Changeset 7824


Ignore:
Timestamp:
Jul 30, 2018, 9:23:26 AM (15 months ago)
Author:
daduve
Message:

First version

Location:
export-web-sites/trunk/fuentes
Files:
15 added
4 edited

Legend:

Unmodified
Added
Removed
  • export-web-sites/trunk/fuentes/export-web-sites.install/usr/share/export-web-sites/ExportWebSites.css

    r7823 r7824  
    1010
    1111
     12GtkCheckButton {
     13  -gtk-icon-source: -gtk-scaled(url("rsrc/checkbutton_unchecked.png"), url("rsrc/checkbutton_unchecked.png")); }
    1214
    13         GtkLabel {
     15GtkCheckButton:hover {
     16  -gtk-icon-source: -gtk-scaled(url("rsrc/checkbutton_unchecked_hover.png"), url("rsrc/checkbutton_unchecked_hover.png"));
     17  }
     18GtkCheckButton:focus {
     19  -gtk-icon-source: -gtk-scaled(url("rsrc/checkbutton_unchecked_hover.png"), url("rsrc/checkbutton_unchecked_hover.png"));
     20  }
     21
     22GtkCheckButton:checked {
     23  -gtk-icon-source: -gtk-scaled(url("rsrc/checkbutton_checked.png"), url("rsrc/checkbutton_checked.png"));
     24  }
     25 
     26  GtkCheckButton:checked:hover {
     27  -gtk-icon-source: -gtk-scaled(url("rsrc/checkbutton_checked_hover.png"), url("rsrc/checkbutton_checked_hover.png"));
     28  }
     29GtkCheckButton:checked:focus {
     30  -gtk-icon-source: -gtk-scaled(url("rsrc/checkbutton_checked_hover.png"), url("rsrc/checkbutton_checked_hover.png"));
     31  }
     32
     33
     34
     35
     36GtkLabel {
    1437                /*font: 12px;*/
    15         }
    16         #WINDOW {
     38}
     39
     40
     41#WINDOW {
    1742                background-color: #ffffff;
    1843}
  • export-web-sites/trunk/fuentes/export-web-sites.install/usr/share/export-web-sites/ExportWebSites.py

    r7823 r7824  
    3434       
    3535        # ********HACKKKKKK
    36         server="server"
     36        #server="server"
     37        moodle="moodle"
     38        jclic="jclic"
     39        pmb="pmb"
     40        web_sites=[moodle,jclic,pmb]
     41        initial_state=[]
    3742       
    3843        DEBUG=True
    3944       
    4045        def dprint(self,arg):
    41                 self.n4d_man.lprint(self.user_val, "[ExportWebSitesGUI] %s"%arg)
     46                #self.n4d_man.lprint(self.user_val, "[ExportWebSitesGUI] %s"%arg)
    4247                if ExportWebSites.DEBUG:
    4348                        print("[ExportWebSitesGUI] %s"%arg)
     
    4853        def __init__(self,args_dic):
    4954               
    50                 #self.n4d_man=N4dManager.N4dManager()
     55                self.n4d_man=N4dManager.N4dManager()
    5156                #self.n4d_man.set_server(args_dic[self.server])
    5257               
     
    6469                builder=Gtk.Builder()
    6570                builder.set_translation_domain('export-web-sites')
    66                 builder.add_from_file("/usr/share//rsrc/export-web-sites.ui")
     71                builder.add_from_file("/usr/share/export-web-sites/rsrc/export-web-sites.ui")
    6772                self.main_window=builder.get_object("main_window")
    6873                self.main_window.set_icon_from_file('/usr/share/export-web-sites/rsrc/export-web-sites-icon.svg')
     
    8590                self.entry_user=builder.get_object("entry1")
    8691                self.entry_password=builder.get_object("entry2")
     92                self.entry_server=builder.get_object("entry3")
    8793                self.login_msg_label=builder.get_object("login_msg_label")
    8894               
     
    9096                #self.separator4 = builder.get_object("separator4")
    9197               
    92                 self.switch_moodle = builder.get_object("switch1")
    93                 self.switch_jclic = builder.get_object("switch2")
    94                 self.switch_pmb = builder.get_object("switch3")
     98                self.switch_moodle = builder.get_object("checkbutton1")
     99                self.switch_jclic = builder.get_object("checkbutton2")
     100                self.switch_pmb = builder.get_object("checkbutton3")
    95101               
    96102                self.apply_button=builder.get_object("apply_button")
     
    98104                self.spinner=builder.get_object("spinner")
    99105               
    100                 #self.set_css_info()
     106                self.set_css_info()
    101107               
    102108                self.connect_signals()
    103109                self.main_window.show()
     110               
     111                self.apply_button.set_sensitive(False)
    104112               
    105113        #def start_gui
     
    115123                self.apply_button.set_name("OPTION_BUTTON")
    116124                self.login_button.set_name("OPTION_BUTTON")
    117                
    118                 #self.entry_user.set_name("OPTION_ENTRY")
    119                 #self.entry_password.set_name("OPTION_ENTRY")
    120                
    121                 #self.separator3.set_name("OPTION_SEPARATOR")
    122                 #self.separator4.set_name("OPTION_SEPARATOR")
    123                
    124                 '''self.checkb1.set_name("CHECKMARK")
    125                 self.checkb2.set_name("CHECKMARK")
    126                 self.checkb3.set_name("CHECKMARK")
    127                 self.checkb4.set_name("CHECKMARK")
    128                 self.checkb5.set_name("CHECKMARK")
    129                 self.checkb6.set_name("CHECKMARK")'''
    130125                       
    131126        #def set-css_info
     
    136131                self.main_window.connect("destroy",Gtk.main_quit)
    137132               
    138                 #self.apply_button.connect("clicked",self.apply_button_clicked)
     133                self.apply_button.connect("clicked",self.apply_button_clicked)
    139134               
    140135                self.login_button.connect("clicked",self.login_clicked)
    141136                self.entry_password.connect("activate",self.entries_press_event)
     137                self.entry_server.connect("activate",self.entries_press_event)
     138               
     139                self.switch_moodle.connect("notify::active",self.activate_apply_button)
     140                self.switch_pmb.connect("notify::active",self.activate_apply_button)
     141                self.switch_jclic.connect("notify::active",self.activate_apply_button)
    142142               
    143143        #def connect_signals
     
    150150               
    151151        #def entries_press_event
     152       
     153        def activate_apply_button(self,entry,event):
     154               
     155                self.apply_button.set_sensitive(True)
     156                self.txt_apply.set_markup("")
     157               
     158        #def activate_apply_button
    152159       
    153160        def login_clicked(self,button):
     
    158165                user=self.entry_user.get_text()
    159166                password=self.entry_password.get_text()
     167                user="netadmin"
     168                password="lliurex"
    160169                self.user_val=(user,password)
    161                 server="server"
     170                server=self.entry_server.get_text()
     171               
     172                self.n4d_man.set_server(server)
    162173               
    163174                #self.validate_user(user,password)
     175                # HACKED DELETE THIS LINE and delete commnet before
     176                self.initial_state=self.n4d_man.read_export_sites(self.user_val,self.web_sites)
     177                self.dprint(self.initial_state[1])
     178                for service in self.web_sites:
     179                        self.dprint("Testing if is active service: %s "%service)
     180                        self.dprint(self.initial_state[1][service])
     181                        state=self.initial_state[1][service]["install"]
     182                        exec("self.switch_%s.set_active(state)"%service)
     183                self.apply_button.set_sensitive(False)
     184               
     185                self.stack.set_visible_child_name("main")
    164186               
    165187        #def login_clicked
     
    179201                        return True
    180202                               
    181                 self.login_button.set_sensitive(True)
    182203               
    183204                if not self.n4d_man.user_validated:
     
    191212                                       
    192213                        if group_found:
    193                                 self.n4d_man.get_client_list()
     214
    194215                                # ***START LOG
    195216                                self.dprint("")
    196                                 self.dprint("** START HOME ERASER GUI **")
     217                                self.dprint("** START EXPORT WEB SITES GUI **")
    197218                                self.dprint("   ---------------------")
    198219                                self.dprint("")
     
    200221                               
    201222                                self.stack.set_visible_child_name("main")
    202                                 self.dprint("Clients connected: %s"%self.n4d_man.detected_clients)
    203                                 self.num_clients_glade.set_text(str(self.n4d_man.detected_clients))
    204                                
    205                                 t2=threading.Thread(target=self.n4d_man.update_client_list_thread)
    206                                 t2.daemon=True
    207                                 t2.start()
    208                                
    209                                 GLib.timeout_add(5000,self.client_list_listener)
    210                         else:
    211                                 self.login_msg_label.set_markup("<span foreground='red'>"+_("Invalid user, please only admin users.")+"</span>")
    212                
    213        
    214        
    215         def client_list_listener(self):
    216                
    217                 self.num_clients_glade.set_text(str(self.n4d_man.detected_clients))
    218                 return True
    219                
    220         #def  client_list_listener
     223                               
     224                        else:
     225                                self.login_msg_label.set_markup("<span foreground='red'>"+_("Invalid user, please only netadmin users.")+"</span>")
     226               
     227        #validate_user_listener
    221228
    222229
     
    226233               
    227234                try:                   
    228                        
    229                         delete={}
    230                         delete[self.home]=[]
    231                         delete[self.net]=[]
    232                        
    233                         info={}
    234                         info[self.students]={}
    235                        
    236                        
    237                         info[self.students][self.home]=self.checkb1.get_active()
    238                         if info[self.students][self.home]:
    239                                 delete[self.home].append("students")
    240                         info[self.students][self.net]=self.checkb4.get_active()
    241                         if info[self.students][self.net]:
    242                                 delete[self.net].append("students")
    243                         info[self.teachers]={}
    244                         info[self.teachers][self.home]=self.checkb2.get_active()
    245                         if info[self.teachers][self.home]:
    246                                 delete[self.home].append("teachers")
    247                         info[self.teachers][self.net]=self.checkb5.get_active()
    248                         if info[self.teachers][self.net]:
    249                                 delete[self.net].append("teachers")
    250                         info[self.admins]={}
    251                         info[self.admins][self.home]=self.checkb3.get_active()
    252                         if info[self.admins][self.home]:
    253                                 delete[self.home].append("admins")
    254                         info[self.admins][self.net]=self.checkb6.get_active()
    255                         if info[self.admins][self.net]:
    256                                 delete[self.net].append("admins")
    257                        
    258                        
    259                        
    260                         for g in info:
    261                                 self.dprint(g)
    262                                 for d in info[g]:
    263                                         self.dprint("\t %s : %s"%(d,info[g][d]))
    264 
    265                         self.dprint("Summary to remove this elements: %s"%(delete))
    266                        
    267                         #Are you sure to delete????
    268                        
    269                         if ( len(delete[self.home]) >0 ) or ( len(delete[self.net]) >0 ):
    270                                
    271                                 #dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.WARNING, Gtk.ButtonsType.YES_NO, "HOME ERASER")
    272                                 #dialog.format_secondary_text(_("Are you sure you want to delete?"))
    273                                
    274                                 dialog=Dialog.QuestionDialog(self.main_window,_(u"HOME ERASER"),_(u"Are you sure you want to delete?"))
    275                                 response=dialog.run()
    276                                 dialog.destroy()
    277                                 #if response == Gtk.ResponseType.YES:
    278                                 if response == Gtk.ResponseType.OK:
    279                                        
    280                                         self.apply_button.set_sensitive(False)
    281                                         self.checkb1.set_sensitive(False)
    282                                         self.checkb2.set_sensitive(False)
    283                                         self.checkb3.set_sensitive(False)
    284                                         self.checkb4.set_sensitive(False)
    285                                         self.checkb5.set_sensitive(False)
    286                                         self.checkb6.set_sensitive(False)
    287                                         self.txt_apply.set_text(_("Working........"))
    288                                         self.apply_delete_methods_thread(delete)
    289                         else:
    290                                 #dialog = Gtk.MessageDialog(None,0,Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "HOME ERASER")
    291                                 #dialog.format_secondary_text(_("You didn't select any option to delete."))
    292                                 dialog=Dialog.InfoDialog(self.main_window,_(u"HOME ERASER"),_(u"You didn't select any option to delete."))
    293                                 response=dialog.run()
    294                                 dialog.destroy()
    295                        
     235                        self.apply_button.set_sensitive(False)
     236                        self.switch_moodle.set_sensitive(False)
     237                        self.switch_jclic.set_sensitive(False)
     238                        self.switch_pmb.set_sensitive(False)
     239                               
     240                        export={}
     241                        export[self.moodle]=False
     242                        export[self.jclic]=False
     243                        export[self.pmb]=False
     244                       
     245                        self.dprint("")
     246                        self.dprint("RESUME APPLY")
     247                        self.dprint("-------------")
     248                        export[self.moodle]=self.switch_moodle.get_active()
     249                        if export[self.moodle]:
     250                                self.dprint("Export Moodle....")
     251                        else:
     252                                self.dprint("Unexport Moodle....")
     253                        export[self.jclic]=self.switch_jclic.get_active()
     254                        if export[self.jclic]:
     255                                self.dprint("Export jclic")
     256                        else:
     257                                self.dprint("Unexport Jclic....")
     258                        export[self.pmb]=self.switch_pmb.get_active()
     259                        if export[self.pmb]:
     260                                self.dprint("Export pmb")       
     261                        else:
     262                                self.dprint("Unexport Pmb....")
     263                       
     264                        self.dprint("")
     265                       
     266                        self.apply_export_web_sites_thread(export)
    296267                       
    297268                except Exception as e:
     
    304275       
    305276       
    306         def apply_delete_methods_thread(self,delete):
    307                
    308                 t=threading.Thread(target=self.apply_delete_methods,args=(delete,))
     277        def apply_export_web_sites_thread(self,export):
     278               
     279                t=threading.Thread(target=self.apply_export_web_sites,args=(export,))
    309280                t.daemon=True
    310281                t.start()
    311282                self.spinner.start()
    312                 GLib.timeout_add(500,self.sure_delete,t)
     283                GLib.timeout_add(500,self.sure_export,t)
    313284               
    314285        #apply_delete_methods_thread
    315286       
    316287               
    317         def sure_delete(self,thread):
     288        def sure_export(self,thread):
    318289               
    319290                try:
    320291                        if thread.is_alive():
     292                                self.apply_button.set_sensitive(False)
    321293                                return True
    322294                       
    323                         self.detect_connected_clients_cancelled=True
     295                        self.switch_moodle.set_sensitive(True)
     296                        self.switch_jclic.set_sensitive(True)
     297                        self.switch_pmb.set_sensitive(True)
     298                               
    324299                        self.spinner.stop()
    325300                        self.txt_apply.set_markup("<span foreground='blue'>"+_("Finished. Log is found in /var/log/export-web-sites.log ")+"</span>")
     
    337312       
    338313       
    339         def apply_delete_methods(self,delete):
     314        def apply_export_web_sites(self,export):
    340315               
    341316                try:
    342                        
    343                        
    344                        
    345                         #DELETE LOCAL HOMES IN FAT CLIENTS
    346                         if ( len(delete[self.home] ) > 0 ):
    347                                 ips_detele=self.n4d_man.ips_connected
    348                                 self.dprint("Apply to clients: %s"%(ips_detele))
    349                                 r=self.n4d_man.delete_clients_homes(self.user_val,ips_detele, delete[self.home])
    350                                 if r[0]:
    351                                         #shared in resume all ips and paths deleted
    352                                         self.resume_home={**self.resume_home,**r[1]}
    353                        
    354                         #print resume home deleted in fat clients
    355                         if (  len(self.resume_home) >0 ):
    356                                 self.dprint("")
    357                                 self.dprint("Summary for HOMES deleted")
    358                                 for i in self.resume_home:
    359                                         self.dprint("%s : %s"%(i,self.resume_home[i]))
    360                        
    361                        
    362                         #DELETE /NET DIRECTORIES
    363                         if ( len(delete[self.net] ) > 0 ):
    364                                 rnet=self.n4d_man.delete_net_homes(self.user_val,delete[self.net])
    365                                 if rnet[0]:
    366                                         self.resume_net=rnet[1]
    367                                         self.dprint("")
    368                                         self.dprint("Summary for paths in /NET deleted:")
    369                                         for i in rnet[1]:
    370                                                 self.dprint(i)
    371                        
    372                        
    373                        
    374                         return[True,self.resume_home,self.resume_net]
     317                        exec_error=False
     318                        resume={}
     319                        resume[self.moodle]=[]
     320                        resume[self.jclic]=[]
     321                        resume[self.pmb]=[]
     322                        export_service=False
     323                        restart_apache=False
     324                       
     325                        self.dprint("---------------------WORKING---------------------------")
     326                       
     327                        for service in self.web_sites:
     328                                self.dprint("Service: %s "%service)
     329                                #self.dprint(self.initial_state[1][service])
     330                                state=self.initial_state[1][service]["install"]
     331                               
     332                                if ( state != export[service] ):
     333                                        self.dprint("Operating in server....")
     334                                        if export[service]:
     335                                                self.dprint("Calling N4D to export %s"%service)
     336                                                resume[service]=self.n4d_man.export_web_sites(self.user_val,service)
     337                                                export_service=True
     338                                                restart_apache=True
     339                                        else:
     340                                                self.dprint("Calling N4D to remove %s"%service)
     341                                                resume[service]=self.n4d_man.un_export_web_sites(self.user_val,service)
     342                                                restart_apache=True
     343                                        if resume[service][0]:
     344                                                self.dprint("Work in server, did it.")
     345                                        else:
     346                                                self.dprint("Something wrong")
     347                                                exec_error=True
     348                                else:
     349                                        self.dprint("Do nothing")
     350                       
     351                        if export_service:
     352                                if self.n4d_man.export_active(self.user_val)[0]:
     353                                        self.dprint("Apache Export Service is avaiable")
     354                                else:
     355                                        self.dprint("Error with Apache Export Service")
     356                                       
     357                        if self.n4d_man.sites_configuration(self.user_val)[0]:
     358                                self.dprint("Sites-configuration is configured")
     359                        else:
     360                                self.dprint("Error Sites-configuration")
     361                       
     362                       
     363                        if restart_apache:
     364                                apache2_restart=self.n4d_man.apache2_restart(self.user_val)
     365                                self.dprint(apache2_restart)
     366                                if ( apache2_restart[2] == "" ):
     367                                        self.dprint("Apache Service has been restarted")
     368                                else:
     369                                        self.dprint("Apache Service has a problem please contact with adminsitrator")
     370                                        self.dprint("Apache Service Status: %s"%apache2_restart[1])
     371                                        self.dprint("Apache Service Error: %s"%apache2_restart[2])
     372                       
     373                        self.dprint("")
     374                        self.dprint("---------------------RESUME---------------------------")
     375                       
     376                        self.initial_state=self.n4d_man.read_export_sites(self.user_val,self.web_sites)
     377                        self.dprint("---------------------FINISHED---------------------------")
     378                        self.dprint("")
     379                        return[True,resume,exec_error]
    375380                                       
    376381                except Exception as e:
  • export-web-sites/trunk/fuentes/export-web-sites.install/usr/share/export-web-sites/N4dManager.py

    r7823 r7824  
    77class N4dManager:
    88       
     9        moodle="moodle"
     10        jclic="jclic"
     11        pmb="pmb"
     12       
    913        def __init__(self,server=None):
    1014               
    11                 self.debug=False
     15                self.debug=True
    1216               
    1317                self.user_validated=False
    1418                self.client=None
    1519                self.user_val=()
    16                 self.user_groups=[]
    1720                self.validation=None
    18                 self.detected_clients=0
    19                 self.ips_connected=[]
    2021
    2122                if server!=None:
     
    2627        def lprint(self,validation,arg):
    2728               
    28                 self.client.lprint(validation,"HomeEraserServer", arg)
     29                self.client.lprint(validation,"ExportWebServices", arg)
    2930               
    3031        #def_lprint
    3132       
    32        
    3333        def mprint(self,msg):
    3434               
    3535                if self.debug:
    36                         print("[HomeEraserN4DManager] %s"%str(msg))
     36                        print("[ExportWebServicesN4DManager] %s"%str(msg))
    3737                       
    3838        #def mprint
     
    6161        #def validate_user
    6262       
    63         def delete_net_homes(self,validation,groups_to_delete):
     63        def export_web_sites(self,validation,web_site):
    6464                               
    65                 resume=[]
    66                
    67                 try:
    68                         context=ssl._create_unverified_context()
    69                         tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
    70                         resolve=tmp.delete_net_home(validation,"HomeEraserServer", groups_to_delete)
     65                resolve=[]
     66               
     67                try:
     68                        context=ssl._create_unverified_context()
     69                        tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
     70                        self.mprint("From N4D Manager calling to server to export %s"%web_site)
     71                        if (  web_site == self.moodle ):
     72                                resolve=tmp.export_moodle(validation,"ExportWebSites")
     73                                if (  resolve == "USER DOES NOT EXIST" ):
     74                                        return[False,"YOUR USER[%s] CAN'T MAKE THIS CHANGES IN THE SERVER"%validation[0]]
     75                                if resolve[0]:
     76                                        return[True,resolve]
     77                                else:
     78                                        return[False]
     79                                       
     80                        elif(  web_site == self.jclic ):
     81                                resolve=tmp.export_jclic(validation,"ExportWebSites")
     82                                if (  resolve == "USER DOES NOT EXIST" ):
     83                                        return[False,"YOUR USER[%s] CAN'T MAKE THIS CHANGES IN THE SERVER"%validation[0]]
     84                                #self.mprint(resolve)
     85                                if resolve[0]:
     86                                        return[True,resolve]
     87                                else:
     88                                        return[False]
     89                                       
     90                        elif(  web_site == self.pmb ):
     91                                resolve=tmp.export_pmb(validation,"ExportWebSites")
     92                                if (  resolve == "USER DOES NOT EXIST" ):
     93                                        return[False,"YOUR USER[%s] CAN'T MAKE THIS CHANGES IN THE SERVER"%validation[0]]
     94                                #self.mprint(resolve)
     95                                if resolve[0]:
     96                                        return[True,resolve]
     97                                else:
     98                                        return[False]
     99       
     100                except Exception as e:
     101                        print ("[ExportWebServicesN4DManager] ERROR: %s"%e)
     102                        self.lprint (validation,"[ExportWebServicesN4DManager] %s"%e)
     103                        return [False,str(e)]   
     104               
     105        #def export_web_sites
     106       
     107        def un_export_web_sites(self,validation,web_site):
     108                               
     109                resolve=[]
     110               
     111                try:
     112                        context=ssl._create_unverified_context()
     113                        tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
     114                        self.mprint("From N4D Manager calling to server to cancel the exportation %s"%web_site)
     115                        if (  web_site == self.moodle ):
     116                                resolve=tmp.un_export_moodle(validation,"ExportWebSites")
     117                                if (  resolve == "USER DOES NOT EXIST" ):
     118                                        return[False,"YOUR USER[%s] CAN'T MAKE THIS CHANGES IN THE SERVER"%validation[0]]
     119                                if resolve[0]:
     120                                        return[True,resolve]
     121                                else:
     122                                        return[False]
     123                                       
     124                        elif(  web_site == self.jclic ):
     125                                resolve=tmp.un_export_jclic(validation,"ExportWebSites")
     126                                #self.mprint(resolve)
     127                                if (  resolve == "USER DOES NOT EXIST" ):
     128                                        return[False,"YOUR USER[%s] CAN'T MAKE THIS CHANGES IN THE SERVER"%validation[0]]
     129                                if resolve[0]:
     130                                        return[True,resolve]
     131                                else:
     132                                        return[False]
     133                                       
     134                        elif(  web_site == self.pmb ):
     135                                resolve=tmp.un_export_pmb(validation,"ExportWebSites")
     136                                #self.mprint(resolve)
     137                                if (  resolve == "USER DOES NOT EXIST" ):
     138                                        return[False,"YOUR USER[%s] CAN'T MAKE THIS CHANGES IN THE SERVER"%validation[0]]
     139                                if resolve[0]:
     140                                        return[True,resolve]
     141                                else:
     142                                        return[False]
     143       
     144                except Exception as e:
     145                        print ("[ExportWebServicesN4DManager] ERROR: %s"%e)
     146                        self.lprint (validation,"[ExportWebServicesN4DManager] %s"%e)
     147                        return [False,str(e)]   
     148               
     149        #def un_export_web_sites
     150       
     151        def read_export_sites(self,validation,web_sites):
     152               
     153                try:
     154                        context=ssl._create_unverified_context()
     155                        tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
     156                        self.mprint("Reading inital state in server....")
     157                        resolve=tmp.read_export_sites(validation,"ExportWebSites",web_sites)
     158                        self.mprint("Solved: %s"%resolve)
    71159                        if resolve[0]:
    72                                 resume=resolve[1]
    73                                        
    74                         return[True,resume]
    75        
    76                 except Exception as e:
    77                         print ("[HomeEraserN4DManager] ERROR: %s"%e)
    78                         self.lprint (validation,"[HomeEraserServer] %s"%e)
    79                         return [False,str(e)]   
    80                
    81         #def delete_net_homes
    82        
    83        
    84        
    85        
    86        
    87         def delete_clients_homes(self,validation,clients,groups_to_delete):
    88                                
    89                 resume={}
    90                
    91                 try:
    92                         context=ssl._create_unverified_context()
    93                         #Delete homes in Fat clients
    94                         if ( len(clients) > 0 ):
    95                                 for ip in clients:
    96                                         self.mprint("Deleting client: %s"%ip)
    97                                         tmp=xmlrpc.client.ServerProxy("https://%s:9779"%ip,allow_none=True,context=context)
    98                                         resolve=tmp.delete_home(validation,"HomeEraserClient", groups_to_delete)
    99                                         if resolve[0]:
    100                                                 resume[ip]=resolve[1]
    101                                
    102                         #Delete homes in Server
    103                         tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
    104                         resolve=tmp.delete_home(validation,"HomeEraserServer", groups_to_delete)
    105                         if resolve[0]:
    106                                 resume["server"]=resolve[1]
    107                                        
    108                         return[True,resume]
    109        
    110                 except Exception as e:
    111                         print ("[HomeEraserN4DManager] ERROR: %s"%e)
    112                         self.lprint (validation,"[HomeEraserServer] %s"%e)
    113                         return [False,str(e)]   
    114                
    115         #def delete_clients_homes
    116        
    117        
    118        
    119         def get_client_list(self):
    120                
    121                 try:
    122                         self.ips_connected=[]
    123                         self.mprint(self.client.manual_client_list_check(self.user_val,"VariablesManager"))
    124                         self.ret=self.client.get_client_list("","VariablesManager")
    125                        
    126                         count=0
    127                         for item in self.ret:
    128                                 if self.ret[item]["missed_pings"]<1:
    129                                         count+=1
    130                                 self.ips_connected.append(self.ret[item]["ip"])
    131                                        
    132                         self.detected_clients=count
    133                         self.mprint("Clients connected N4D: %s"%self.detected_clients)
    134                        
    135                 except Exception as e:
    136                         print ("[HomeEraserN4DManager] ERROR: %s"%e)
    137                         return [False,str(e)]   
    138                        
    139         #def get_client_list
    140        
    141        
    142         def update_client_list_thread(self):
    143                
    144                 try:
    145                         while True:
    146                                 time.sleep(5)
    147                                 self.get_client_list()
    148                                 self.mprint("Clients connected Thread: %s"%self.detected_clients)
    149                
    150                 except Exception as e:
    151                         print ("[HomeEraserN4DManager] ERROR: %s"%e)
    152                         return [False,str(e)]
    153                        
    154         #def update_client_list_thread
     160                                return[True,resolve[1]]
     161                        else:
     162                                return[False,resolve[1]]
     163       
     164                except Exception as e:
     165                        print ("[ExportWebServicesN4DManager] ERROR: %s"%e)
     166                        self.lprint (validation,"[ExportWebServicesN4DManager] %s"%e)
     167                        return [False,str(e)]   
     168               
     169        #def read_export_sites
     170       
     171       
     172        def export_active(self,validation):
     173               
     174                try:
     175                        context=ssl._create_unverified_context()
     176                        tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
     177                        self.mprint("Does Server have mod-enabled to export sites?")
     178                        resolve=tmp.export_active(validation,"ExportWebSites")
     179                        return[resolve]
     180       
     181                except Exception as e:
     182                        print ("[ExportWebServicesN4DManager] ERROR: %s"%e)
     183                        self.lprint (validation,"[ExportWebServicesN4DManager] %s"%e)
     184                        return [False,str(e)]   
     185               
     186        #def export_active
     187       
     188        def apache2_restart(self,validation):
     189               
     190                try:
     191                        context=ssl._create_unverified_context()
     192                        tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
     193                        self.mprint("Restarting Apache 2 service")
     194                        resolve=tmp.apache2_restart(validation,"ExportWebSites")
     195                        self.mprint(resolve)
     196                        return resolve
     197       
     198                except Exception as e:
     199                        print ("[ExportWebServicesN4DManager] ERROR: %s"%e)
     200                        self.lprint (validation,"[ExportWebServicesN4DManager] %s"%e)
     201                        return [False,str(e)]   
     202               
     203        #def apache2_restart
     204       
     205        def sites_configuration(self,validation):
     206               
     207                try:
     208                        context=ssl._create_unverified_context()
     209                        tmp=xmlrpc.client.ServerProxy("https://server:9779",allow_none=True,context=context)
     210                        self.mprint("Restarting Apache 2 service")
     211                        resolve=tmp.sites_configuration(validation,"ExportWebSites")
     212                        self.mprint(resolve)
     213                        return resolve
     214       
     215                except Exception as e:
     216                        print ("[ExportWebServicesN4DManager] ERROR: %s"%e)
     217                        self.lprint (validation,"[ExportWebServicesN4DManager] %s"%e)
     218                        return [False,str(e)]   
     219               
     220        #def sites_configuration
     221       
  • export-web-sites/trunk/fuentes/export-web-sites.install/usr/share/export-web-sites/rsrc/export-web-sites.ui

    r7823 r7824  
    105105    </child>
    106106    <child>
     107      <object class="GtkBox" id="box4">
     108        <property name="visible">True</property>
     109        <property name="can_focus">False</property>
     110        <property name="halign">start</property>
     111        <property name="valign">center</property>
     112        <property name="margin_top">12</property>
     113        <property name="margin_bottom">4</property>
     114        <property name="spacing">6</property>
     115        <child>
     116          <object class="GtkLabel" id="label4">
     117            <property name="visible">True</property>
     118            <property name="can_focus">False</property>
     119            <property name="label" translatable="yes">Server:</property>
     120          </object>
     121          <packing>
     122            <property name="expand">False</property>
     123            <property name="fill">True</property>
     124            <property name="position">0</property>
     125          </packing>
     126        </child>
     127      </object>
     128      <packing>
     129        <property name="expand">False</property>
     130        <property name="fill">True</property>
     131        <property name="position">4</property>
     132      </packing>
     133    </child>
     134    <child>
     135      <object class="GtkEntry" id="entry3">
     136        <property name="height_request">10</property>
     137        <property name="visible">True</property>
     138        <property name="can_focus">True</property>
     139        <property name="valign">center</property>
     140        <property name="text" translatable="yes">server</property>
     141      </object>
     142      <packing>
     143        <property name="expand">False</property>
     144        <property name="fill">False</property>
     145        <property name="position">5</property>
     146      </packing>
     147    </child>
     148    <child>
    107149      <object class="GtkButton" id="login_button">
    108150        <property name="label" translatable="yes">Login</property>
     
    118160        <property name="expand">False</property>
    119161        <property name="fill">False</property>
    120         <property name="position">4</property>
     162        <property name="position">6</property>
    121163      </packing>
    122164    </child>
     
    129171        <property name="expand">False</property>
    130172        <property name="fill">True</property>
    131         <property name="position">5</property>
     173        <property name="position">7</property>
    132174      </packing>
    133175    </child>
     
    136178    <property name="visible">True</property>
    137179    <property name="can_focus">False</property>
     180    <property name="halign">center</property>
     181    <property name="valign">center</property>
    138182    <property name="orientation">vertical</property>
    139183    <child>
     
    148192            <property name="visible">True</property>
    149193            <property name="can_focus">False</property>
     194            <property name="halign">start</property>
     195            <property name="valign">center</property>
    150196            <property name="xpad">10</property>
     197            <property name="wrap">True</property>
     198            <property name="width_chars">0</property>
     199            <property name="max_width_chars">40</property>
    151200          </object>
    152201          <packing>
     
    260309            <property name="spacing">15</property>
    261310            <child>
    262               <object class="GtkSwitch" id="switch1">
     311              <object class="GtkCheckButton" id="checkbutton1">
    263312                <property name="visible">True</property>
    264313                <property name="can_focus">True</property>
     314                <property name="receives_default">False</property>
     315                <property name="xalign">0</property>
     316                <property name="draw_indicator">True</property>
     317                <child>
     318                  <placeholder/>
     319                </child>
    265320              </object>
    266321              <packing>
     
    271326            </child>
    272327            <child>
    273               <object class="GtkSwitch" id="switch2">
     328              <object class="GtkCheckButton" id="checkbutton2">
    274329                <property name="visible">True</property>
    275330                <property name="can_focus">True</property>
     331                <property name="receives_default">False</property>
     332                <property name="xalign">0</property>
     333                <property name="draw_indicator">True</property>
     334                <child>
     335                  <placeholder/>
     336                </child>
    276337              </object>
    277338              <packing>
     
    282343            </child>
    283344            <child>
    284               <object class="GtkSwitch" id="switch3">
     345              <object class="GtkCheckButton" id="checkbutton3">
    285346                <property name="visible">True</property>
    286347                <property name="can_focus">True</property>
     348                <property name="receives_default">False</property>
     349                <property name="xalign">0</property>
     350                <property name="draw_indicator">True</property>
     351                <child>
     352                  <placeholder/>
     353                </child>
    287354              </object>
    288355              <packing>
     
    313380        <property name="halign">center</property>
    314381        <property name="valign">center</property>
     382        <property name="margin_top">20</property>
    315383      </object>
    316384      <packing>
Note: See TracChangeset for help on using the changeset viewer.