From 6f3aa3637c8ca8494f883c54ee0dc99a4586f43f Mon Sep 17 00:00:00 2001 From: Marc Fiuczynski Date: Wed, 20 May 2009 18:16:53 +0000 Subject: [PATCH] modularized more... probably only Get* functions work --- PLC/Legacy/NodeNetworks.py | 71 +++++++------------------------------- PLC/Legacy/Types.py | 62 ++++++++------------------------- PLC/Legacy/v42legacy.py | 41 ++++++++++++++++++++++ 3 files changed, 68 insertions(+), 106 deletions(-) create mode 100644 PLC/Legacy/v42legacy.py diff --git a/PLC/Legacy/NodeNetworks.py b/PLC/Legacy/NodeNetworks.py index 4a1e404..8febd01 100644 --- a/PLC/Legacy/NodeNetworks.py +++ b/PLC/Legacy/NodeNetworks.py @@ -2,13 +2,9 @@ # $Id$ from PLC.Method import Method - -def import_deep(name): - mod = __import__(name) - components = name.split('.') - for comp in components[1:]: - mod = getattr(mod, comp) - return mod +import v42legacy +import sys +current_module=sys.modules[__name__] methods = [ "AddNodeNetwork", @@ -21,63 +17,20 @@ methods = [ "UpdateNodeNetworkSetting", ] -# does any required renaming -v42_to_v43_renaming = { +# argument mapping +v42_to_v43_argmap = { "nodenetwork_id":"interface_id", "nodenetwork_ids":"interface_ids", "nodenetworksetting_ids":"interface_tag_ids", } +v43_to_v42_argmap = dict([ (v,k) for k,v in v42_to_v43_argmap.iteritems()]) +def v42rename (x): return v42_to_v43_argmap.get(x,x) +def v43rename (x): return v43_to_v42_argmap.get(x,x) -v43_to_v42_renaming = dict([ (v,k) for k,v in v42_to_v43_renaming.iteritems()]) - -for k,v in v42_to_v43_renaming.iteritems(): - v43_to_v42_renaming[v]=k - -def v42rename (x): - return v42_to_v43_renaming.get(x,x) - -def v43rename (x): - return v43_to_v42_renaming.get(x,x) - - -# apply rename on list (columns) or dict (filter) args -def patch_legacy (arg,rename): - if isinstance(arg,list): - for i in range(0,len(arg)): - arg[i] = patch_legacy(arg[i],rename) - return arg - if isinstance(arg,dict): - return dict ( [ (rename(k),v) for (k,v) in arg.iteritems() ] ) - return rename(arg) - -def legacy_method (legacyname): +# attach methods here +for legacyname in methods: # new method name newname=legacyname.replace("NodeNetwork","Interface").replace("Setting","Tag") - # locate new class - newclass=getattr(import_deep("PLC.Methods."+newname),newname) - # create class for legacy name - legacyclass = type(legacyname,(newclass,), - {"__doc__":"Legacy method - please use %s instead"%newname}) - # xxx should rewrite 'call' to handle any argument using nodenetwork_id(s) - for internal in ["roles","accepts","returns"]: - setattr(legacyclass,internal,getattr(newclass,internal)) - # turn off type checking, as introspection code fails on wrapped_call - setattr(legacyclass,"skip_typecheck",True) - # rewrite call - def wrapped_call (self,auth,*args, **kwds): - print "%s: self.caller = %s, self=%s" % (legacyname,self.caller,self) - newargs=[patch_legacy(x,v42rename) for x in args] - newkwds=dict ( [ (k,patch_legacy(v,v42rename)) for (k,v) in kwds.iteritems() ] ) - results = getattr(newclass,"call")(self,auth,*newargs,**newkwds) - return patch_legacy(results,v43rename) - setattr(legacyclass,"call",wrapped_call) - - return legacyclass - -import sys -current_module=sys.modules[__name__] - -# attach -for legacyname in methods: - setattr(current_module,legacyname,legacy_method(legacyname)) + path = "PLC.Methods." + setattr(current_module,legacyname,v42legacy.make_class(legacyname,newname,path,v42rename,v43rename)) diff --git a/PLC/Legacy/Types.py b/PLC/Legacy/Types.py index c7eb749..9828730 100644 --- a/PLC/Legacy/Types.py +++ b/PLC/Legacy/Types.py @@ -2,15 +2,11 @@ # $Id$ from PLC.Method import Method +import v42legacy +import sys +current_module=sys.modules[__name__] -def import_deep(name): - mod = __import__(name) - components = name.split('.') - for comp in components[1:]: - mod = getattr(mod, comp) - return mod - -map = { +v42_to_v43_methodmap = { "AddSliceAttributeType" : "AddTagType", "DeleteSliceAttributeType" : "DeleteTagType", "GetSliceAttributeTypes" : "GetTagTypes", @@ -21,45 +17,17 @@ map = { "UpdateNodeNetworkSettingType" : "UpdateTagType", } -methods = map.keys() - -# does any required renaming -def rename (x): - if x=='name': - return 'tagname' - else: - return x - -# apply rename on list (columns) or dict (filter) args -def patch_legacy_arg (arg): - if isinstance(arg,list): - return [rename(x) for x in arg] - if isinstance(arg,dict): - return dict ( [ (rename(k),v) for (k,v) in arg.iteritems() ] ) - return arg +methods = v42_to_v43_methodmap.keys() -def legacy_method (legacyname, newname): - # locate new class - newclass=getattr(import_deep("PLC.Methods."+newname),newname) - # create class for legacy name - legacyclass = type(legacyname,(newclass,), - {"__doc__":"Legacy method - please use %s instead"%newname}) - for internal in ["roles","accepts","returns"]: - setattr(legacyclass,internal,getattr(newclass,internal)) - # turn off type checking, as introspection code fails on wrapped_call - setattr(legacyclass,"skip_typecheck",True) - # rewrite call - def wrapped_call (self,auth,*args, **kwds): - newargs=[patch_legacy_arg(x) for x in args] - newkwds=dict ( [ (k,patch_legacy_arg(v)) for (k,v) in kwds.iteritems() ] ) - return getattr(newclass,"call")(self,auth,*newargs,**newkwds) - setattr(legacyclass,"call",wrapped_call) - - return legacyclass - -import sys -current_module=sys.modules[__name__] +v42_to_v43_argmap = { "name":"tagname" } +v43_to_v42_argmap = dict([ (v,k) for k,v in v42_to_v43_argmap.iteritems()]) -for (legacyname,newname) in map.iteritems(): - setattr(current_module,legacyname,legacy_method(legacyname,newname)) +def v42rename (x): return v42_to_v43_argmap.get(x,x) +def v43rename (x): return v43_to_v42_argmap.get(x,x) +# attach methods here +for legacyname in methods: + # new method name + newname=v42_to_v43_methodmap[legacyname] + path = "PLC.Methods." + setattr(current_module,legacyname,v42legacy.make_class(legacyname,newname,path,v42rename,v43rename)) diff --git a/PLC/Legacy/v42legacy.py b/PLC/Legacy/v42legacy.py new file mode 100644 index 0000000..fdf316f --- /dev/null +++ b/PLC/Legacy/v42legacy.py @@ -0,0 +1,41 @@ +# $Id: $ + +def import_deep(name): + mod = __import__(name) + components = name.split('.') + for comp in components[1:]: + mod = getattr(mod, comp) + return mod + +# apply rename on list (columns) or dict (filter) args +def patch (arg,rename): + if isinstance(arg,list): + for i in range(0,len(arg)): + arg[i] = patch(arg[i],rename) + return arg + if isinstance(arg,dict): + return dict ( [ (rename(k),v) for (k,v) in arg.iteritems() ] ) + return rename(arg) + + +def make_class (legacyname,newname,path,v42rename,v43rename): + # locate new class + newclass=getattr(import_deep(path+newname),newname) + # create class for legacy name + legacyclass = type(legacyname,(newclass,), + {"__doc__":"Legacy method - please use %s instead"%newname}) + for internal in ["roles","accepts","returns"]: + setattr(legacyclass,internal,getattr(newclass,internal)) + # turn off type checking, as introspection code fails on wrapped_call + setattr(legacyclass,"skip_typecheck",True) + # rewrite call + def wrapped_call (self,auth,*args, **kwds): + # print "%s: self.caller = %s, self=%s" % (legacyname,self.caller,self) + newargs=[patch(x,v42rename) for x in args] + newkwds=dict ( [ (k,patch(v,v42rename)) for (k,v) in kwds.iteritems() ] ) + results = getattr(newclass,"call")(self,auth,*newargs,**newkwds) + return patch(results,v43rename) + setattr(legacyclass,"call",wrapped_call) + + return legacyclass + -- 2.43.0