core/various: python3 compat, prepare for python2 -> python3

see https://review.gluster.org/#/c/19788/

use print fn from __future__

Change-Id: If5075d8d9ca9641058fbc71df8a52aa35804cda4
updates: #411
Signed-off-by: Kaleb S. KEITHLEY <kkeithle@redhat.com>

11 files changed, 204 insertions, 190 deletions

diff --git a/xlators/experimental/fdl/src/gen_dumper.py b/xlators/experimental/fdl/src/gen_dumper.py
index 2950be44e01..363ba6ce63f 100755
--- a/xlators/experimental/fdl/src/gen_dumper.py
+++ b/xlators/experimental/fdl/src/gen_dumper.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python2
 
+from __future__ import print_function
 import os
 import re
 import sys
@@ -109,8 +110,8 @@ def load_fragments (path="recon-tmpl.c"):
 
 if __name__ == "__main__":
 	fragments = load_fragments(sys.argv[1])
-	print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
-	print fragments["PROLOG"]
-	print gen_functions()
-	print fragments["EPILOG"].replace("@SWITCH_BODY@",gen_cases())
-	print "/* END GENERATED CODE */"
+	print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
+	print(fragments["PROLOG"])
+	print(gen_functions())
+	print(fragments["EPILOG"].replace("@SWITCH_BODY@",gen_cases()))
+	print("/* END GENERATED CODE */")
diff --git a/xlators/experimental/fdl/src/gen_fdl.py b/xlators/experimental/fdl/src/gen_fdl.py
index 136aa112861..d2e7dd5dfb2 100755
--- a/xlators/experimental/fdl/src/gen_fdl.py
+++ b/xlators/experimental/fdl/src/gen_fdl.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python2
 
+from __future__ import print_function
 import os
 import sys
 
@@ -325,29 +326,29 @@ def gen_fdl ():
 		fop_subs[name]["@LEN_CODE@"] = len_code[:-1]
 		fop_subs[name]["@SER_CODE@"] = ser_code[:-1]
 		if 'len' in gen_funcs:
-			print generate(LEN_TEMPLATE,name,fop_subs)
+			print(generate(LEN_TEMPLATE,name,fop_subs))
 		if 'serialize' in gen_funcs:
-			print generate(SER_TEMPLATE,name,fop_subs)
+			print(generate(SER_TEMPLATE,name,fop_subs))
 		if name == 'writev':
-			print "#define DESTAGE_ASYNC"
+			print("#define DESTAGE_ASYNC")
 		if 'callback' in gen_funcs:
-			print generate(CBK_TEMPLATE,name,cbk_subs)
+			print(generate(CBK_TEMPLATE,name,cbk_subs))
 		if 'continue' in gen_funcs:
-			print generate(CONTINUE_TEMPLATE,name,fop_subs)
+			print(generate(CONTINUE_TEMPLATE,name,fop_subs))
 		if 'fop' in gen_funcs:
-			print generate(FOP_TEMPLATE,name,fop_subs)
+			print(generate(FOP_TEMPLATE,name,fop_subs))
 		if name == 'writev':
-			print "#undef DESTAGE_ASYNC"
+			print("#undef DESTAGE_ASYNC")
 		entrypoints.append(name)
-	print "struct xlator_fops fops = {"
+	print("struct xlator_fops fops = {")
 	for ep in entrypoints:
-		print "\t.%s = fdl_%s," % (ep, ep)
-	print "};"
+		print("\t.%s = fdl_%s," % (ep, ep))
+	print("};")
 
 for l in open(sys.argv[1],'r').readlines():
 	if l.find('#pragma generate') != -1:
-		print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
+		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
 		gen_fdl()
-		print "/* END GENERATED CODE */"
+		print("/* END GENERATED CODE */")
 	else:
-		print l[:-1]
+		print(l[:-1])
diff --git a/xlators/experimental/fdl/src/gen_recon.py b/xlators/experimental/fdl/src/gen_recon.py
index af1765517f3..75323ea3dd9 100755
--- a/xlators/experimental/fdl/src/gen_recon.py
+++ b/xlators/experimental/fdl/src/gen_recon.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python2
 
+from __future__ import print_function
 import os
 import re
 import string
@@ -210,8 +211,8 @@ def load_fragments (path="recon-tmpl.c"):
 
 if __name__ == "__main__":
 	fragments = load_fragments(sys.argv[1])
-	print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
-	print fragments["PROLOG"]
-	print gen_functions()
-	print fragments["EPILOG"].replace("@SWITCH_BODY@",gen_cases())
-	print "/* END GENERATED CODE */"
+	print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
+	print(fragments["PROLOG"])
+	print(gen_functions())
+	print(fragments["EPILOG"].replace("@SWITCH_BODY@",gen_cases()))
+	print("/* END GENERATED CODE */")
diff --git a/xlators/experimental/jbr-client/src/gen-fops.py b/xlators/experimental/jbr-client/src/gen-fops.py
index 64bd8b06cae..9893e0c5968 100755
--- a/xlators/experimental/jbr-client/src/gen-fops.py
+++ b/xlators/experimental/jbr-client/src/gen-fops.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python2
 
+from __future__ import print_function
 import os
 import re
 import string
@@ -43,15 +44,15 @@ def gen_client (templates):
 		if name == 'getspec':
 			# It's not real if it doesn't have a stub function.
 			continue
-		print generate(templates['cbk'],name,cbk_subs)
-		print generate(templates['cont-func'],name,fop_subs)
-		print generate(templates['fop'],name,fop_subs)
+		print(generate(templates['cbk'],name,cbk_subs))
+		print(generate(templates['cont-func'],name,fop_subs))
+		print(generate(templates['fop'],name,fop_subs))
 
 tmpl = load_templates(sys.argv[1])
 for l in open(sys.argv[2],'r').readlines():
 	if l.find('#pragma generate') != -1:
-		print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
+		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
 		gen_client(tmpl)
-		print "/* END GENERATED CODE */"
+		print("/* END GENERATED CODE */")
 	else:
-		print l[:-1]
+		print(l[:-1])
diff --git a/xlators/experimental/jbr-server/src/gen-fops.py b/xlators/experimental/jbr-server/src/gen-fops.py
index 2005e3932d4..e728f473372 100755
--- a/xlators/experimental/jbr-server/src/gen-fops.py
+++ b/xlators/experimental/jbr-server/src/gen-fops.py
@@ -5,6 +5,7 @@
 # between leader and followers (including fan-out), and basic error checking
 # to be centralized one place, with per-operation code kept to a minimum.
 
+from __future__ import print_function
 import os
 import re
 import string
@@ -132,49 +133,49 @@ def gen_server (templates):
 		if ("fsync" in flags) or ("queue" in flags):
 			flags.append("need_fd")
 		for fname in flags:
-			print "#define JBR_CG_%s" % fname.upper()
+			print("#define JBR_CG_%s" % fname.upper())
 
 		if 'complete' in gen_funcs:
-			print generate(templates[kind+"-complete"],
-					name,cbk_subs)
+			print(generate(templates[kind+"-complete"],
+					name,cbk_subs))
 
 		if 'continue' in gen_funcs:
-			print generate(templates[kind+"-continue"],
-					name,fop_subs)
+			print(generate(templates[kind+"-continue"],
+					name,fop_subs))
 
 		if 'fan-in' in gen_funcs:
-			print generate(templates[kind+"-fan-in"],
-					name,cbk_subs)
+			print(generate(templates[kind+"-fan-in"],
+					name,cbk_subs))
 
 		if 'dispatch' in gen_funcs:
-			print generate(templates[kind+"-dispatch"],
-					name,fop_subs)
+			print(generate(templates[kind+"-dispatch"],
+					name,fop_subs))
 
 		if 'call_dispatch' in gen_funcs:
-			print generate(templates[kind+"-call_dispatch"],
-					name,fop_subs)
+			print(generate(templates[kind+"-call_dispatch"],
+					name,fop_subs))
 
 		if 'perform_local_op' in gen_funcs:
-			print generate(templates[kind+"-perform_local_op"],
-					name, fop_subs)
+			print(generate(templates[kind+"-perform_local_op"],
+					name, fop_subs))
 
 		if 'fop' in gen_funcs:
-			print generate(templates[kind+"-fop"],name,fop_subs)
+			print(generate(templates[kind+"-fop"],name,fop_subs))
 
 		for fname in flags:
-			print "#undef JBR_CG_%s" % fname.upper()
+			print("#undef JBR_CG_%s" % fname.upper())
 		fops_done.append(name)
 	# Just for fun, emit the fops table too.
 	print("struct xlator_fops fops = {")
 	for x in fops_done:
-		print("	.%s = jbr_%s,"%(x,x))
+		print(("	.%s = jbr_%s,"%(x,x)))
 	print("};")
 
 tmpl = load_templates(sys.argv[1])
 for l in open(sys.argv[2],'r').readlines():
 	if l.find('#pragma generate') != -1:
-		print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
+		print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
 		gen_server(tmpl)
-		print "/* END GENERATED CODE */"
+		print("/* END GENERATED CODE */")
 	else:
-		print l[:-1]
+		print(l[:-1])
diff --git a/xlators/features/changelog/lib/examples/python/changes.py b/xlators/features/changelog/lib/examples/python/changes.py
index c0341b52ca3..077c1108cce 100644
--- a/xlators/features/changelog/lib/examples/python/changes.py
+++ b/xlators/features/changelog/lib/examples/python/changes.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python2
 
+from __future__ import print_function
 import os
 import sys
 import time
@@ -16,18 +17,18 @@ def get_changes(brick, scratch_dir, log_file, log_level, interval):
             cl.cl_scan()
             change_list = cl.cl_getchanges()
             if change_list:
-                print change_list
+                print(change_list)
             for change in change_list:
-                print('done with %s' % (change))
+                print(('done with %s' % (change)))
                 cl.cl_done(change)
             time.sleep(interval)
     except OSError:
         ex = sys.exc_info()[1]
-        print ex
+        print(ex)
 
 if __name__ == '__main__':
     if len(sys.argv) != 6:
-        print("usage: %s <brick> <scratch-dir> <log-file> <fetch-interval>"
-              % (sys.argv[0]))
+        print(("usage: %s <brick> <scratch-dir> <log-file> <fetch-interval>"
+              % (sys.argv[0])))
         sys.exit(1)
     get_changes(sys.argv[1], sys.argv[2], sys.argv[3], 9, int(sys.argv[4]))
diff --git a/xlators/features/cloudsync/src/cloudsync-fops-c.py b/xlators/features/cloudsync/src/cloudsync-fops-c.py
index e3030724468..fda56752871 100644
--- a/xlators/features/cloudsync/src/cloudsync-fops-c.py
+++ b/xlators/features/cloudsync/src/cloudsync-fops-c.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python
 
+from __future__ import print_function
 import os
 import sys
 
@@ -289,17 +290,17 @@ special_fops = ['readdirp', 'statfs', 'setxattr', 'unlink', 'getxattr',
 def gen_defaults():
     for name in ops:
         if name in fd_data_modify_op_fop_template:
-            print generate(FD_DATA_MODIFYING_OP_FOP_CBK_TEMPLATE, name, cbk_subs)
-            print generate(FD_DATA_MODIFYING_RESUME_OP_FOP_TEMPLATE, name, fop_subs)
-            print generate(FD_DATA_MODIFYING_OP_FOP_TEMPLATE, name, fop_subs)
+            print(generate(FD_DATA_MODIFYING_OP_FOP_CBK_TEMPLATE, name, cbk_subs))
+            print(generate(FD_DATA_MODIFYING_RESUME_OP_FOP_TEMPLATE, name, fop_subs))
+            print(generate(FD_DATA_MODIFYING_OP_FOP_TEMPLATE, name, fop_subs))
         elif name in loc_stat_op_fop_template:
-            print generate(LOC_STAT_OP_FOP_CBK_TEMPLATE, name, cbk_subs)
-            print generate(LOC_STAT_OP_FOP_TEMPLATE, name, fop_subs)
+            print(generate(LOC_STAT_OP_FOP_CBK_TEMPLATE, name, cbk_subs))
+            print(generate(LOC_STAT_OP_FOP_TEMPLATE, name, fop_subs))
 
 for l in open(sys.argv[1], 'r').readlines():
     if l.find('#pragma generate') != -1:
-        print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
+        print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
         gen_defaults()
-        print "/* END GENERATED CODE */"
+        print("/* END GENERATED CODE */")
     else:
-        print l[:-1]
+        print(l[:-1])
diff --git a/xlators/features/cloudsync/src/cloudsync-fops-h.py b/xlators/features/cloudsync/src/cloudsync-fops-h.py
index 552c6b58e3a..37dfa5b10be 100644
--- a/xlators/features/cloudsync/src/cloudsync-fops-h.py
+++ b/xlators/features/cloudsync/src/cloudsync-fops-h.py
@@ -1,5 +1,6 @@
 #!/usr/bin/python
 
+from __future__ import print_function
 import os
 import sys
 
@@ -18,13 +19,13 @@ def gen_defaults():
     for name, value in ops.iteritems():
         if name == 'getspec':
             continue
-        print generate(OP_FOP_TEMPLATE, name, fop_subs)
+        print(generate(OP_FOP_TEMPLATE, name, fop_subs))
 
 
 for l in open(sys.argv[1], 'r').readlines():
     if l.find('#pragma generate') != -1:
-        print "/* BEGIN GENERATED CODE - DO NOT MODIFY */"
+        print("/* BEGIN GENERATED CODE - DO NOT MODIFY */")
         gen_defaults()
-        print "/* END GENERATED CODE */"
+        print("/* END GENERATED CODE */")
     else:
-        print l[:-1]
+        print(l[:-1])
diff --git a/xlators/features/glupy/examples/debug-trace.py b/xlators/features/glupy/examples/debug-trace.py
index 6eef1b58b8f..ca726ed21cb 100644
--- a/xlators/features/glupy/examples/debug-trace.py
+++ b/xlators/features/glupy/examples/debug-trace.py
@@ -1,3 +1,5 @@
+
+from __future__ import print_function
 import sys
 import stat
 from uuid import UUID
@@ -106,8 +108,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.gfid)
-                print("GLUPY TRACE LOOKUP FOP- {0:d}: gfid={1:s}; " +
-                      "path={2:s}").format(unique, gfid, loc.contents.path)
+                print(("GLUPY TRACE LOOKUP FOP- {0:d}: gfid={1:s}; " +
+                      "path={2:s}").format(unique, gfid, loc.contents.path))
                 self.gfids[key] = gfid
                 dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata)
                 return 0
@@ -120,18 +122,18 @@ class xlator(Translator):
                         gfid = uuid2str(buf.contents.ia_gfid)
                         statstr = trace_stat2str(buf)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE LOOKUP CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE LOOKUP CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; *buf={3:s}; " +
                               "*postparent={4:s}").format(unique, gfid,
                                                           op_ret, statstr,
-                                                          postparentstr)
+                                                          postparentstr))
                 else:
                         gfid = self.gfids[key]
-                        print("GLUPY TRACE LOOKUP CBK - {0:d}: gfid={1:s};" +
+                        print(("GLUPY TRACE LOOKUP CBK - {0:d}: gfid={1:s};" +
                               " op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                       gfid,
                                                                       op_ret,
-                                                                      op_errno)
+                                                                      op_errno))
                 del self.gfids[key]
                 dl.unwind_lookup(frame, cookie, this, op_ret, op_errno,
                                  inode, buf, xdata, postparent)
@@ -141,10 +143,10 @@ class xlator(Translator):
                        xdata):
                 unique = dl.get_rootunique(frame)
                 gfid = uuid2str(loc.contents.gfid)
-                print("GLUPY TRACE CREATE FOP- {0:d}: gfid={1:s}; path={2:s}; " +
+                print(("GLUPY TRACE CREATE FOP- {0:d}: gfid={1:s}; path={2:s}; " +
                       "fd={3:s}; flags=0{4:o}; mode=0{5:o}; " +
                       "umask=0{6:o}").format(unique, gfid, loc.contents.path,
-                                             fd, flags, mode, umask)
+                                             fd, flags, mode, umask))
                 dl.wind_create(frame, POINTER(xlator_t)(), loc, flags,mode,
                                umask, fd, xdata)
                 return 0
@@ -157,16 +159,16 @@ class xlator(Translator):
                         statstr = trace_stat2str(buf)
                         preparentstr = trace_stat2str(preparent)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE CREATE CBK- {0:d}: gfid={1:s};" +
+                        print(("GLUPY TRACE CREATE CBK- {0:d}: gfid={1:s};" +
                               " op_ret={2:d}; fd={3:s}; *stbuf={4:s}; " +
                               "*preparent={5:s};" +
                               " *postparent={6:s}").format(unique, gfid, op_ret,
                                                            fd, statstr,
                                                            preparentstr,
-                                                           postparentstr)
+                                                           postparentstr))
                 else:
-                        print ("GLUPY TRACE CREATE CBK- {0:d}: op_ret={1:d}; " +
-                              "op_errno={2:d}").format(unique, op_ret, op_errno)
+                        print(("GLUPY TRACE CREATE CBK- {0:d}: op_ret={1:d}; " +
+                              "op_errno={2:d}").format(unique, op_ret, op_errno))
                 dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd,
                                  inode, buf, preparent, postparent, xdata)
                 return 0
@@ -175,10 +177,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE OPEN FOP- {0:d}: gfid={1:s}; path={2:s}; "+
+                print(("GLUPY TRACE OPEN FOP- {0:d}: gfid={1:s}; path={2:s}; "+
                       "flags={3:d}; fd={4:s}").format(unique, gfid,
                                                       loc.contents.path, flags,
-                                                      fd)
+                                                      fd))
                 self.gfids[key] = gfid
                 dl.wind_open(frame, POINTER(xlator_t)(), loc, flags, fd, xdata)
                 return 0
@@ -187,9 +189,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE OPEN CBK- {0:d}: gfid={1:s}; op_ret={2:d}; "
+                print(("GLUPY TRACE OPEN CBK- {0:d}: gfid={1:s}; op_ret={2:d}; "
                       "op_errno={3:d}; *fd={4:s}").format(unique, gfid,
-                                                          op_ret, op_errno, fd)
+                                                          op_ret, op_errno, fd))
                 del self.gfids[key]
                 dl.unwind_open(frame, cookie, this, op_ret, op_errno, fd,
                                xdata)
@@ -199,10 +201,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE READV FOP- {0:d}: gfid={1:s}; "+
+                print(("GLUPY TRACE READV FOP- {0:d}: gfid={1:s}; "+
                       "fd={2:s}; size ={3:d}; offset={4:d}; " +
                       "flags=0{5:x}").format(unique, gfid, fd, size, offset,
-                                             flags)
+                                             flags))
                 self.gfids[key] = gfid
                 dl.wind_readv (frame, POINTER(xlator_t)(), fd, size, offset,
                                flags, xdata)
@@ -215,17 +217,17 @@ class xlator(Translator):
                 gfid = self.gfids[key]
                 if op_ret >= 0:
                         statstr = trace_stat2str(buf)
-                        print("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+
+                        print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+
                               "op_ret={2:d}; *buf={3:s};").format(unique, gfid,
                                                                   op_ret,
-                                                                  statstr)
+                                                                  statstr))
 
                 else:
-                        print("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+
+                        print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+
                               "op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                      gfid,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 del self.gfids[key]
                 dl.unwind_readv (frame, cookie, this, op_ret, op_errno,
                                  vector, count, buf, iobref, xdata)
@@ -236,10 +238,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE  WRITEV FOP- {0:d}: gfid={1:s}; " +
+                print(("GLUPY TRACE  WRITEV FOP- {0:d}: gfid={1:s}; " +
                       "fd={2:s}; count={3:d}; offset={4:d}; " +
                       "flags=0{5:x}").format(unique, gfid, fd, count, offset,
-                                             flags)
+                                             flags))
                 self.gfids[key] = gfid
                 dl.wind_writev(frame, POINTER(xlator_t)(), fd, vector, count,
                                offset, flags, iobref, xdata)
@@ -252,17 +254,17 @@ class xlator(Translator):
                 if op_ret >= 0:
                         preopstr = trace_stat2str(prebuf)
                         postopstr = trace_stat2str(postbuf)
-                        print("GLUPY TRACE WRITEV CBK- {0:d}: op_ret={1:d}; " +
+                        print(("GLUPY TRACE WRITEV CBK- {0:d}: op_ret={1:d}; " +
                               "*prebuf={2:s}; " +
                               "*postbuf={3:s}").format(unique, op_ret, preopstr,
-                                                       postopstr)
+                                                       postopstr))
                 else:
                         gfid = self.gfids[key]
-                        print("GLUPY TRACE WRITEV CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE WRITEV CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                      gfid,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 del self.gfids[key]
                 dl.unwind_writev (frame, cookie, this, op_ret, op_errno,
                                   prebuf, postbuf, xdata)
@@ -272,8 +274,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE OPENDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+
-                      "fd={3:s}").format(unique, gfid, loc.contents.path, fd)
+                print(("GLUPY TRACE OPENDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+
+                      "fd={3:s}").format(unique, gfid, loc.contents.path, fd))
                 self.gfids[key] = gfid
                 dl.wind_opendir(frame, POINTER(xlator_t)(), loc, fd, xdata)
                 return 0
@@ -283,9 +285,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE OPENDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+
+                print(("GLUPY TRACE OPENDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+
                       " op_errno={3:d}; fd={4:s}").format(unique, gfid, op_ret,
-                                                          op_errno, fd)
+                                                          op_errno, fd))
                 del self.gfids[key]
                 dl.unwind_opendir(frame, cookie, this, op_ret, op_errno,
                                   fd, xdata)
@@ -295,9 +297,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE READDIR FOP- {0:d}:  gfid={1:s}; fd={2:s}; " +
+                print(("GLUPY TRACE READDIR FOP- {0:d}:  gfid={1:s}; fd={2:s}; " +
                       "size={3:d}; offset={4:d}").format(unique, gfid, fd, size,
-                                                         offset)
+                                                         offset))
                 self.gfids[key] = gfid
                 dl.wind_readdir(frame, POINTER(xlator_t)(), fd, size, offset,
                                 xdata)
@@ -308,8 +310,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE READDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+
-                      " op_errno={3:d}").format(unique, gfid, op_ret, op_errno)
+                print(("GLUPY TRACE READDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+
+                      " op_errno={3:d}").format(unique, gfid, op_ret, op_errno))
                 del self.gfids[key]
                 dl.unwind_readdir(frame, cookie, this, op_ret, op_errno, buf,
                                   xdata)
@@ -319,9 +321,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE READDIRP FOP- {0:d}: gfid={1:s}; fd={2:s}; "+
+                print(("GLUPY TRACE READDIRP FOP- {0:d}: gfid={1:s}; fd={2:s}; "+
                       " size={3:d}; offset={4:d}").format(unique, gfid, fd, size,
-                                                          offset)
+                                                          offset))
                 self.gfids[key] = gfid
                 dl.wind_readdirp(frame, POINTER(xlator_t)(), fd, size, offset,
                                  dictionary)
@@ -332,9 +334,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE READDIRP CBK- {0:d}: gfid={1:s}; "+
+                print(("GLUPY TRACE READDIRP CBK- {0:d}: gfid={1:s}; "+
                       "op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                             op_ret, op_errno)
+                                                             op_ret, op_errno))
                 del self.gfids[key]
                 dl.unwind_readdirp(frame, cookie, this, op_ret, op_errno, buf,
                                   xdata)
@@ -343,10 +345,10 @@ class xlator(Translator):
         def mkdir_fop(self, frame, this, loc, mode, umask, xdata):
                 unique = dl.get_rootunique(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE MKDIR FOP- {0:d}: gfid={1:s}; path={2:s}; " +
+                print(("GLUPY TRACE MKDIR FOP- {0:d}: gfid={1:s}; path={2:s}; " +
                       "mode={3:d}; umask=0{4:o}").format(unique, gfid,
                                                          loc.contents.path, mode,
-                                                         umask)
+                                                         umask))
                 dl.wind_mkdir(frame, POINTER(xlator_t)(), loc, mode, umask,
                               xdata)
                 return 0
@@ -359,15 +361,15 @@ class xlator(Translator):
                         statstr = trace_stat2str(buf)
                         preparentstr = trace_stat2str(preparent)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE MKDIR CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE MKDIR CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; *stbuf={3:s}; *prebuf={4:s}; "+
                               "*postbuf={5:s} ").format(unique, gfid, op_ret,
                                                         statstr,
                                                         preparentstr,
-                                                        postparentstr)
+                                                        postparentstr))
                 else:
-                        print("GLUPY TRACE MKDIR CBK- {0:d}:  op_ret={1:d}; "+
-                              "op_errno={2:d}").format(unique, op_ret, op_errno)
+                        print(("GLUPY TRACE MKDIR CBK- {0:d}:  op_ret={1:d}; "+
+                              "op_errno={2:d}").format(unique, op_ret, op_errno))
                 dl.unwind_mkdir(frame, cookie, this, op_ret, op_errno, inode,
                                 buf, preparent, postparent, xdata)
                 return 0
@@ -376,9 +378,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE RMDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+
+                print(("GLUPY TRACE RMDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+
                       "flags={3:d}").format(unique, gfid, loc.contents.path,
-                                            flags)
+                                            flags))
                 self.gfids[key] = gfid
                 dl.wind_rmdir(frame, POINTER(xlator_t)(), loc, flags, xdata)
                 return 0
@@ -391,17 +393,17 @@ class xlator(Translator):
                 if op_ret == 0:
                         preparentstr = trace_stat2str(preparent)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; *prebuf={3:s}; "+
                               "*postbuf={4:s}").format(unique, gfid, op_ret,
                                                        preparentstr,
-                                                       postparentstr)
+                                                       postparentstr))
                 else:
-                        print("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                      gfid,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 del self.gfids[key]
                 dl.unwind_rmdir(frame, cookie, this, op_ret, op_errno,
                                 preparent, postparent, xdata)
@@ -411,8 +413,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE STAT FOP- {0:d}: gfid={1:s}; " +
-                      " path={2:s}").format(unique, gfid, loc.contents.path)
+                print(("GLUPY TRACE STAT FOP- {0:d}: gfid={1:s}; " +
+                      " path={2:s}").format(unique, gfid, loc.contents.path))
                 self.gfids[key] = gfid
                 dl.wind_stat(frame, POINTER(xlator_t)(), loc, xdata)
                 return 0
@@ -424,17 +426,17 @@ class xlator(Translator):
                 gfid = self.gfids[key]
                 if op_ret == 0:
                         statstr = trace_stat2str(buf)
-                        print("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d};  *buf={3:s};").format(unique,
                                                                    gfid,
                                                                    op_ret,
-                                                                   statstr)
+                                                                   statstr))
                 else:
-                        print("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                      gfid,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 del self.gfids[key]
                 dl.unwind_stat(frame, cookie, this, op_ret, op_errno,
                                buf, xdata)
@@ -444,8 +446,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE FSTAT FOP- {0:d}:  gfid={1:s}; " +
-                      "fd={2:s}").format(unique, gfid, fd)
+                print(("GLUPY TRACE FSTAT FOP- {0:d}:  gfid={1:s}; " +
+                      "fd={2:s}").format(unique, gfid, fd))
                 self.gfids[key] = gfid
                 dl.wind_fstat(frame, POINTER(xlator_t)(), fd, xdata)
                 return 0
@@ -457,17 +459,17 @@ class xlator(Translator):
                 gfid = self.gfids[key]
                 if op_ret == 0:
                         statstr = trace_stat2str(buf)
-                        print("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+
+                        print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+
                               " op_ret={2:d}; *buf={3:s}").format(unique,
                                                                   gfid,
                                                                   op_ret,
-                                                                  statstr)
+                                                                  statstr))
                 else:
-                        print("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+
+                        print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+
                               "op_ret={2:d}; op_errno={3:d}").format(unique.
                                                                      gfid,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 del self.gfids[key]
                 dl.unwind_fstat(frame, cookie, this, op_ret, op_errno,
                                 buf, xdata)
@@ -479,8 +481,8 @@ class xlator(Translator):
                         gfid = uuid2str(loc.contents.inode.contents.gfid)
                 else:
                         gfid = "0"
-                print("GLUPY TRACE STATFS FOP- {0:d}: gfid={1:s}; "+
-                      "path={2:s}").format(unique, gfid, loc.contents.path)
+                print(("GLUPY TRACE STATFS FOP- {0:d}: gfid={1:s}; "+
+                      "path={2:s}").format(unique, gfid, loc.contents.path))
                 dl.wind_statfs(frame, POINTER(xlator_t)(), loc, xdata)
                 return 0
 
@@ -489,13 +491,13 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 if op_ret == 0:
                         #TBD: print buf (pointer to an iovec type object)
-                        print("GLUPY TRACE STATFS CBK {0:d}: "+
-                              "op_ret={1:d}").format(unique, op_ret)
+                        print(("GLUPY TRACE STATFS CBK {0:d}: "+
+                              "op_ret={1:d}").format(unique, op_ret))
                 else:
-                        print("GLUPY TRACE STATFS CBK-  {0:d}"+
+                        print(("GLUPY TRACE STATFS CBK-  {0:d}"+
                               "op_ret={1:d}; op_errno={2:d}").format(unique,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 dl.unwind_statfs(frame, cookie, this, op_ret, op_errno,
                                  buf, xdata)
                 return 0
@@ -504,9 +506,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE GETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+
+                print(("GLUPY TRACE GETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+
                       " name={3:s}").format(unique, gfid, loc.contents.path,
-                                            name)
+                                            name))
                 self.gfids[key]=gfid
                 dl.wind_getxattr(frame, POINTER(xlator_t)(), loc, name, xdata)
                 return 0
@@ -516,10 +518,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE GETXATTR CBK- {0:d}: gfid={1:s}; "+
+                print(("GLUPY TRACE GETXATTR CBK- {0:d}: gfid={1:s}; "+
                       "op_ret={2:d}; op_errno={3:d}; "+
                       " dictionary={4:s}").format(unique, gfid, op_ret, op_errno,
-                                                  dictionary)
+                                                  dictionary))
                 del self.gfids[key]
                 dl.unwind_getxattr(frame, cookie, this, op_ret, op_errno,
                                    dictionary, xdata)
@@ -529,8 +531,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE FGETXATTR FOP- {0:d}: gfid={1:s}; fd={2:s}; "+
-                      "name={3:s}").format(unique, gfid, fd, name)
+                print(("GLUPY TRACE FGETXATTR FOP- {0:d}: gfid={1:s}; fd={2:s}; "+
+                      "name={3:s}").format(unique, gfid, fd, name))
                 self.gfids[key] = gfid
                 dl.wind_fgetxattr(frame, POINTER(xlator_t)(), fd, name, xdata)
                 return 0
@@ -540,10 +542,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE FGETXATTR CBK- {0:d}: gfid={1:s}; "+
+                print(("GLUPY TRACE FGETXATTR CBK- {0:d}: gfid={1:s}; "+
                       "op_ret={2:d}; op_errno={3:d};"+
                       " dictionary={4:s}").format(unique, gfid, op_ret,
-                                                  op_errno, dictionary)
+                                                  op_errno, dictionary))
                 del self.gfids[key]
                 dl.unwind_fgetxattr(frame, cookie, this, op_ret, op_errno,
                                     dictionary, xdata)
@@ -553,9 +555,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE SETXATTR FOP- {0:d}:  gfid={1:s}; path={2:s};"+
+                print(("GLUPY TRACE SETXATTR FOP- {0:d}:  gfid={1:s}; path={2:s};"+
                       " flags={3:d}").format(unique, gfid, loc.contents.path,
-                                             flags)
+                                             flags))
                 self.gfids[key] = gfid
                 dl.wind_setxattr(frame, POINTER(xlator_t)(), loc, dictionary,
                                  flags, xdata)
@@ -565,9 +567,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE SETXATTR CBK- {0:d}: gfid={1:s}; "+
+                print(("GLUPY TRACE SETXATTR CBK- {0:d}: gfid={1:s}; "+
                       "op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                             op_ret, op_errno)
+                                                             op_ret, op_errno))
                 del self.gfids[key]
                 dl.unwind_setxattr(frame, cookie, this, op_ret, op_errno,
                                    xdata)
@@ -577,8 +579,8 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(fd.contents.inode.contents.gfid)
-                print("GLUPY TRACE FSETXATTR FOP- {0:d}: gfid={1:s}; fd={2:p}; "+
-                      "flags={3:d}").format(unique, gfid, fd, flags)
+                print(("GLUPY TRACE FSETXATTR FOP- {0:d}: gfid={1:s}; fd={2:p}; "+
+                      "flags={3:d}").format(unique, gfid, fd, flags))
                 self.gfids[key] = gfid
                 dl.wind_fsetxattr(frame, POINTER(xlator_t)(), fd, dictionary,
                                   flags, xdata)
@@ -588,9 +590,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE FSETXATTR CBK- {0:d}: gfid={1:s};  "+
+                print(("GLUPY TRACE FSETXATTR CBK- {0:d}: gfid={1:s};  "+
                       "op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                             op_ret, op_errno)
+                                                             op_ret, op_errno))
                 del self.gfids[key]
                 dl.unwind_fsetxattr(frame, cookie, this, op_ret, op_errno,
                                    xdata)
@@ -600,10 +602,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE REMOVEXATTR FOP- {0:d}:  gfid={1:s}; "+
+                print(("GLUPY TRACE REMOVEXATTR FOP- {0:d}:  gfid={1:s}; "+
                       "path={2:s}; name={3:s}").format(unique, gfid,
                                                        loc.contents.path,
-                                                       name)
+                                                       name))
                 self.gfids[key] = gfid
                 dl.wind_removexattr(frame, POINTER(xlator_t)(), loc, name,
                                     xdata)
@@ -614,9 +616,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = self.gfids[key]
-                print("GLUPY TRACE REMOVEXATTR CBK- {0:d}: gfid={1:s} "+
+                print(("GLUPY TRACE REMOVEXATTR CBK- {0:d}: gfid={1:s} "+
                       " op_ret={2:d}; op_errno={3:d}").format(unique, gfid,
-                                                              op_ret, op_errno)
+                                                              op_ret, op_errno))
                 del self.gfids[key]
                 dl.unwind_removexattr(frame, cookie, this, op_ret, op_errno,
                                       xdata)
@@ -630,12 +632,12 @@ class xlator(Translator):
                 else:
                         newgfid = "0"
                 oldgfid = uuid2str(oldloc.contents.inode.contents.gfid)
-                print("GLUPY TRACE LINK FOP-{0:d}: oldgfid={1:s}; oldpath={2:s};"+
+                print(("GLUPY TRACE LINK FOP-{0:d}: oldgfid={1:s}; oldpath={2:s};"+
                       "newgfid={3:s};"+
                       "newpath={4:s}").format(unique, oldgfid,
                                               oldloc.contents.path,
                                               newgfid,
-                                              newloc.contents.path)
+                                              newloc.contents.path))
                 self.gfids[key] =  oldgfid
                 dl.wind_link(frame, POINTER(xlator_t)(), oldloc, newloc,
                              xdata)
@@ -650,16 +652,16 @@ class xlator(Translator):
                         statstr = trace_stat2str(buf)
                         preparentstr = trace_stat2str(preparent)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE LINK CBK- {0:d}: op_ret={1:d} "+
+                        print(("GLUPY TRACE LINK CBK- {0:d}: op_ret={1:d} "+
                               "*stbuf={2:s}; *prebuf={3:s}; "+
                               "*postbuf={4:s} ").format(unique, op_ret, statstr,
                                                         preparentstr,
-                                                        postparentstr)
+                                                        postparentstr))
                 else:
-                        print("GLUPY TRACE LINK CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE LINK CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; "+
                               "op_errno={3:d}").format(unique, gfid,
-                                                       op_ret, op_errno)
+                                                       op_ret, op_errno))
                 del self.gfids[key]
                 dl.unwind_link(frame, cookie, this, op_ret, op_errno, inode,
                                buf, preparent, postparent, xdata)
@@ -669,9 +671,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE UNLINK FOP- {0:d}; gfid={1:s}; path={2:s}; "+
+                print(("GLUPY TRACE UNLINK FOP- {0:d}; gfid={1:s}; path={2:s}; "+
                       "flag={3:d}").format(unique, gfid, loc.contents.path,
-                                           xflag)
+                                           xflag))
                 self.gfids[key] = gfid
                 dl.wind_unlink(frame, POINTER(xlator_t)(), loc, xflag,
                                xdata)
@@ -685,16 +687,16 @@ class xlator(Translator):
                 if op_ret == 0:
                         preparentstr = trace_stat2str(preparent)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE UNLINK CBK- {0:d}: gfid ={1:s}; "+
+                        print(("GLUPY TRACE UNLINK CBK- {0:d}: gfid ={1:s}; "+
                               "op_ret={2:d}; *prebuf={3:s}; "+
                               "*postbuf={4:s} ").format(unique, gfid, op_ret,
                                                         preparentstr,
-                                                        postparentstr)
+                                                        postparentstr))
                 else:
-                        print("GLUPY TRACE UNLINK CBK: {0:d}: gfid ={1:s}; "+
+                        print(("GLUPY TRACE UNLINK CBK: {0:d}: gfid ={1:s}; "+
                               "op_ret={2:d}; "+
                               "op_errno={3:d}").format(unique, gfid, op_ret,
-                                                       op_errno)
+                                                       op_errno))
                 del self.gfids[key]
                 dl.unwind_unlink(frame, cookie, this, op_ret, op_errno,
                                  preparent, postparent, xdata)
@@ -704,9 +706,9 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE READLINK FOP- {0:d}:  gfid={1:s}; path={2:s};"+
+                print(("GLUPY TRACE READLINK FOP- {0:d}:  gfid={1:s}; path={2:s};"+
                       " size={3:d}").format(unique, gfid, loc.contents.path,
-                                            size)
+                                            size))
                 self.gfids[key] = gfid
                 dl.wind_readlink(frame, POINTER(xlator_t)(), loc, size,
                                xdata)
@@ -719,17 +721,17 @@ class xlator(Translator):
                 gfid  = self.gfids[key]
                 if op_ret == 0:
                         statstr = trace_stat2str(stbuf)
-                        print("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+
+                        print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+
                               " op_ret={2:d}; op_errno={3:d}; *prebuf={4:s}; "+
                               "*postbuf={5:s} ").format(unique, gfid,
                                                         op_ret, op_errno,
-                                                        buf, statstr)
+                                                        buf, statstr))
                 else:
-                        print("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+
+                        print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+
                               " op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                       gfid,
                                                                       op_ret,
-                                                                      op_errno)
+                                                                      op_errno))
                 del self.gfids[key]
                 dl.unwind_readlink(frame, cookie, this, op_ret, op_errno, buf,
                                    stbuf, xdata)
@@ -739,10 +741,10 @@ class xlator(Translator):
                 unique = dl.get_rootunique(frame)
                 key = dl.get_id(frame)
                 gfid = uuid2str(loc.contents.inode.contents.gfid)
-                print("GLUPY TRACE SYMLINK FOP- {0:d}: gfid={1:s}; "+
+                print(("GLUPY TRACE SYMLINK FOP- {0:d}: gfid={1:s}; "+
                       "linkpath={2:s}; path={3:s};"+
                       "umask=0{4:o}").format(unique, gfid, linkpath,
-                                             loc.contents.path, umask)
+                                             loc.contents.path, umask))
                 self.gfids[key] = gfid
                 dl.wind_symlink(frame, POINTER(xlator_t)(), linkpath, loc,
                                 umask, xdata)
@@ -757,18 +759,18 @@ class xlator(Translator):
                         statstr = trace_stat2str(buf)
                         preparentstr = trace_stat2str(preparent)
                         postparentstr = trace_stat2str(postparent)
-                        print("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; *stbuf={3:s}; *preparent={4:s}; "+
                               "*postparent={5:s}").format(unique, gfid,
                                                           op_ret, statstr,
                                                           preparentstr,
-                                                          postparentstr)
+                                                          postparentstr))
                 else:
-                        print("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+
+                        print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+
                               "op_ret={2:d}; op_errno={3:d}").format(unique,
                                                                      gfid,
                                                                      op_ret,
-                                                                     op_errno)
+                                                                     op_errno))
                 del self.gfids[key]
                 dl.unwind_symlink(frame, cookie, this, op_ret, op_errno,
                                   inode, buf, preparent, postparent, xdata)
diff --git a/xlators/features/glupy/examples/helloworld.py b/xlators/features/glupy/examples/helloworld.py
index b565a4e5bc3..282f9207949 100644
--- a/xlators/features/glupy/examples/helloworld.py
+++ b/xlators/features/glupy/examples/helloworld.py
@@ -1,3 +1,5 @@
+
+from __future__ import print_function
 import sys
 from gluster.glupy import *
 
@@ -7,13 +9,13 @@ class xlator (Translator):
         Translator.__init__(self, c_this)
 
     def lookup_fop(self, frame, this, loc, xdata):
-        print "Python xlator: Hello!"
+        print("Python xlator: Hello!")
         dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata)
         return 0
 
     def lookup_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf,
                    xdata, postparent):
-        print "Python xlator: Hello again!"
+        print("Python xlator: Hello again!")
         dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, inode, buf,
                          xdata, postparent)
         return 0
diff --git a/xlators/features/glupy/examples/negative.py b/xlators/features/glupy/examples/negative.py
index e7a4fc07ced..e44ff4deed2 100644
--- a/xlators/features/glupy/examples/negative.py
+++ b/xlators/features/glupy/examples/negative.py
@@ -1,3 +1,5 @@
+
+from __future__ import print_function
 import sys
 from uuid import UUID
 from gluster.glupy import *
@@ -31,12 +33,12 @@ class xlator (Translator):
 
     def lookup_fop (self, frame, this, loc, xdata):
         pargfid = uuid2str(loc.contents.pargfid)
-        print "lookup FOP: %s:%s" % (pargfid, loc.contents.name)
+        print("lookup FOP: %s:%s" % (pargfid, loc.contents.name))
         # Check the cache.
         if cache.has_key(pargfid):
             if loc.contents.name in cache[pargfid]:
-                print "short-circuiting for %s:%s" % (pargfid,
-                    loc.contents.name)
+                print("short-circuiting for %s:%s" % (pargfid,
+                    loc.contents.name))
                 dl.unwind_lookup(frame,0,this,-1,2,None,None,None,None)
                 return 0
         key = dl.get_id(frame)
@@ -47,16 +49,16 @@ class xlator (Translator):
 
     def lookup_cbk (self, frame, cookie, this, op_ret, op_errno, inode, buf,
                     xdata, postparent):
-        print "lookup CBK: %d (%d)" % (op_ret, op_errno)
+        print("lookup CBK: %d (%d)" % (op_ret, op_errno))
         key = dl.get_id(frame)
         pargfid, name = self.requests[key]
         # Update the cache.
         if op_ret == 0:
-            print "found %s, removing from cache" % name
+            print("found %s, removing from cache" % name)
             if cache.has_key(pargfid):
                 cache[pargfid].discard(name)
         elif op_errno == 2:    # ENOENT
-            print "failed to find %s, adding to cache" % name
+            print("failed to find %s, adding to cache" % name)
             if cache.has_key(pargfid):
                 cache[pargfid].add(name)
             else:
@@ -68,7 +70,7 @@ class xlator (Translator):
 
     def create_fop (self, frame, this, loc, flags, mode, umask, fd, xdata):
         pargfid = uuid2str(loc.contents.pargfid)
-        print "create FOP: %s:%s" % (pargfid, loc.contents.name)
+        print("create FOP: %s:%s" % (pargfid, loc.contents.name))
         key = dl.get_id(frame)
         self.requests[key] = (pargfid, loc.contents.name[:])
         # TBD: get real child xl from init, pass it here
@@ -77,12 +79,12 @@ class xlator (Translator):
 
     def create_cbk (self, frame, cookie, this, op_ret, op_errno, fd, inode,
                     buf, preparent, postparent, xdata):
-        print "create CBK: %d (%d)" % (op_ret, op_errno)
+        print("create CBK: %d (%d)" % (op_ret, op_errno))
         key = dl.get_id(frame)
         pargfid, name = self.requests[key]
         # Update the cache.
         if op_ret == 0:
-            print "created %s, removing from cache" % name
+            print("created %s, removing from cache" % name)
             if cache.has_key(pargfid):
                 cache[pargfid].discard(name)
         del self.requests[key]