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

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

wip in triggers

File size: 19.9 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[item]["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       
208        def check_single_client(self,mac,ip):
209               
210                sys.stdout.write("[VariablesManager] Checking client { MAC:%s IP:%s } ... "%(mac,ip))
211                c=xmlrpclib.ServerProxy("https://%s:9779"%ip)
212                try:
213                        c.get_methods()
214                        self.variables_clients[mac]["last_check"]=time.time()
215                        self.variables_clients[mac]["missed_pings"]=0
216                        print("OK")
217                except:
218                        self.variables_clients[mac]["missed_pings"]+=1
219                        print("FAILED")
220                        if self.variables_clients[mac]["missed_pings"] >=3:
221                                print "[VariablesManager] Removing client due to too many missed pings."
222                                self.variables_clients.pop(mac)
223               
224        #def check_single_client
225       
226       
227       
228        def get_client_list(self):
229               
230                return self.variables_clients
231               
232        #def get_client_list
233       
234        def notify_changes(self,variable):
235               
236               
237                if len(self.variables_clients) > 0:
238               
239                        print "[VariablesManager] Notifying changes... "
240                        for mac in self.variables_clients:
241                               
242                                ip=self.variables_clients[mac]["ip"]
243                                c=xmlrpclib.ServerProxy("https://%s:9779"%ip)
244                                try:
245                                        c.server_changed("","VariablesManager","",self.instance_id,variable)
246                                       
247                                except:
248                                        self.variables_clients[mac]["missed_pings"]+=1
249                                       
250                                self.variables_clients[mac]["last_check"]=time.time()
251               
252        #def announce_changes
253       
254       
255        def server_changed(self,autocompleted_server_ip,server_instance_id,variable_name):
256
257                if server_instance_id==self.server_instance_id:
258
259                        print "[VariablesManager] Server instance ID validated"
260
261                        t=threading.Thread(target=self.execute_trigger,args=(variable_name,))
262                        t.daemon=True
263                        t.start()
264                       
265                        return True
266                       
267                else:
268                       
269                        if autocompleted_server_ip not in self.failed_servers:
270                                self.failed_servers[autocompleted_server_ip]={}
271                                self.failed_servers[autocompleted_server_ip]["failed_count"]=0
272                       
273                        sleep_time=0.1
274                        self.failed_servers[autocompleted_server_ip]["failed_count"]+=1
275                        time.sleep(sleep_time*self.failed_servers[autocompleted_server_ip]["failed_count"])
276                        return False
277               
278        #def server_changed
279       
280       
281        def execute_trigger(self,variable_name):
282               
283                if variable_name in self.variables_triggers:
284                        for i in self.variables_triggers[variable_name]:
285                                class_name,function=i
286                                try:
287                                        print "[VariablesManager] Executing %s.%s trigger..."%(class_name,function.im_func.func_name)
288                                        function()
289                                except Exception as e:
290                                        print e
291                                        pass
292               
293        #def execute_trigger
294       
295       
296        def register_trigger(self,variable_name,class_name,function):
297               
298                if variable_name not in self.variables_triggers:
299                        self.variables_triggers[variable_name]=[]
300                       
301                self.variables_triggers[variable_name].append((class_name,function))
302               
303        #def register_trigger
304       
305       
306        def backup(self,dir="/backup"):
307               
308                try:
309               
310                        #file_path=dir+"/"+self.get_time()+"_VariablesManager.tar.gz"
311                        file_path=dir+"/"+get_backup_name("VariablesManager")
312                               
313                        tar=tarfile.open(file_path,"w:gz")
314                       
315                        tar.add(VariablesManager.VARIABLES_DIR)
316                       
317                        tar.close()
318                       
319                        return [True,file_path]
320                       
321                except Exception as e:
322                        return [False,str(e)]
323               
324        #def backup
325
326       
327        def restore(self,file_path=None):
328
329
330                if file_path==None:
331                        for f in sorted(os.listdir("/backup"),reverse=True):
332                                if "VariablesManager" in f:
333                                        file_path="/backup/"+f
334                                        break
335
336                try:
337
338                        if os.path.exists(file_path):
339                               
340                                tmp_dir=tempfile.mkdtemp()
341                                tar=tarfile.open(file_path)
342                                tar.extractall(tmp_dir)
343                                tar.close()
344                               
345                                if not os.path.exists(VariablesManager.VARIABLES_DIR):
346                                        os.mkdir(VariablesManager.VARIABLES_DIR)
347                               
348                                for f in os.listdir(tmp_dir+VariablesManager.VARIABLES_DIR):
349                                        tmp_path=tmp_dir+VariablesManager.VARIABLES_DIR+f
350                                        shutil.copy(tmp_path,VariablesManager.VARIABLES_DIR)
351                                       
352                                self.load_json(None)
353                                               
354                                return [True,""]
355                               
356                except Exception as e:
357                               
358                        return [False,str(e)]
359               
360        #def restore
361       
362        def log(self,txt):
363               
364                try:
365                        f=open(VariablesManager.LOG,"a")
366                        txt=str(txt)
367                        f.write(txt+"\n")
368                        f.close()
369                except Exception as e:
370                        pass
371               
372        #def log
373       
374        def listvars(self,extra_info=False,custom_dic=None):
375                ret=""
376               
377                try:
378               
379                        if custom_dic==None:
380                                custom_dic=self.variables
381                        for variable in custom_dic:
382                                if type(custom_dic[variable])==type({}) and "root_protected" in custom_dic[variable] and custom_dic[variable]["root_protected"]:
383                                        continue
384                                value=self.get_variable(variable)
385                                if value==None:
386                                        continue
387                                ret+=variable+ "='" + str(value).encode("utf-8") + "';\n"
388                                if extra_info:
389                                        ret+= "\tDescription: " + self.variables[variable][u"description"] + "\n"
390                                        ret+="\tUsed by:\n"
391                                        for depend in self.variables[variable][u"packages"]:
392                                                ret+= "\t\t" + depend.encode("utf-8") + "\n"
393                       
394                        return ret.strip("\n")
395                except Exception as e:
396                        return str(e)
397                                       
398        #def listvars
399       
400        def calculate_variable(self,value):
401                pattern="_@START@_.*?_@END@_"
402                variables=[]
403               
404                ret=re.findall(pattern,value)
405               
406                for item in ret:
407                        tmp=item.replace("_@START@_","")
408                        tmp=tmp.replace("_@END@_","")
409                        variables.append(tmp)
410               
411                for var in variables:
412                        value=value.replace("_@START@_"+var+"_@END@_",self.get_variable(var))
413                       
414                return value
415               
416        #def remove_calculated_chars
417       
418        def add_volatile_info(self):
419               
420                for item in self.variables:
421               
422                        if not self.variables[item].has_key("volatile"):
423                                self.variables[item]["volatile"]=False
424               
425        #def add_volatile_info
426
427       
428        def showvars(self,var_list,extra_info=False):
429               
430                ret=""
431               
432                for var in var_list:
433                        ret+=var+"='"
434                        if self.variables.has_key(var):
435                                try:
436                                        ret+=self.variables[var][u'value'].encode("utf-8")+"';\n"
437                                except Exception as e:
438                                        #it's probably something old showvars couldn't have stored anyway
439                                        ret+="';\n"
440                                if extra_info:
441                                        ret+= "\tDescription: " + self.variables[var][u"description"] + "\n"
442                                        ret+="\tUsed by:\n"
443                                        for depend in self.variables[var][u"packages"]:
444                                                ret+= "\t\t" + depend.encode("utf-8") + "\n"
445                        else:
446                                ret+="'\n"
447                                               
448                return ret.strip("\n")
449               
450        #def  showvars
451
452       
453        def get_variables(self):
454
455                return self.variables
456               
457        #def get_variables
458               
459       
460        def load_json(self, file=None):
461
462                self.variables={}
463               
464                if file!=None:
465               
466                        try:
467                               
468                                f=open(file,"r")
469                                data=json.load(f)
470                                f.close()
471                                self.variables=data
472                               
473                                #return [True,""]
474                               
475                        except Exception as e:
476                                print(str(e))
477                                #return [False,e.message]
478                               
479                for file in os.listdir(VariablesManager.VARIABLES_DIR):
480                        try:
481                                sys.stdout.write("\t[VariablesManager] Loading " + file + " ... ")
482                                f=open(VariablesManager.VARIABLES_DIR+file)     
483                                data=json.load(f)
484                                f.close()
485                                self.variables[file]=data[file]
486                                print("OK")
487                        except Exception as e:
488                                print("FAILED ["+str(e)+"]")
489                               
490                return [True,""]
491               
492        #def load_json
493       
494        def read_inbox(self, force_write=False):
495               
496                '''
497                        value
498                        function
499                        description
500                        packages
501                '''
502               
503                if self.variables_ok:
504               
505                        if os.path.exists(VariablesManager.INBOX):
506                               
507                                for file in os.listdir(VariablesManager.INBOX):
508                                        file_path=VariablesManager.INBOX+file
509                                        print "[VariablesManager] Adding " + file_path + " info..."
510                                        try:
511                                                f=open(file_path,"r")
512                                                data=json.load(f)
513                                                f.close()
514                                               
515                                                for item in data:
516                                                        if self.variables.has_key(item):
517                                                                for key in data[item].keys():
518                                                                        if not self.variables[item].has_key(unicode(key)):
519                                                                                self.variables[item][unicode(key)] = data[item][key]
520                                                                if data[item].has_key(unicode('function')):
521                                                                        self.variables[item][unicode('function')] = data[item][u'function']
522                                                                for depend in data[item][u'packages']:
523                                                                        if depend not in self.variables[item][u'packages']:
524                                                                                self.variables[item][u'packages'].append(depend)
525                                                               
526                                                                if "force_update" in data[item] and data[item]["force_update"]:
527                                                                        self.variables[item][u'value']=data[item][u'value']
528                                                        else:
529                                                                self.variables[item]=data[item]
530
531                                       
532                                        except Exception as e:
533                                                print e
534                                                #return [False,e.message]
535                                        os.remove(file_path)
536                               
537                                if force_write:
538                                        try:
539                                                self.add_volatile_info()
540                                                self.write_file()
541                                        except Exception as e:
542                                                print(e)
543                                               
544               
545                return [True,""]
546                               
547        #def read_inbox
548
549       
550        def empty_trash(self,force_write=False):
551               
552               
553                if self.variables_ok:
554               
555                        for file in os.listdir(VariablesManager.TRASH):
556                                file_path=VariablesManager.TRASH+file
557                                #print "[VariablesManager] Removing " + file_path + " info..."
558                                try:
559                                        f=open(file_path,"r")
560                                        data=json.load(f)
561                                        f.close()
562                                       
563                                        for item in data:
564                                                if self.variables.has_key(item):
565                                                        if data[item][u'packages'][0] in self.variables[item][u'packages']:
566                                                                count=0
567                                                                for depend in self.variables[item][u'packages']:
568                                                                        if depend==data[item][u'packages'][0]:
569                                                                                self.variables[item][u'packages'].pop(count)
570                                                                                if len(self.variables[item][u'packages'])==0:
571                                                                                        self.variables.pop(item)
572                                                                                break
573                                                                        else:
574                                                                                count+=1
575                                                       
576                                        #os.remove(file_path)
577                                       
578                                       
579                                except Exception as e:
580                                        print e
581                                        pass
582                                        #return [False,e.message]
583                                os.remove(file_path)
584                       
585                        if force_write:
586                                try:   
587                                        self.write_file()
588                                except Exception as e:
589                                        print(e)
590                               
591                return [True,'']
592                       
593               
594        #def empty_trash
595       
596
597        def get_variable_list(self,variable_list,store=False,full_info=False):
598               
599                ret={}
600                if variable_list!=None:
601                        for item in variable_list:
602                                try:
603                                        ret[item]=self.get_variable(item,store,full_info)
604                                        #if ret[item]==None:
605                                        #       ret[item]=""
606                                except Exception as e:
607                                        print e
608
609                return ret
610               
611        #def get_variable_list
612       
613
614        def get_variable(self,name,store=False,full_info=False,key=None):
615       
616                global master_password
617               
618                if name in self.variables and self.variables[name].has_key("root_protected") and self.variables[name]["root_protected"] and key!=master_password:
619                        return None
620                       
621                if name in self.variables and self.variables[name].has_key("function"):
622                        try:
623                                if not full_info:
624                                        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:
625                                                #print "I have to ask for " + name + " which has value: " + self.variables[name][u'value']
626                                                value=self.calculate_variable(self.variables[name][u"value"])
627                                        else:
628                                                value=self.variables[name][u"value"]
629                                        #return str(value.encode("utf-8")
630                                        if type(value)==type(u""):
631                                                try:
632                                                        ret=value.encode("utf-8")
633                                                        return ret
634                                                except:
635                                                        return value
636                                        else:
637                                                return value
638                                else:
639                                        variable=self.variables[name].copy()
640                                        variable["remote"]=False
641                                        if type(variable[u"value"])==type(""):
642                                                if variable[u"value"].find("_@START@_")!=-1:
643                                                        variable["original_value"]=variable[u"value"]
644                                                        variable[u"value"]=self.calculate_variable(self.variables[name][u"value"])
645                                                        variable["calculated"]=True
646                                        return variable
647                        except:
648                                return None
649                else:
650                        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:
651                                try:
652                                        server_ip=socket.gethostbyname(self.variables["REMOTE_VARIABLES_SERVER"][u"value"])
653                                except:
654                                        return None
655                                if self.get_ip()!=server_ip:
656                                        for count in range(0,3):
657                                                try:
658
659                                                        server=xmlrpclib.ServerProxy("https://"+server_ip+":9779",allow_none=True)
660                                                        var=server.get_variable("","VariablesManager",name,True,True)
661                                                       
662                                                        if var==None:
663                                                                return None
664                                                        if (var!=""  or type(var)!=type("")) and store:
665
666                                                                self.add_variable(name,var[u"value"],var[u"function"],var[u"description"],var[u"packages"],False)
667                                                                return self.get_variable(name,store,full_info)
668                                                        else:
669                                                                if full_info:
670                                                                        var["remote"]=True
671                                                                        return var
672                                                                else:
673                                                                        return var["value"]
674                                                               
675                                                except Exception as e:
676                                                        time.sleep(1)
677                                       
678                                        return None
679                                else:
680                                        return None
681                        else:
682                               
683                                return None
684                       
685        #def get_variable
686
687       
688        def set_variable(self,name,value,depends=[],force_volatile_flag=False):
689
690                if name in self.variables:
691                       
692                        if value == self.variables[name][u"value"]:
693                                return [True,"Variable already contained that value"]
694                       
695                        if type(value)==type(""):
696                                self.variables[name][u"value"]=unicode(value).encode("utf-8")
697                        else:
698                                self.variables[name][u"value"]=value
699
700                        if len(depends)>0:
701                                for depend in depends:
702                                        self.variables[unicode(name).encode("utf-8")][u"packages"].append(depend)
703                       
704                        if not force_volatile_flag:
705                                self.write_file()
706                        else:
707                               
708                                self.variables[name]["volatile"]=True
709                                if "function" not in self.variables["name"]:
710                                        self.variables[name]["function"]=""
711                                if "description" not in self.variables["name"]:
712                                        self.variables[name]["description"]=""
713                       
714                        t=threading.Thread(target=self.notify_changes,args=(name,))
715                        t.daemon=True
716                        t.start()
717                       
718                        return [True,""]
719                else:
720                        return [False,"Variable not found. Use add_variable"]
721               
722               
723        #def set_variable
724
725       
726        def add_variable(self,name,value,function,description,depends,volatile=False,root_protected=False):
727
728                if name not in self.variables:
729                        dic={}
730                        if type(value)==type(""):
731                                dic[u"value"]=unicode(value).encode("utf-8")
732                        else:
733                                dic[u"value"]=value
734                        dic[u"function"]=function
735                        dic[u"description"]=unicode(description).encode("utf-8")
736                        if type(depends)==type(""):
737                                dic[u"packages"]=[unicode(depends).encode("utf-8")]
738                        elif type(depends)==type([]):
739                                dic[u"packages"]=depends
740                        else:
741                                dic[u"packages"]=[]
742                        dic["volatile"]=volatile
743                        dic["root_protected"]=root_protected
744                        self.variables[unicode(name)]=dic
745                        if not volatile:
746                                self.write_file()
747                        return [True,""]
748                else:
749                        return [False,"Variable already exists. Use set_variable"]
750                       
751        #def add_variable
752
753
754        def write_file(self,fname=None):
755               
756                try:
757                        while os.path.exists(VariablesManager.LOCK_FILE):
758                                time.sleep(2)
759                               
760                        f=open(VariablesManager.LOCK_FILE,"w")
761                        f.close()
762                        tmp_vars={}
763                        for item in self.variables:
764                                if self.variables[item].has_key("volatile") and self.variables[item]["volatile"]==False:
765                                        tmp_vars[item]=self.variables[item]
766                                       
767                        for item in tmp_vars:
768                               
769                                tmp={}
770                                tmp[item]=tmp_vars[item]
771                                f=open(VariablesManager.VARIABLES_DIR+item,"w")
772                                data=unicode(json.dumps(tmp,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
773                                f.write(data)
774                                f.close()
775                               
776                                if "root_protected" in tmp_vars[item]:
777                                        if tmp_vars[item]["root_protected"]:
778                                                self.chmod(VariablesManager.VARIABLES_DIR+item,0600)
779                                               
780                                               
781                        os.remove(VariablesManager.LOCK_FILE)
782                        return True
783                               
784                       
785                except Exception as e:
786                        os.remove(VariablesManager.LOCK_FILE)
787                        print (e)
788                        return False
789               
790        #def write_file
791
792
793        def chmod(self,file,mode):
794                prevmask = os.umask(0)
795                try:
796                        os.chmod(file,mode)
797                        os.umask(prevmask)
798                        return True
799                except Exception as e:
800                        print e
801                        os.umask(prevmask)
802                        return False
803                       
804        #def chmod
805       
806       
807        def init_variable(self,variable,args={},force=False,full_info=False):
808
809                try:
810                        funct=self.variables[variable]["function"]
811                        mod_name=funct[:funct.rfind(".")]
812                        funct_name=funct[funct.rfind(".")+1:]
813                        funct_name=funct_name.replace("(","")
814                        funct_name=funct_name.replace(")","")
815                        mod=importlib.import_module(mod_name)
816                        ret=getattr(mod,funct_name)(args)
817                        ok,exc=self.set_variable(variable,ret)
818                        if ok:
819                                return (True,ret)
820                        else:
821                                return (False,ret)
822                except Exception as e:
823                        return (False,e)
824               
825        #def init_variable
826       
827       
828#class VariablesManager
829
830
831if __name__=="__main__":
832       
833        vm=VariablesManager()
834       
835        print vm.listvars()
836        print vm.init_variable("name_center")
837        args={}
838        args["iface"]="eth0"
839        print vm.init_variable("SERVER_IP",args)
840        print vm.write_file()
841        #print vm.get_variable("VARIABLE2",full_info=True)
842        #print vm.get_variable("VARIABLE3",full_info=True)
843        #print vm.showvars(var_list)
844       
845       
846               
847               
848               
849       
850       
851       
Note: See TracBrowser for help on using the repository browser.