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
RevLine 
[103]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
[3547]13import subprocess
14import time
15import string
[103]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               
[3547]29                self.instance_id="".join(random.sample(string.letters+string.digits, 50))
30                self.server_instance_id=None
[103]31                self.variables={}
32                self.variables_ok=False
[3547]33                self.variables_clients={}
34                self.variables_triggers={}
[5195]35                self.failed_servers={}
[3547]36                t=threading.Thread(target=self.check_clients,args=())
37                t.daemon=True
38                t.start()
39               
[103]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):
[3547]75
76                if "REMOTE_VARIABLES_SERVER" in self.variables:
[5195]77                        t=threading.Thread(target=self.register_n4d_instance_to_server)
78                        t.daemon=True
79                        t.start()
[3547]80                       
81        #def startup
82       
83       
84        def is_ip_in_range(self,ip,network):
[103]85               
[3547]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
[103]92       
[3547]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
[103]116       
[3547]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               
[5195]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:
[3547]182
[5195]183                                self.server_instance_id=None
184                                return None
185                               
186                        time.sleep(60*3)
[3547]187
[5195]188        #def register_n4d_instance_to_server
[3547]189       
190       
191        def check_clients(self):
192               
193                while True:
194                       
[5195]195                        for mac in self.variables_clients:
196                               
[5234]197                                ip=self.variables_clients[mac]["ip"]
[5195]198                                t=threading.Thread(target=self.check_single_client,args=(mac,ip,))
199                                t.daemon=True
200                                t.start()
[3547]201                       
[5195]202                        time.sleep(60*3)
[3547]203               
204               
205        #def check_clients
[5234]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
[3547]217       
[5195]218       
219        def check_single_client(self,mac,ip):
220               
[5234]221                max_pings=3
222               
223                print("[VariablesManager] Checking client { MAC:%s IP:%s } ... "%(mac,ip))
[5195]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
[5234]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)
[5195]233                                self.variables_clients.pop(mac)
234               
235        #def check_single_client
236       
237       
238       
[5186]239        def get_client_list(self):
240               
241                return self.variables_clients
242               
243        #def get_client_list
244       
[3547]245        def notify_changes(self,variable):
246               
247               
[4407]248                if len(self.variables_clients) > 0:
249               
250                        print "[VariablesManager] Notifying changes... "
251                        for mac in self.variables_clients:
[3547]252                               
[4407]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()
[3547]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                       
[5195]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"])
[3547]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       
[103]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
[3547]336
[103]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
[3547]462
[103]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)
[1441]536                                                               
537                                                                if "force_update" in data[item] and data[item]["force_update"]:
538                                                                        self.variables[item][u'value']=data[item][u'value']
[103]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:
[1441]549                                        try:
[103]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
[3547]559
[103]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:
[3547]702                       
703                        if value == self.variables[name][u"value"]:
704                                return [True,"Variable already contained that value"]
705                       
[103]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"]=""
[3547]724                       
725                        t=threading.Thread(target=self.notify_changes,args=(name,))
726                        t.daemon=True
727                        t.start()
728                       
[103]729                        return [True,""]
730                else:
731                        return [False,"Variable not found. Use add_variable"]
732               
733               
734        #def set_variable
[3547]735
[103]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"]
[3547]761                       
762        #def add_variable
763
764
[103]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
[3547]803
[103]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
[3547]814                       
[103]815        #def chmod
816       
[3547]817       
[103]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.