source: n4d/trunk/fuentes/install-files/usr/share/n4d/python-plugins/VariablesManager.py @ 5234

Last change on this file since 5234 was 5234, checked in by hectorgh, 2 years ago

Updating client_list logic. Adding way to force client check

File size: 20.1 KB
Line 
1import json
2import os.path
3import os
4import time
5import xmlrpclib
6import socket
7import netifaces
8import re
9import importlib
10import sys
11import tarfile
12import threading
13import subprocess
14import time
15import string
16
17class VariablesManager:
18
19        VARIABLES_FILE="/var/lib/n4d/variables"
20        VARIABLES_DIR="/var/lib/n4d/variables-dir/"
21        LOCK_FILE="/tmp/.llxvarlock"
22        INBOX="/var/lib/n4d/variables-inbox/"
23        TRASH="/var/lib/n4d/variables-trash/"
24        CUSTOM_INSTALLATION_DIR="/usr/share/n4d/variablesmanager-funcs/"
25        LOG="/var/log/n4d/variables-manager"
26       
27        def __init__(self):
28               
29                self.instance_id="".join(random.sample(string.letters+string.digits, 50))
30                self.server_instance_id=None
31                self.variables={}
32                self.variables_ok=False
33                self.variables_clients={}
34                self.variables_triggers={}
35                self.failed_servers={}
36                t=threading.Thread(target=self.check_clients,args=())
37                t.daemon=True
38                t.start()
39               
40                if os.path.exists(VariablesManager.LOCK_FILE):
41                        os.remove(VariablesManager.LOCK_FILE)
42                       
43                       
44                if os.path.exists(VariablesManager.VARIABLES_FILE):
45                        self.variables_ok,ret=self.load_json(VariablesManager.VARIABLES_FILE)
46                        try:
47                                os.remove(VariablesManager.VARIABLES_FILE)
48                        except:
49                                pass
50                else:
51                        self.variables_ok,ret=self.load_json(None)
52                       
53                if self.variables_ok:
54                        #print "\nVARIABLES FILE"
55                        #print "=============================="
56                        #self.listvars()
57                        self.read_inbox(False)
58                        #print "\nAFTER INBOX"
59                        #print "=============================="
60                        #print self.listvars(True)
61                        self.empty_trash(False)
62                        #print "\nAFTER TRASH"
63                        #print "=============================="
64                        #print self.listvars(True)
65                        self.add_volatile_info()
66                        self.write_file()
67                else:
68                        print("[VariablesManager] Loading variables failed because: " + str(ret))
69
70               
71        #def __init__
72       
73       
74        def startup(self,options):
75
76                if "REMOTE_VARIABLES_SERVER" in self.variables:
77                        t=threading.Thread(target=self.register_n4d_instance_to_server)
78                        t.daemon=True
79                        t.start()
80                       
81        #def startup
82       
83       
84        def is_ip_in_range(self,ip,network):
85               
86                try:
87                        return netaddr.ip.IPAddress(ip) in netaddr.IPNetwork(network).iter_hosts()
88                except:
89                        return False
90                       
91        #def is_ip_in_range
92       
93
94        def get_net_size(self,netmask):
95               
96                netmask=netmask.split(".")
97                binary_str=""
98                for octet in netmask:
99                        binary_str += bin(int(octet))[2:].zfill(8)
100                       
101                return str(len(binary_str.rstrip('0')))
102               
103        #def get_net_size
104
105
106        def get_ip(self):
107               
108                for item in netifaces.interfaces():
109                        tmp=netifaces.ifaddresses(item)
110                        if tmp.has_key(netifaces.AF_INET):
111                                if tmp[netifaces.AF_INET][0].has_key("broadcast") and tmp[netifaces.AF_INET][0]["broadcast"]=="10.0.2.255":
112                                        return tmp[netifaces.AF_INET][0]["addr"]
113                return None
114               
115        #def get_ip
116       
117
118        def route_get_ip(self,ip):
119               
120                p=subprocess.Popen(["ip route get %s"%ip],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()
121                if "dev" in p[0]:
122                        dev=p[0].split("dev ")[1].split(" ")[0]
123                else:
124                        dev=None
125                return dev
126               
127        #def route_get_ip
128               
129
130        def get_mac_from_device(self,dev):
131
132                for item in netifaces.interfaces():
133                       
134                        try:
135                                i=netifaces.ifaddresses(item)
136                                mac=i[17][0]["addr"]
137                                broadcast=i[2][0]["broadcast"]
138                                network=broadcast
139                                netmask=i[2][0]["netmask"]
140                                network+="/%s"%self.get_net_size(netmask)
141                                ip=i[2][0]["addr"]
142                        except Exception as e:
143                                continue
144                       
145                        if dev=="lo":
146                                return mac
147                       
148                        if item==dev:
149                                return mac
150                               
151                return None
152
153        #def get_mac_from_device_in_server_network
154       
155       
156        def register_instance(self,autocompleted_secured_ip,mac):
157
158                client={}
159                client["last_check"]=int(time.time())
160                client["missed_pings"]=0
161                client["ip"]=autocompleted_secured_ip
162                self.variables_clients[mac]=client
163               
164                return self.instance_id
165
166        #def register_instance
167       
168
169        def register_n4d_instance_to_server(self):
170               
171                while True:
172               
173                        try:
174                                server_ip=socket.gethostbyname(self.variables["REMOTE_VARIABLES_SERVER"][u"value"])
175                                if self.get_ip()!=server_ip:
176                               
177                                        c=xmlrpclib.ServerProxy("https://%s:9779"%server_ip)
178                                        mac=self.get_mac_from_device(self.route_get_ip(server_ip))
179                                        self.server_instance_id=c.register_instance("","VariablesManager","",mac)
180                               
181                        except Exception as e:
182
183                                self.server_instance_id=None
184                                return None
185                               
186                        time.sleep(60*3)
187
188        #def register_n4d_instance_to_server
189       
190       
191        def check_clients(self):
192               
193                while True:
194                       
195                        for mac in self.variables_clients:
196                               
197                                ip=self.variables_clients[mac]["ip"]
198                                t=threading.Thread(target=self.check_single_client,args=(mac,ip,))
199                                t.daemon=True
200                                t.start()
201                       
202                        time.sleep(60*3)
203               
204               
205        #def check_clients
206
207        def manual_client_list_check(self):
208
209                for mac in self.variables_clients:
210                        ip=self.variables_clients[mac]["ip"]
211                        t=threading.Thread(target=self.check_single_client,args=(mac,ip,))
212                        t.daemon=True
213                        t.start()
214                        ip=self.variable
215
216        #def manual_client_list_check
217       
218       
219        def check_single_client(self,mac,ip):
220               
221                max_pings=3
222               
223                print("[VariablesManager] Checking client { MAC:%s IP:%s } ... "%(mac,ip))
224                c=xmlrpclib.ServerProxy("https://%s:9779"%ip)
225                try:
226                        c.get_methods()
227                        self.variables_clients[mac]["last_check"]=time.time()
228                        self.variables_clients[mac]["missed_pings"]=0
229                except:
230                        self.variables_clients[mac]["missed_pings"]+=1
231                        if self.variables_clients[mac]["missed_pings"] >=max_pings:
232                                print "[VariablesManager] Removing client %s:%s after %s missed pings."%(mac,ip,max_pings)
233                                self.variables_clients.pop(mac)
234               
235        #def check_single_client
236       
237       
238       
239        def get_client_list(self):
240               
241                return self.variables_clients
242               
243        #def get_client_list
244       
245        def notify_changes(self,variable):
246               
247               
248                if len(self.variables_clients) > 0:
249               
250                        print "[VariablesManager] Notifying changes... "
251                        for mac in self.variables_clients:
252                               
253                                ip=self.variables_clients[mac]["ip"]
254                                c=xmlrpclib.ServerProxy("https://%s:9779"%ip)
255                                try:
256                                        c.server_changed("","VariablesManager","",self.instance_id,variable)
257                                       
258                                except:
259                                        self.variables_clients[mac]["missed_pings"]+=1
260                                       
261                                self.variables_clients[mac]["last_check"]=time.time()
262               
263        #def announce_changes
264       
265       
266        def server_changed(self,autocompleted_server_ip,server_instance_id,variable_name):
267
268                if server_instance_id==self.server_instance_id:
269
270                        print "[VariablesManager] Server instance ID validated"
271
272                        t=threading.Thread(target=self.execute_trigger,args=(variable_name,))
273                        t.daemon=True
274                        t.start()
275                       
276                        return True
277                       
278                else:
279                       
280                        if autocompleted_server_ip not in self.failed_servers:
281                                self.failed_servers[autocompleted_server_ip]={}
282                                self.failed_servers[autocompleted_server_ip]["failed_count"]=0
283                       
284                        sleep_time=0.1
285                        self.failed_servers[autocompleted_server_ip]["failed_count"]+=1
286                        time.sleep(sleep_time*self.failed_servers[autocompleted_server_ip]["failed_count"])
287                        return False
288               
289        #def server_changed
290       
291       
292        def execute_trigger(self,variable_name):
293               
294                if variable_name in self.variables_triggers:
295                        for i in self.variables_triggers[variable_name]:
296                                class_name,function=i
297                                try:
298                                        print "[VariablesManager] Executing %s.%s trigger..."%(class_name,function.im_func.func_name)
299                                        function()
300                                except Exception as e:
301                                        print e
302                                        pass
303               
304        #def execute_trigger
305       
306       
307        def register_trigger(self,variable_name,class_name,function):
308               
309                if variable_name not in self.variables_triggers:
310                        self.variables_triggers[variable_name]=[]
311                       
312                self.variables_triggers[variable_name].append((class_name,function))
313               
314        #def register_trigger
315       
316       
317        def backup(self,dir="/backup"):
318               
319                try:
320               
321                        #file_path=dir+"/"+self.get_time()+"_VariablesManager.tar.gz"
322                        file_path=dir+"/"+get_backup_name("VariablesManager")
323                               
324                        tar=tarfile.open(file_path,"w:gz")
325                       
326                        tar.add(VariablesManager.VARIABLES_DIR)
327                       
328                        tar.close()
329                       
330                        return [True,file_path]
331                       
332                except Exception as e:
333                        return [False,str(e)]
334               
335        #def backup
336
337       
338        def restore(self,file_path=None):
339
340
341                if file_path==None:
342                        for f in sorted(os.listdir("/backup"),reverse=True):
343                                if "VariablesManager" in f:
344                                        file_path="/backup/"+f
345                                        break
346
347                try:
348
349                        if os.path.exists(file_path):
350                               
351                                tmp_dir=tempfile.mkdtemp()
352                                tar=tarfile.open(file_path)
353                                tar.extractall(tmp_dir)
354                                tar.close()
355                               
356                                if not os.path.exists(VariablesManager.VARIABLES_DIR):
357                                        os.mkdir(VariablesManager.VARIABLES_DIR)
358                               
359                                for f in os.listdir(tmp_dir+VariablesManager.VARIABLES_DIR):
360                                        tmp_path=tmp_dir+VariablesManager.VARIABLES_DIR+f
361                                        shutil.copy(tmp_path,VariablesManager.VARIABLES_DIR)
362                                       
363                                self.load_json(None)
364                                               
365                                return [True,""]
366                               
367                except Exception as e:
368                               
369                        return [False,str(e)]
370               
371        #def restore
372       
373        def log(self,txt):
374               
375                try:
376                        f=open(VariablesManager.LOG,"a")
377                        txt=str(txt)
378                        f.write(txt+"\n")
379                        f.close()
380                except Exception as e:
381                        pass
382               
383        #def log
384       
385        def listvars(self,extra_info=False,custom_dic=None):
386                ret=""
387               
388                try:
389               
390                        if custom_dic==None:
391                                custom_dic=self.variables
392                        for variable in custom_dic:
393                                if type(custom_dic[variable])==type({}) and "root_protected" in custom_dic[variable] and custom_dic[variable]["root_protected"]:
394                                        continue
395                                value=self.get_variable(variable)
396                                if value==None:
397                                        continue
398                                ret+=variable+ "='" + str(value).encode("utf-8") + "';\n"
399                                if extra_info:
400                                        ret+= "\tDescription: " + self.variables[variable][u"description"] + "\n"
401                                        ret+="\tUsed by:\n"
402                                        for depend in self.variables[variable][u"packages"]:
403                                                ret+= "\t\t" + depend.encode("utf-8") + "\n"
404                       
405                        return ret.strip("\n")
406                except Exception as e:
407                        return str(e)
408                                       
409        #def listvars
410       
411        def calculate_variable(self,value):
412                pattern="_@START@_.*?_@END@_"
413                variables=[]
414               
415                ret=re.findall(pattern,value)
416               
417                for item in ret:
418                        tmp=item.replace("_@START@_","")
419                        tmp=tmp.replace("_@END@_","")
420                        variables.append(tmp)
421               
422                for var in variables:
423                        value=value.replace("_@START@_"+var+"_@END@_",self.get_variable(var))
424                       
425                return value
426               
427        #def remove_calculated_chars
428       
429        def add_volatile_info(self):
430               
431                for item in self.variables:
432               
433                        if not self.variables[item].has_key("volatile"):
434                                self.variables[item]["volatile"]=False
435               
436        #def add_volatile_info
437
438       
439        def showvars(self,var_list,extra_info=False):
440               
441                ret=""
442               
443                for var in var_list:
444                        ret+=var+"='"
445                        if self.variables.has_key(var):
446                                try:
447                                        ret+=self.variables[var][u'value'].encode("utf-8")+"';\n"
448                                except Exception as e:
449                                        #it's probably something old showvars couldn't have stored anyway
450                                        ret+="';\n"
451                                if extra_info:
452                                        ret+= "\tDescription: " + self.variables[var][u"description"] + "\n"
453                                        ret+="\tUsed by:\n"
454                                        for depend in self.variables[var][u"packages"]:
455                                                ret+= "\t\t" + depend.encode("utf-8") + "\n"
456                        else:
457                                ret+="'\n"
458                                               
459                return ret.strip("\n")
460               
461        #def  showvars
462
463       
464        def get_variables(self):
465
466                return self.variables
467               
468        #def get_variables
469               
470       
471        def load_json(self, file=None):
472
473                self.variables={}
474               
475                if file!=None:
476               
477                        try:
478                               
479                                f=open(file,"r")
480                                data=json.load(f)
481                                f.close()
482                                self.variables=data
483                               
484                                #return [True,""]
485                               
486                        except Exception as e:
487                                print(str(e))
488                                #return [False,e.message]
489                               
490                for file in os.listdir(VariablesManager.VARIABLES_DIR):
491                        try:
492                                sys.stdout.write("\t[VariablesManager] Loading " + file + " ... ")
493                                f=open(VariablesManager.VARIABLES_DIR+file)     
494                                data=json.load(f)
495                                f.close()
496                                self.variables[file]=data[file]
497                                print("OK")
498                        except Exception as e:
499                                print("FAILED ["+str(e)+"]")
500                               
501                return [True,""]
502               
503        #def load_json
504       
505        def read_inbox(self, force_write=False):
506               
507                '''
508                        value
509                        function
510                        description
511                        packages
512                '''
513               
514                if self.variables_ok:
515               
516                        if os.path.exists(VariablesManager.INBOX):
517                               
518                                for file in os.listdir(VariablesManager.INBOX):
519                                        file_path=VariablesManager.INBOX+file
520                                        print "[VariablesManager] Adding " + file_path + " info..."
521                                        try:
522                                                f=open(file_path,"r")
523                                                data=json.load(f)
524                                                f.close()
525                                               
526                                                for item in data:
527                                                        if self.variables.has_key(item):
528                                                                for key in data[item].keys():
529                                                                        if not self.variables[item].has_key(unicode(key)):
530                                                                                self.variables[item][unicode(key)] = data[item][key]
531                                                                if data[item].has_key(unicode('function')):
532                                                                        self.variables[item][unicode('function')] = data[item][u'function']
533                                                                for depend in data[item][u'packages']:
534                                                                        if depend not in self.variables[item][u'packages']:
535                                                                                self.variables[item][u'packages'].append(depend)
536                                                               
537                                                                if "force_update" in data[item] and data[item]["force_update"]:
538                                                                        self.variables[item][u'value']=data[item][u'value']
539                                                        else:
540                                                                self.variables[item]=data[item]
541
542                                       
543                                        except Exception as e:
544                                                print e
545                                                #return [False,e.message]
546                                        os.remove(file_path)
547                               
548                                if force_write:
549                                        try:
550                                                self.add_volatile_info()
551                                                self.write_file()
552                                        except Exception as e:
553                                                print(e)
554                                               
555               
556                return [True,""]
557                               
558        #def read_inbox
559
560       
561        def empty_trash(self,force_write=False):
562               
563               
564                if self.variables_ok:
565               
566                        for file in os.listdir(VariablesManager.TRASH):
567                                file_path=VariablesManager.TRASH+file
568                                #print "[VariablesManager] Removing " + file_path + " info..."
569                                try:
570                                        f=open(file_path,"r")
571                                        data=json.load(f)
572                                        f.close()
573                                       
574                                        for item in data:
575                                                if self.variables.has_key(item):
576                                                        if data[item][u'packages'][0] in self.variables[item][u'packages']:
577                                                                count=0
578                                                                for depend in self.variables[item][u'packages']:
579                                                                        if depend==data[item][u'packages'][0]:
580                                                                                self.variables[item][u'packages'].pop(count)
581                                                                                if len(self.variables[item][u'packages'])==0:
582                                                                                        self.variables.pop(item)
583                                                                                break
584                                                                        else:
585                                                                                count+=1
586                                                       
587                                        #os.remove(file_path)
588                                       
589                                       
590                                except Exception as e:
591                                        print e
592                                        pass
593                                        #return [False,e.message]
594                                os.remove(file_path)
595                       
596                        if force_write:
597                                try:   
598                                        self.write_file()
599                                except Exception as e:
600                                        print(e)
601                               
602                return [True,'']
603                       
604               
605        #def empty_trash
606       
607
608        def get_variable_list(self,variable_list,store=False,full_info=False):
609               
610                ret={}
611                if variable_list!=None:
612                        for item in variable_list:
613                                try:
614                                        ret[item]=self.get_variable(item,store,full_info)
615                                        #if ret[item]==None:
616                                        #       ret[item]=""
617                                except Exception as e:
618                                        print e
619
620                return ret
621               
622        #def get_variable_list
623       
624
625        def get_variable(self,name,store=False,full_info=False,key=None):
626       
627                global master_password
628               
629                if name in self.variables and self.variables[name].has_key("root_protected") and self.variables[name]["root_protected"] and key!=master_password:
630                        return None
631                       
632                if name in self.variables and self.variables[name].has_key("function"):
633                        try:
634                                if not full_info:
635                                        if (type(self.variables[name][u"value"])==type("") or  type(self.variables[name][u"value"])==type(u"")) and self.variables[name][u"value"].find("_@START@_")!=-1:
636                                                #print "I have to ask for " + name + " which has value: " + self.variables[name][u'value']
637                                                value=self.calculate_variable(self.variables[name][u"value"])
638                                        else:
639                                                value=self.variables[name][u"value"]
640                                        #return str(value.encode("utf-8")
641                                        if type(value)==type(u""):
642                                                try:
643                                                        ret=value.encode("utf-8")
644                                                        return ret
645                                                except:
646                                                        return value
647                                        else:
648                                                return value
649                                else:
650                                        variable=self.variables[name].copy()
651                                        variable["remote"]=False
652                                        if type(variable[u"value"])==type(""):
653                                                if variable[u"value"].find("_@START@_")!=-1:
654                                                        variable["original_value"]=variable[u"value"]
655                                                        variable[u"value"]=self.calculate_variable(self.variables[name][u"value"])
656                                                        variable["calculated"]=True
657                                        return variable
658                        except:
659                                return None
660                else:
661                        if self.variables.has_key("REMOTE_VARIABLES_SERVER") and self.variables["REMOTE_VARIABLES_SERVER"][u"value"]!="" and self.variables["REMOTE_VARIABLES_SERVER"][u"value"]!=None:
662                                try:
663                                        server_ip=socket.gethostbyname(self.variables["REMOTE_VARIABLES_SERVER"][u"value"])
664                                except:
665                                        return None
666                                if self.get_ip()!=server_ip:
667                                        for count in range(0,3):
668                                                try:
669
670                                                        server=xmlrpclib.ServerProxy("https://"+server_ip+":9779",allow_none=True)
671                                                        var=server.get_variable("","VariablesManager",name,True,True)
672                                                       
673                                                        if var==None:
674                                                                return None
675                                                        if (var!=""  or type(var)!=type("")) and store:
676
677                                                                self.add_variable(name,var[u"value"],var[u"function"],var[u"description"],var[u"packages"],False)
678                                                                return self.get_variable(name,store,full_info)
679                                                        else:
680                                                                if full_info:
681                                                                        var["remote"]=True
682                                                                        return var
683                                                                else:
684                                                                        return var["value"]
685                                                               
686                                                except Exception as e:
687                                                        time.sleep(1)
688                                       
689                                        return None
690                                else:
691                                        return None
692                        else:
693                               
694                                return None
695                       
696        #def get_variable
697
698       
699        def set_variable(self,name,value,depends=[],force_volatile_flag=False):
700
701                if name in self.variables:
702                       
703                        if value == self.variables[name][u"value"]:
704                                return [True,"Variable already contained that value"]
705                       
706                        if type(value)==type(""):
707                                self.variables[name][u"value"]=unicode(value).encode("utf-8")
708                        else:
709                                self.variables[name][u"value"]=value
710
711                        if len(depends)>0:
712                                for depend in depends:
713                                        self.variables[unicode(name).encode("utf-8")][u"packages"].append(depend)
714                       
715                        if not force_volatile_flag:
716                                self.write_file()
717                        else:
718                               
719                                self.variables[name]["volatile"]=True
720                                if "function" not in self.variables["name"]:
721                                        self.variables[name]["function"]=""
722                                if "description" not in self.variables["name"]:
723                                        self.variables[name]["description"]=""
724                       
725                        t=threading.Thread(target=self.notify_changes,args=(name,))
726                        t.daemon=True
727                        t.start()
728                       
729                        return [True,""]
730                else:
731                        return [False,"Variable not found. Use add_variable"]
732               
733               
734        #def set_variable
735
736       
737        def add_variable(self,name,value,function,description,depends,volatile=False,root_protected=False):
738
739                if name not in self.variables:
740                        dic={}
741                        if type(value)==type(""):
742                                dic[u"value"]=unicode(value).encode("utf-8")
743                        else:
744                                dic[u"value"]=value
745                        dic[u"function"]=function
746                        dic[u"description"]=unicode(description).encode("utf-8")
747                        if type(depends)==type(""):
748                                dic[u"packages"]=[unicode(depends).encode("utf-8")]
749                        elif type(depends)==type([]):
750                                dic[u"packages"]=depends
751                        else:
752                                dic[u"packages"]=[]
753                        dic["volatile"]=volatile
754                        dic["root_protected"]=root_protected
755                        self.variables[unicode(name)]=dic
756                        if not volatile:
757                                self.write_file()
758                        return [True,""]
759                else:
760                        return [False,"Variable already exists. Use set_variable"]
761                       
762        #def add_variable
763
764
765        def write_file(self,fname=None):
766               
767                try:
768                        while os.path.exists(VariablesManager.LOCK_FILE):
769                                time.sleep(2)
770                               
771                        f=open(VariablesManager.LOCK_FILE,"w")
772                        f.close()
773                        tmp_vars={}
774                        for item in self.variables:
775                                if self.variables[item].has_key("volatile") and self.variables[item]["volatile"]==False:
776                                        tmp_vars[item]=self.variables[item]
777                                       
778                        for item in tmp_vars:
779                               
780                                tmp={}
781                                tmp[item]=tmp_vars[item]
782                                f=open(VariablesManager.VARIABLES_DIR+item,"w")
783                                data=unicode(json.dumps(tmp,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
784                                f.write(data)
785                                f.close()
786                               
787                                if "root_protected" in tmp_vars[item]:
788                                        if tmp_vars[item]["root_protected"]:
789                                                self.chmod(VariablesManager.VARIABLES_DIR+item,0600)
790                                               
791                                               
792                        os.remove(VariablesManager.LOCK_FILE)
793                        return True
794                               
795                       
796                except Exception as e:
797                        os.remove(VariablesManager.LOCK_FILE)
798                        print (e)
799                        return False
800               
801        #def write_file
802
803
804        def chmod(self,file,mode):
805                prevmask = os.umask(0)
806                try:
807                        os.chmod(file,mode)
808                        os.umask(prevmask)
809                        return True
810                except Exception as e:
811                        print e
812                        os.umask(prevmask)
813                        return False
814                       
815        #def chmod
816       
817       
818        def init_variable(self,variable,args={},force=False,full_info=False):
819
820                try:
821                        funct=self.variables[variable]["function"]
822                        mod_name=funct[:funct.rfind(".")]
823                        funct_name=funct[funct.rfind(".")+1:]
824                        funct_name=funct_name.replace("(","")
825                        funct_name=funct_name.replace(")","")
826                        mod=importlib.import_module(mod_name)
827                        ret=getattr(mod,funct_name)(args)
828                        ok,exc=self.set_variable(variable,ret)
829                        if ok:
830                                return (True,ret)
831                        else:
832                                return (False,ret)
833                except Exception as e:
834                        return (False,e)
835               
836        #def init_variable
837       
838       
839#class VariablesManager
840
841
842if __name__=="__main__":
843       
844        vm=VariablesManager()
845       
846        print vm.listvars()
847        print vm.init_variable("name_center")
848        args={}
849        args["iface"]="eth0"
850        print vm.init_variable("SERVER_IP",args)
851        print vm.write_file()
852        #print vm.get_variable("VARIABLE2",full_info=True)
853        #print vm.get_variable("VARIABLE3",full_info=True)
854        #print vm.showvars(var_list)
855       
856       
857               
858               
859               
860       
861       
862       
Note: See TracBrowser for help on using the repository browser.