1 files changed, 118 insertions, 0 deletions
diff --git a/xlators/features/glupy/src/gluster.py b/xlators/features/glupy/src/gluster.py
new file mode 100644
index 00000000000..ac732fb1733
--- /dev/null
+++ b/xlators/features/glupy/src/gluster.py
@@ -0,0 +1,118 @@
+import sys
+from ctypes import *
+
+dl = CDLL("",RTLD_GLOBAL)
+
+class call_frame_t (Structure):
+	pass
+
+class dict_t (Structure):
+	pass
+
+class fd_t (Structure):
+	pass
+
+class iatt_t (Structure):
+	pass
+
+class inode_t (Structure):
+	pass
+
+class loc_t (Structure):
+	_fields_ = [
+		( "path",	c_char_p ),
+		( "name",	c_char_p ),
+		( "inode",	c_void_p ),
+		( "parent",	c_void_p ),
+		# Not quite correct, but easier to manipulate.
+		( "gfid", c_uint * 4 ),
+		( "pargfid", c_uint * 4 ),
+	]
+
+class xlator_t (Structure):
+	pass
+
+def _init_op (a_class, fop, cbk, wind, unwind):
+	# Decorators, used by translators. We could pass the signatures as
+	# parameters, but it's actually kind of nice to keep them around for
+	# inspection.
+	a_class.fop_type = apply(CFUNCTYPE,a_class.fop_sig)
+	a_class.cbk_type = apply(CFUNCTYPE,a_class.cbk_sig)
+	# Dispatch-function registration.
+	fop.restype = None
+	fop.argtypes = [ c_long, a_class.fop_type ]
+	# Callback-function registration.
+	cbk.restype = None
+	cbk.argtypes = [ c_long, a_class.cbk_type ]
+	# STACK_WIND function.
+	wind.restype = None
+	wind.argtypes = list(a_class.fop_sig[1:])
+	# STACK_UNWIND function.
+	unwind.restype = None
+	unwind.argtypes = list(a_class.cbk_sig[1:])
+
+class OpLookup:
+	fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
+		   POINTER(loc_t), POINTER(dict_t))
+	cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
+		   c_int, c_int, POINTER(inode_t), POINTER(iatt_t),
+		   POINTER(dict_t), POINTER(iatt_t))
+_init_op (OpLookup, dl.set_lookup_fop, dl.set_lookup_cbk,
+		    dl.wind_lookup,    dl.unwind_lookup)
+
+class OpCreate:
+	fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t),
+		   POINTER(loc_t), c_int, c_uint, c_uint, POINTER(fd_t),
+		   POINTER(dict_t))
+	cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t),
+		   c_int, c_int, POINTER(fd_t), POINTER(inode_t),
+		   POINTER(iatt_t), POINTER(iatt_t), POINTER(iatt_t),
+		   POINTER(dict_t))
+_init_op (OpCreate, dl.set_create_fop, dl.set_create_cbk,
+		    dl.wind_create,    dl.unwind_create)
+
+class Translator:
+	def __init__ (self, c_this):
+		# This is only here to keep references to the stubs we create,
+		# because ctypes doesn't and glupy.so can't because it doesn't
+		# get a pointer to the actual Python object. It's a dictionary
+		# instead of a list in case we ever allow changing fops/cbks
+		# after initialization and need to look them up.
+		self.stub_refs = {}
+		funcs = dir(self.__class__)
+		if "lookup_fop" in funcs:
+			@OpLookup.fop_type
+			def stub (frame, this, loc, xdata, s=self):
+				return s.lookup_fop (frame, this, loc, xdata)
+			self.stub_refs["lookup_fop"] = stub
+			dl.set_lookup_fop(c_this,stub)
+		if "lookup_cbk" in funcs:
+			@OpLookup.cbk_type
+			def stub (frame, cookie, this, op_ret, op_errno, inode,
+				  buf, xdata, postparent, s=self):
+				return s.lookup_cbk(frame, cookie, this, op_ret,
+						    op_errno, inode, buf, xdata,
+						    postparent)
+			self.stub_refs["lookup_cbk"] = stub
+			dl.set_lookup_cbk(c_this,stub)
+		if "create_fop" in funcs:
+			@OpCreate.fop_type
+			def stub (frame, this, loc, flags, mode, umask, fd,
+				  xdata, s=self):
+				return s.create_fop (frame, this, loc, flags,
+						     mode, umask, fd, xdata)
+			self.stub_refs["create_fop"] = stub
+			dl.set_create_fop(c_this,stub)
+		if "create_cbk" in funcs:
+			@OpCreate.cbk_type
+			def stub (frame, cookie, this, op_ret, op_errno, fd,
+				  inode, buf, preparent, postparent, xdata,
+				  s=self):
+				return s.create_cbk (frame, cookie, this,
+						     op_ret, op_errno, fd,
+						     inode, buf, preparent,
+						     postparent, xdata)
+				return 0
+			self.stub_refs["create_cbk"] = stub
+			dl.set_create_cbk(c_this,stub)
+