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

Last change on this file since 1441 was 1441, checked in by hectorgh, 3 years ago

changelog updated

File size: 15.5 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
13
14class VariablesManager:
15
16        VARIABLES_FILE="/var/lib/n4d/variables"
17        VARIABLES_DIR="/var/lib/n4d/variables-dir/"
18        LOCK_FILE="/tmp/.llxvarlock"
19        INBOX="/var/lib/n4d/variables-inbox/"
20        TRASH="/var/lib/n4d/variables-trash/"
21        CUSTOM_INSTALLATION_DIR="/usr/share/n4d/variablesmanager-funcs/"
22        LOG="/var/log/n4d/variables-manager"
23       
24        def __init__(self):
25               
26                self.variables={}
27                self.variables_ok=False
28                if os.path.exists(VariablesManager.LOCK_FILE):
29                        os.remove(VariablesManager.LOCK_FILE)
30                       
31                       
32                if os.path.exists(VariablesManager.VARIABLES_FILE):
33                        self.variables_ok,ret=self.load_json(VariablesManager.VARIABLES_FILE)
34                        try:
35                                os.remove(VariablesManager.VARIABLES_FILE)
36                        except:
37                                pass
38                else:
39                        self.variables_ok,ret=self.load_json(None)
40                       
41                if self.variables_ok:
42                        #print "\nVARIABLES FILE"
43                        #print "=============================="
44                        #self.listvars()
45                        self.read_inbox(False)
46                        #print "\nAFTER INBOX"
47                        #print "=============================="
48                        #print self.listvars(True)
49                        self.empty_trash(False)
50                        #print "\nAFTER TRASH"
51                        #print "=============================="
52                        #print self.listvars(True)
53                        self.add_volatile_info()
54                        self.write_file()
55                else:
56                        print("[VariablesManager] Loading variables failed because: " + str(ret))
57
58               
59        #def __init__
60       
61        # DO NOT TOUCH THIS
62       
63        def startup(self,options):
64                pass
65               
66        # DONE ============
67       
68       
69        def backup(self,dir="/backup"):
70               
71                try:
72               
73                        #file_path=dir+"/"+self.get_time()+"_VariablesManager.tar.gz"
74                        file_path=dir+"/"+get_backup_name("VariablesManager")
75                               
76                        tar=tarfile.open(file_path,"w:gz")
77                       
78                        tar.add(VariablesManager.VARIABLES_DIR)
79                       
80                        tar.close()
81                       
82                        return [True,file_path]
83                       
84                except Exception as e:
85                        return [False,str(e)]
86               
87        #def backup
88       
89        def restore(self,file_path=None):
90
91
92                if file_path==None:
93                        for f in sorted(os.listdir("/backup"),reverse=True):
94                                if "VariablesManager" in f:
95                                        file_path="/backup/"+f
96                                        break
97
98                try:
99
100                        if os.path.exists(file_path):
101                               
102                                tmp_dir=tempfile.mkdtemp()
103                                tar=tarfile.open(file_path)
104                                tar.extractall(tmp_dir)
105                                tar.close()
106                               
107                                if not os.path.exists(VariablesManager.VARIABLES_DIR):
108                                        os.mkdir(VariablesManager.VARIABLES_DIR)
109                               
110                                for f in os.listdir(tmp_dir+VariablesManager.VARIABLES_DIR):
111                                        tmp_path=tmp_dir+VariablesManager.VARIABLES_DIR+f
112                                        shutil.copy(tmp_path,VariablesManager.VARIABLES_DIR)
113                                       
114                                self.load_json(None)
115                                               
116                                return [True,""]
117                               
118                except Exception as e:
119                               
120                        return [False,str(e)]
121               
122        #def restore
123       
124        def log(self,txt):
125               
126                try:
127                        f=open(VariablesManager.LOG,"a")
128                        txt=str(txt)
129                        f.write(txt+"\n")
130                        f.close()
131                except Exception as e:
132                        pass
133               
134        #def log
135       
136        def listvars(self,extra_info=False,custom_dic=None):
137                ret=""
138               
139                try:
140               
141                        if custom_dic==None:
142                                custom_dic=self.variables
143                        for variable in custom_dic:
144                                if type(custom_dic[variable])==type({}) and "root_protected" in custom_dic[variable] and custom_dic[variable]["root_protected"]:
145                                        continue
146                                value=self.get_variable(variable)
147                                if value==None:
148                                        continue
149                                ret+=variable+ "='" + str(value).encode("utf-8") + "';\n"
150                                if extra_info:
151                                        ret+= "\tDescription: " + self.variables[variable][u"description"] + "\n"
152                                        ret+="\tUsed by:\n"
153                                        for depend in self.variables[variable][u"packages"]:
154                                                ret+= "\t\t" + depend.encode("utf-8") + "\n"
155                       
156                        return ret.strip("\n")
157                except Exception as e:
158                        return str(e)
159                                       
160        #def listvars
161       
162        def calculate_variable(self,value):
163                pattern="_@START@_.*?_@END@_"
164                variables=[]
165               
166                ret=re.findall(pattern,value)
167               
168                print "hola",ret
169               
170                for item in ret:
171                        tmp=item.replace("_@START@_","")
172                        tmp=tmp.replace("_@END@_","")
173                        variables.append(tmp)
174               
175                for var in variables:
176                        value=value.replace("_@START@_"+var+"_@END@_",self.get_variable(var))
177                       
178                return value
179               
180               
181               
182        #def remove_calculated_chars
183       
184        def add_volatile_info(self):
185               
186                for item in self.variables:
187               
188                        if not self.variables[item].has_key("volatile"):
189                                self.variables[item]["volatile"]=False
190                       
191               
192               
193        #def add_volatile_info
194
195       
196        def showvars(self,var_list,extra_info=False):
197               
198                ret=""
199               
200                for var in var_list:
201                        ret+=var+"='"
202                        if self.variables.has_key(var):
203                                try:
204                                        ret+=self.variables[var][u'value'].encode("utf-8")+"';\n"
205                                except Exception as e:
206                                        #it's probably something old showvars couldn't have stored anyway
207                                        ret+="';\n"
208                                if extra_info:
209                                        ret+= "\tDescription: " + self.variables[var][u"description"] + "\n"
210                                        ret+="\tUsed by:\n"
211                                        for depend in self.variables[var][u"packages"]:
212                                                ret+= "\t\t" + depend.encode("utf-8") + "\n"
213                        else:
214                                ret+="'\n"
215                                               
216                return ret.strip("\n")
217                                       
218               
219               
220        #def  showvars
221       
222        def get_variables(self):
223
224                return self.variables
225               
226        #def get_variables
227               
228       
229        def load_json(self, file=None):
230
231                self.variables={}
232               
233                if file!=None:
234               
235                        try:
236                               
237                                f=open(file,"r")
238                                data=json.load(f)
239                                f.close()
240                                self.variables=data
241                               
242                                #return [True,""]
243                               
244                        except Exception as e:
245                                print(str(e))
246                                #return [False,e.message]
247                               
248                for file in os.listdir(VariablesManager.VARIABLES_DIR):
249                        try:
250                                sys.stdout.write("\t[VariablesManager] Loading " + file + " ... ")
251                                f=open(VariablesManager.VARIABLES_DIR+file)     
252                                data=json.load(f)
253                                f.close()
254                                self.variables[file]=data[file]
255                                print("OK")
256                        except Exception as e:
257                                print("FAILED ["+str(e)+"]")
258                               
259                return [True,""]
260               
261        #def load_json
262       
263        def read_inbox(self, force_write=False):
264               
265                '''
266                        value
267                        function
268                        description
269                        packages
270                '''
271               
272                if self.variables_ok:
273               
274                        if os.path.exists(VariablesManager.INBOX):
275                               
276                                for file in os.listdir(VariablesManager.INBOX):
277                                        file_path=VariablesManager.INBOX+file
278                                        print "[VariablesManager] Adding " + file_path + " info..."
279                                        try:
280                                                f=open(file_path,"r")
281                                                data=json.load(f)
282                                                f.close()
283                                               
284                                                for item in data:
285                                                        if self.variables.has_key(item):
286                                                                for key in data[item].keys():
287                                                                        if not self.variables[item].has_key(unicode(key)):
288                                                                                self.variables[item][unicode(key)] = data[item][key]
289                                                                if data[item].has_key(unicode('function')):
290                                                                        self.variables[item][unicode('function')] = data[item][u'function']
291                                                                for depend in data[item][u'packages']:
292                                                                        if depend not in self.variables[item][u'packages']:
293                                                                                self.variables[item][u'packages'].append(depend)
294                                                               
295                                                                if "force_update" in data[item] and data[item]["force_update"]:
296                                                                        self.variables[item][u'value']=data[item][u'value']
297                                                        else:
298                                                                self.variables[item]=data[item]
299
300                                       
301                                        except Exception as e:
302                                                print e
303                                                #return [False,e.message]
304                                        os.remove(file_path)
305                               
306                                if force_write:
307                                        try:
308                                                self.add_volatile_info()
309                                                self.write_file()
310                                        except Exception as e:
311                                                print(e)
312                                               
313               
314                return [True,""]
315                               
316               
317                       
318                       
319                '''
320               
321                if os.path.exists(VariablesManager.INBOX):
322                       
323                        for file in os.listdir(VariablesManager.INBOX):
324                                file_path=VariablesManager.INBOX+file
325                               
326                                try:
327                                        execfile(file_path)
328                                        os.remove(file_path)
329                                except Exception as e:
330                                        self.log(file_path + ": " + str(e))
331                       
332                '''
333               
334        #def read_inbox
335       
336        def empty_trash(self,force_write=False):
337               
338               
339                if self.variables_ok:
340               
341                        for file in os.listdir(VariablesManager.TRASH):
342                                file_path=VariablesManager.TRASH+file
343                                #print "[VariablesManager] Removing " + file_path + " info..."
344                                try:
345                                        f=open(file_path,"r")
346                                        data=json.load(f)
347                                        f.close()
348                                       
349                                        for item in data:
350                                                if self.variables.has_key(item):
351                                                        if data[item][u'packages'][0] in self.variables[item][u'packages']:
352                                                                count=0
353                                                                for depend in self.variables[item][u'packages']:
354                                                                        if depend==data[item][u'packages'][0]:
355                                                                                self.variables[item][u'packages'].pop(count)
356                                                                                if len(self.variables[item][u'packages'])==0:
357                                                                                        self.variables.pop(item)
358                                                                                break
359                                                                        else:
360                                                                                count+=1
361                                                       
362                                        #os.remove(file_path)
363                                       
364                                       
365                                except Exception as e:
366                                        print e
367                                        pass
368                                        #return [False,e.message]
369                                os.remove(file_path)
370                       
371                        if force_write:
372                                try:   
373                                        self.write_file()
374                                except Exception as e:
375                                        print(e)
376                               
377                return [True,'']
378                       
379               
380        #def empty_trash
381       
382        def get_ip(self):
383               
384                for item in netifaces.interfaces():
385                        tmp=netifaces.ifaddresses(item)
386                        if tmp.has_key(netifaces.AF_INET):
387                                if tmp[netifaces.AF_INET][0].has_key("broadcast") and tmp[netifaces.AF_INET][0]["broadcast"]=="10.0.2.255":
388                                        return tmp[netifaces.AF_INET][0]["addr"]
389                return None
390               
391        #def get_ip
392
393        def get_variable_list(self,variable_list,store=False,full_info=False):
394               
395                ret={}
396                if variable_list!=None:
397                        for item in variable_list:
398                                try:
399                                        ret[item]=self.get_variable(item,store,full_info)
400                                        #if ret[item]==None:
401                                        #       ret[item]=""
402                                except Exception as e:
403                                        print e
404
405                return ret
406               
407        #def get_variable_list
408       
409
410        def get_variable(self,name,store=False,full_info=False,key=None):
411       
412                global master_password
413               
414                if name in self.variables and self.variables[name].has_key("root_protected") and self.variables[name]["root_protected"] and key!=master_password:
415                        return None
416                       
417               
418       
419                if name in self.variables and self.variables[name].has_key("function"):
420                        try:
421                                if not full_info:
422                                        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:
423                                                #print "I have to ask for " + name + " which has value: " + self.variables[name][u'value']
424                                                value=self.calculate_variable(self.variables[name][u"value"])
425                                        else:
426                                                value=self.variables[name][u"value"]
427                                        #return str(value.encode("utf-8")
428                                        if type(value)==type(u""):
429                                                try:
430                                                        ret=value.encode("utf-8")
431                                                        return ret
432                                                except:
433                                                        return value
434                                        else:
435                                                return value
436                                else:
437                                        variable=self.variables[name].copy()
438                                        variable["remote"]=False
439                                        if type(variable[u"value"])==type(""):
440                                                if variable[u"value"].find("_@START@_")!=-1:
441                                                        variable["original_value"]=variable[u"value"]
442                                                        variable[u"value"]=self.calculate_variable(self.variables[name][u"value"])
443                                                        variable["calculated"]=True
444                                        return variable
445                        except:
446                                return None
447                else:
448                        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:
449                                try:
450                                        server_ip=socket.gethostbyname(self.variables["REMOTE_VARIABLES_SERVER"][u"value"])
451                                except:
452                                        return None
453                                if self.get_ip()!=server_ip:
454                                        for count in range(0,3):
455                                                try:
456
457                                                        server=xmlrpclib.ServerProxy("https://"+server_ip+":9779",allow_none=True)
458                                                        var=server.get_variable("","VariablesManager",name,True,True)
459                                                       
460                                                        if var==None:
461                                                                return None
462                                                        if (var!=""  or type(var)!=type("")) and store:
463
464                                                                self.add_variable(name,var[u"value"],var[u"function"],var[u"description"],var[u"packages"],False)
465                                                                return self.get_variable(name,store,full_info)
466                                                        else:
467                                                                if full_info:
468                                                                        var["remote"]=True
469                                                                        return var
470                                                                else:
471                                                                        return var["value"]
472                                                               
473                                                except Exception as e:
474                                                        time.sleep(1)
475                                       
476                                        return None
477                                else:
478                                        return None
479                        else:
480                               
481                                return None
482                       
483        #def get_variable
484
485       
486        def set_variable(self,name,value,depends=[],force_volatile_flag=False):
487
488                if name in self.variables:
489                        if type(value)==type(""):
490                                self.variables[name][u"value"]=unicode(value).encode("utf-8")
491                        else:
492                                self.variables[name][u"value"]=value
493
494                        if len(depends)>0:
495                                for depend in depends:
496                                        self.variables[unicode(name).encode("utf-8")][u"packages"].append(depend)
497                       
498                        if not force_volatile_flag:
499                                self.write_file()
500                        else:
501                               
502                                self.variables[name]["volatile"]=True
503                                if "function" not in self.variables["name"]:
504                                        self.variables[name]["function"]=""
505                                if "description" not in self.variables["name"]:
506                                        self.variables[name]["description"]=""
507                                       
508                        return [True,""]
509                else:
510                        return [False,"Variable not found. Use add_variable"]
511               
512               
513        #def set_variable
514       
515        def add_variable(self,name,value,function,description,depends,volatile=False,root_protected=False):
516
517                if name not in self.variables:
518                        dic={}
519                        if type(value)==type(""):
520                                dic[u"value"]=unicode(value).encode("utf-8")
521                        else:
522                                dic[u"value"]=value
523                        dic[u"function"]=function
524                        dic[u"description"]=unicode(description).encode("utf-8")
525                        if type(depends)==type(""):
526                                dic[u"packages"]=[unicode(depends).encode("utf-8")]
527                        elif type(depends)==type([]):
528                                dic[u"packages"]=depends
529                        else:
530                                dic[u"packages"]=[]
531                        dic["volatile"]=volatile
532                        dic["root_protected"]=root_protected
533                        self.variables[unicode(name)]=dic
534                        if not volatile:
535                                self.write_file()
536                        return [True,""]
537                else:
538                        return [False,"Variable already exists. Use set_variable"]
539               
540        def write_file(self,fname=None):
541               
542                '''
543               
544                try:
545                        while os.path.exists(VariablesManager.LOCK_FILE):
546                                time.sleep(2)
547                        f=open(VariablesManager.LOCK_FILE,"w")
548                        f.close()
549                        tmp={}
550                        for item in self.variables:
551                                if self.variables[item].has_key("volatile") and self.variables[item]["volatile"]==False:
552                                        tmp[item]=self.variables[item]
553
554                        if fname==None:
555                                f=open(VariablesManager.VARIABLES_FILE,"w")
556                        else:
557                                f=open(fname,"w")
558                               
559                        data=unicode(json.dumps(tmp,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
560                        f.write(data)
561                        f.close()
562                        os.remove(VariablesManager.LOCK_FILE)
563                        return True
564                       
565                except Exception as e:
566                        os.remove(VariablesManager.LOCK_FILE)
567                        print(e)
568                        return False
569                       
570                '''
571               
572                try:
573                        while os.path.exists(VariablesManager.LOCK_FILE):
574                                time.sleep(2)
575                               
576                        f=open(VariablesManager.LOCK_FILE,"w")
577                        f.close()
578                        tmp_vars={}
579                        for item in self.variables:
580                                if self.variables[item].has_key("volatile") and self.variables[item]["volatile"]==False:
581                                        tmp_vars[item]=self.variables[item]
582                                       
583                        for item in tmp_vars:
584                               
585                                tmp={}
586                                tmp[item]=tmp_vars[item]
587                                f=open(VariablesManager.VARIABLES_DIR+item,"w")
588                                data=unicode(json.dumps(tmp,indent=4,encoding="utf-8",ensure_ascii=False)).encode("utf-8")
589                                f.write(data)
590                                f.close()
591                               
592                                if "root_protected" in tmp_vars[item]:
593                                        if tmp_vars[item]["root_protected"]:
594                                                self.chmod(VariablesManager.VARIABLES_DIR+item,0600)
595                                               
596                                               
597                        os.remove(VariablesManager.LOCK_FILE)
598                        return True
599                               
600                       
601                except Exception as e:
602                        os.remove(VariablesManager.LOCK_FILE)
603                        print (e)
604                        return False
605               
606                       
607               
608        #def write_file
609
610        def chmod(self,file,mode):
611                prevmask = os.umask(0)
612                try:
613                        os.chmod(file,mode)
614                        os.umask(prevmask)
615                        return True
616                except Exception as e:
617                        print e
618                        os.umask(prevmask)
619                        return False
620        #def chmod
621       
622        def init_variable(self,variable,args={},force=False,full_info=False):
623
624                try:
625                        funct=self.variables[variable]["function"]
626                        mod_name=funct[:funct.rfind(".")]
627                        funct_name=funct[funct.rfind(".")+1:]
628                        funct_name=funct_name.replace("(","")
629                        funct_name=funct_name.replace(")","")
630                        mod=importlib.import_module(mod_name)
631                        ret=getattr(mod,funct_name)(args)
632                        ok,exc=self.set_variable(variable,ret)
633                        if ok:
634                                return (True,ret)
635                        else:
636                                return (False,ret)
637                except Exception as e:
638                        return (False,e)
639               
640               
641        #def init_variable
642       
643       
644#class VariablesManager
645
646
647if __name__=="__main__":
648       
649        vm=VariablesManager()
650       
651        print vm.listvars()
652        print vm.init_variable("name_center")
653        args={}
654        args["iface"]="eth0"
655        print vm.init_variable("SERVER_IP",args)
656        print vm.write_file()
657        #print vm.get_variable("VARIABLE2",full_info=True)
658        #print vm.get_variable("VARIABLE3",full_info=True)
659        #print vm.showvars(var_list)
660       
661       
662               
663               
664               
665       
666       
667       
Note: See TracBrowser for help on using the repository browser.