Changeset 6763


Ignore:
Timestamp:
Feb 2, 2018, 1:32:59 PM (19 months ago)
Author:
Juanma
Message:

WIP on expert mode

Location:
taskscheduler/trunk/fuentes
Files:
3 added
1 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • taskscheduler/trunk/fuentes/client-scheduler.install/usr/share/n4d/python-plugins/SchedulerClient.py

    r6755 r6763  
    44###
    55
     6# -*- coding: utf-8 -*-
    67import os,socket
    78import threading
     
    1516                self.cron_dir='/etc/cron.d'
    1617                self.count=0
    17                 self.dbg=0
     18                self.dbg=1
    1819
    1920        def startup(self,options):
     
    4142                self._debug("Scheduling tasks")
    4243                prefixes={'remote':True,'local':False}
     44                tasks={}
    4345                try:
    4446                        socket.gethostbyname('server')
    4547                except:
    4648                                prefixes={'local':False}
    47                 for prefix,sw_remote in prefixes.items():
     49                for prefix,sw_remote in prefixes.iteritems():
    4850                        if prefix=='remote':
    4951                                n4d=xmlrpc.ServerProxy("https://server:9779")
    5052                        else:
    5153                                n4d=xmlrpc.ServerProxy("https://localhost:9779")
    52                         tasks=n4d.get_tasks("","SchedulerServer",sw_remote,False)['data']
     54                        tasks=n4d.get_tasks("","SchedulerServer",sw_remote,False)['data'].copy()
    5355                        #Delete files
    5456                        for f in os.listdir(self.cron_dir):
     
    5759                        #Create the cron files
    5860                        task_names={}
    59                         for task in tasks:
    60                                 for name in task.keys():
     61                        for name in tasks.keys():
     62                                for serial in tasks[name].keys():
    6163                                        self._debug("Scheduling %s"%name)
    6264                                        fname=name.replace(' ','_')
    63                                         task_names[fname]=task
    64                                         self._write_crontab_for_task(task_names[fname],prefix)
     65                                        task_names[fname]=tasks[name][serial].copy()
     66                                        self._write_crontab_for_task(task_names,prefix)
    6567
    6668        #def process_tasks
    6769
    6870        def _write_crontab_for_task(self,ftask,prefix):
    69                 task=list(ftask.keys())[0]
    70                 for task_name,task_data in ftask.items():
     71                cron_array=[]
     72                for task_name,task_data in ftask.iteritems():
     73                        self._debug("Writing data %s"%task_name)
    7174                        fname=self.cron_dir+'/'+prefix+task_name.replace(' ','_')
    72                         cron_array=[]
    73                         for task_serial,task_info in task_data.items():
    74                                 cron_task=("%s %s %s %s %s root %s"%(task_info['m'],task_info['h'],task_info['dom'],\
    75                                                                 task_info['mon'],task_info['dow'],task_info['cmd']))
    76                                 cron_array.append(cron_task)
     75                        cron_task=("%s %s %s %s %s root %s"%(task_data['m'],task_data['h'],task_data['dom'],\
     76                                                        task_data['mon'],task_data['dow'],u""+task_data['cmd']))
     77                        cron_array.append(cron_task)
     78#                       for task_serial,task_info in task_data.items():
     79#                               cron_task=("%s %s %s %s %s root %s"%(task_info['m'],task_info['h'],task_info['dom'],\
     80#                                                               task_info['mon'],task_info['dow'],task_info['cmd']))
     81#                               cron_array.append(cron_task)
    7782                        if task_data:
    7883                                with open(fname,'w') as data:
     
    8994                                                data.write('http_proxy=%s\n'%http_proxy)
    9095                                        for cron_line in cron_array:
    91                                                 data.write(cron_line+"\n")
     96                                                data.write(cron_line.encode('utf8')+"\n")
    9297        #def _write_crontab_for_task
    9398
  • taskscheduler/trunk/fuentes/python3-taskscheduler.install/usr/share/taskscheduler/taskscheduler.py

    r6755 r6763  
    5151        def get_scheduled_tasks(self,sw_remote):
    5252                tasks={}
    53                 self._debug("Retrieving %s task list"%sw_remote)
    54                 if self.n4dserver:
    55                         result=self.n4dserver.get_tasks("","SchedulerServer",True)
     53                self._debug("Retrieving task list remote=%s"%sw_remote)
     54                if self.n4dserver and sw_remote:
     55                        result=self.n4dserver.get_tasks("","SchedulerServer",True,False)
    5656                        if type(result)==type({}):
    5757                                tasks=result['data'].copy()
    58                 result=self.n4dclient.get_tasks("","SchedulerServer",False)
    59                 if type(result)==type({}):
    60                         tasks.update(result['data'].copy())
     58                elif sw_remote==False:
     59                        result=self.n4dclient.get_tasks("","SchedulerServer",False,False)
     60                        if type(result)==type({}):
     61                                tasks.update(result['data'])
    6162                return tasks
    6263        #def get_scheduled_tasks
     
    8889                tasks=self.get_available_tasks()
    8990                for task_desc,task_data in tasks.items():
    90                         if task_description in task_data.keys():
     91                        if task_desc in task_data.keys():
    9192                                cmd=task_data[i18n_cmd]
    9293                                sw_found=True
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py

    r6755 r6763  
    1919from taskscheduler.taskscheduler import TaskScheduler as scheduler
    2020from taskscheduler.cronParser import cronParser
    21 from DetailBox import DetailBox as TaskDetails
     21from fixedDateBox import DetailBox as fixedDateTask
     22from intervalDateBox import DetailBox as intervalDateTask
     23from dailyDateBox import DetailBox as dailyDateTask
    2224from edupals.ui.n4dgtklogin import *
    2325import signal
     
    4648                self.ldm_helper='/usr/sbin/sched-ldm.sh'
    4749                self.i18n={}
    48                 self.types={'fix':TaskDetails,'repeat':'TaskRepeat','days':TaskDetails}
     50                self.types={'fix':fixedDateTask,'repeat':'TaskRepeat','days':fixedDateTask}
    4951                       
    5052        #def __init__           
     
    6466
    6567        def start_gui(self):
    66                 self.scheduler_client=scheduler()
     68                self.scheduler=scheduler()
    6769                builder=Gtk.Builder()
    6870                builder.set_translation_domain('taskscheduler')
     
    159161                self.tasks_label=builder.get_object("tasks_label")
    160162                self.tasks_tv=builder.get_object("tasks_treeview")
    161                 self.task_details_grid=TaskDetails(self.scheduler_client)
    162 #               self.task_details_grid=DetailBox.DetailBox(self.scheduler_client)
     163                self.task_details_grid=fixedDateTask(self.scheduler)
     164#               self.task_details_grid=DetailBox.DetailBox(self.scheduler)
    163165                td_grid=self.task_details_grid.render_form(builder.get_object("task_details_grid"))
     166                self.detailGrid=builder.get_object("task_details_grid")
     167
    164168                self.task_details_grid.btn_apply.set_sensitive(True)
    165169                self.task_details_grid.btn_apply.connect("clicked",self.update_task)
     
    224228                #Add tasks
    225229                self.add_task_box=builder.get_object("add_task_box")
    226                 self.add_task_grid=TaskDetails(self.scheduler_client)
    227 #               self.add_task_grid=DetailBox(self.scheduler_client)
     230                self.add_task_grid=fixedDateTask(self.scheduler)
     231#               self.add_task_grid=DetailBox(self.scheduler)
    228232                at_grid=self.add_task_grid.render_form(builder.get_object("add_task_grid"),False)
     233                at_grid=builder.get_object("add_task_grid")
    229234                self.cmb_task_names=builder.get_object("cmb_task_names")
    230235                self.cmb_task_cmds=builder.get_object("cmb_task_cmds")
     
    249254                custom_grid.attach(txt_taskname,1,0,1,1)
    250255                cmb_cmds=Gtk.ComboBoxText()
    251                 cmds=self.scheduler_client.get_commands()
     256                cmds=self.scheduler.get_commands()
    252257                i18n_cmd={}
    253258                for cmd in cmds.keys():
     
    294299                cmd_desc=i18n_cmd[cmd]
    295300                parms=w_parms.get_text()
    296                 cmd=self.scheduler_client.get_command_cmd(cmd_desc)
     301                cmd=self.scheduler.get_command_cmd(cmd_desc)
    297302                if w_chk.get_active():
    298303                        parms=parms+' '+w_file.get_uri().replace('file://','')
    299                 if self.scheduler_client.write_custom_task(name,cmd,parms):
     304                if self.scheduler.write_custom_task(name,cmd,parms):
    300305                        self._show_info(_("Task saved"))
    301306                else:
     
    304309
    305310        def _signin(self,user=None,pwd=None,server=None,data=None):
    306                 self.scheduler_client.set_credentials(user,pwd,server)
     311                self.scheduler.set_credentials(user,pwd,server)
    307312                if server=='localhost':
    308313                        self.btn_local_tasks.set_active(True)
     
    320325                tasks=[]
    321326                sw_tasks=False
    322                 tasks=self.scheduler_client.get_scheduled_tasks(sw_remote)
     327                tasks=self.scheduler.get_scheduled_tasks(sw_remote)
    323328                self.tasks_store.clear()
    324                 if type(tasks)==type([]):       
    325                         for task in tasks:
    326                                 for task_name,task_serial in task.items():
    327                                         self.scheduled_tasks[task_name]=task_serial
    328                                         for serial,task in task_serial.items():
    329                                                 sw_tasks=True
    330                                                 parser=cronParser()
    331                                                 parsed_calendar=''
    332                                                 parsed_calendar=parser.parse_taskData(task)
    333                                                 task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
    334                                                 task['action']=self.scheduler_client.get_task_description(task['cmd'])
    335                                                 task['type']=task['type']
    336                                                 self.i18n['cmd']={_(task['action']):task['action']}
    337                                                 self.i18n['name']={_(task_name):task_name}
    338                                                 self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
    339                                                                         "<span font='Roboto' size='small'><i>"+\
    340                                                                         _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
    341                                                                         parsed_calendar+"</span>",self.remove_icon,'',task['type']))
     329                if type(tasks)==type({}):       
     330                        parser=cronParser()
     331                        for task_name in tasks.keys():
     332                                for serial in tasks[task_name].keys():
     333                                        task=tasks[task_name][serial]
     334                                        task['sw_remote']=''
     335                                        task['type']=''
     336#                                       self.scheduled_tasks[task_name]=tasks[task_name][serial]
     337                                        self.scheduled_tasks[task_name]=tasks[task_name]
     338#                                       for task in tasks[task_name][serial]:
     339                                        sw_tasks=True
     340                                        parsed_calendar=''
     341                                        parsed_calendar=parser.parse_taskData(task)
     342                                        task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
     343                                        task['action']=self.scheduler.get_task_description(task['cmd'])
     344                                        self.i18n['cmd']={_(task['action']):task['action']}
     345                                        self.i18n['name']={_(task_name):task_name}
     346                                        self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
     347                                                                "<span font='Roboto' size='small'><i>"+\
     348                                                                _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
     349                                                                parsed_calendar+"</span>",self.remove_icon,task['sw_remote'],task['type']))
    342350                if sw_tasks:
    343351                        self.task_details_grid.btn_apply.set_sensitive(True)
     
    364372        #def match_tasks
    365373
    366         def task_clicked(self,treeview,event=None):
    367                 self._debug("task clicked %s"%event)
    368                 self.task_details_grid.clear_screen()
     374        def _process_model(self,model,data):
    369375                task={}
    370                 sw_show=True
    371                 if event!=None:
    372                         try:
    373                                 row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
    374                                 print(row)
    375                         except:
    376                                 return
    377                         if not row:
    378                                 return
    379                         col=row[1]
    380                         if col==self.col_remove:
    381                                 sw_show=False
    382                 selection=self.tasks_tv.get_selection()
    383                 model,data=selection.get_selected()
    384                 if not data:
    385                         return
    386376                task['data']=model[data][0].split('\n')
    387377                task['serial']=model[data][1].split('\n')[0]
     
    400390                task['serial']=model[data][1]
    401391                if self.btn_remote_tasks.get_active():
    402                         task_type='remote'
     392                        task['type']='remote'
    403393                        task['sw_remote']=True
    404394                else:
    405                         task_type='local'
     395                        task['type']='local'
    406396                        task['sw_remote']=False
     397                return(task)
     398
     399        def _click_on_delete(self,event):
     400                sw_show=True
     401                try:
     402                        row=self.tasks_tv.get_path_at_pos(int(event.x),int(event.y))
     403                except Exception as e:
     404                        self._debug(e)
     405                if row:
     406                        if row[1]==self.col_remove:
     407                                sw_show=False
     408                return sw_show
     409
     410        def task_clicked(self,treeview,event=None):
     411                self._debug("task clicked %s"%event)
     412                if self.task_details_grid:
     413                        self.task_details_grid.clear_screen()
     414                selection=self.tasks_tv.get_selection()
     415                model,data=selection.get_selected()
     416                if not data:
     417                        return
     418                task={}
     419                sw_show=True
     420                if event!=None:
     421                        sw_show=self._click_on_delete(event)
     422                task=self._process_model(model,data)
    407423                if sw_show:
    408424                        if task['name'] in self.scheduled_tasks.keys():
     
    422438                        except:
    423439                                pass
    424                         self.inf_question.connect('response',self.manage_remove_responses,model,task_name,task_serial,task_cmd,task_type,data)
     440                        self.inf_question.connect('response',self.manage_remove_responses,model,task['name'],task['serial'],task['cmd'],task['type'],data)
    425441        #def task_clicked                       
    426442
     
    432448                action=self.cmb_task_cmds.get_active_text()
    433449                i18n_action=self.i18n['cmd'][action]
    434                 tasks=self.scheduler_client.get_available_tasks()
    435                 task['cmd']=tasks[task_name][i18n_action]
     450                tasks=self.scheduler.get_available_tasks()
     451                task['cmd']=tasks[task['name']][i18n_action]
    436452                task['sw_remote']=False
    437453#               task_type='local'
     
    444460                self._debug("Writing task info...")
    445461                if self.chk_remote.get_active():
    446                         status=self.scheduler_client.write_tasks(task,'remote')
     462                        status=self.scheduler.write_tasks(task,'remote')
    447463                if self.chk_local.get_active():
    448                         status=self.scheduler_client.write_tasks(task,'local')
     464                        status=self.scheduler.write_tasks(task,'local')
    449465                if status:
    450466                        self._show_info(_("Task saved"))
     
    499515#               self.orig_tasks={}
    500516                self.cmb_task_names.remove_all()
    501                 tasks=self.scheduler_client.get_available_tasks()
     517                tasks=self.scheduler.get_available_tasks()
    502518                for name in tasks.keys():
     519                        print("APPEND: %s"%name)
    503520                        if name not in names:
    504521                                names.append(name)
    505                                 self.i18n['name']={_(name):name}
     522                                self.i18n['name'].update({_(name):name})
    506523#                               self.orig_tasks[_(name)]=name
    507524                                print("PROCESS %s"%name)
     
    523540                        for action in tasks[orig_name].keys():
    524541                                if action not in actions:
    525                                         self.i18n['cmd'][_(action)]=action
     542                                        self.i18n['cmd'].update({_(action):action})
    526543                                        actions.append(action)
    527544                                        self.cmb_task_cmds.append_text(_(action))
     
    566583                self._debug("CURSOR %s"%widget)
    567584                if self.btn_remote_tasks.get_active():
    568                         task_type='remote'
    569                 else:
    570                         task_type='local'
     585#                       task_type='remote'
     586                        sw_remote=True
     587                else:
     588#                       task_type='local'
     589                        sw_remote=False
    571590                self._debug("Reload grid")
    572                 self.populate_tasks_tv(task_type)
     591                self.populate_tasks_tv(sw_remote)
    573592                if cursor:
    574593                        self._debug("Restoring cursor")
     
    580599
    581600        def manage_remove_responses(self,widget,response,model,task_name,task_serial,task_cmd,task_type,data):
    582                 self._debug("Removing task %s - %s - %s"%(task_name,task_serial,task_cmd))
     601                self.inf_question.hide()
    583602                if response==Gtk.ResponseType.OK:
    584                         self.inf_question.hide()
     603                        self._debug("Removing task %s - %s - %s"%(task_name,task_serial,task_cmd))
    585604                        if task_name in self.i18n['name'].keys():
    586605                                name=self.i18n['name'][task_name]
     
    591610                        else:
    592611                                cmd=task_cmd
    593                         if self.scheduler_client.remove_task(name,task_serial,cmd,task_type):
     612                        if self.scheduler.remove_task(name,task_serial,cmd,task_type):
    594613                                self.populate_tasks_tv(task_type)
    595614                                self.tasks_tv.set_cursor(0)
  • taskscheduler/trunk/fuentes/server-scheduler.install/usr/share/n4d/python-plugins/SchedulerServer.py

    r6755 r6763  
    55#This class reads the json file with the scheduled tasks and
    66#distributes the info among the clients
    7 
     7# -*- coding: utf-8 -*-
    88import os
    99import json
     
    2222        def _debug(self,msg):
    2323                if (self.dbg):
    24                         print("Scheduler: %s" % msg)
     24                        print("Scheduler: %s" %msg)
    2525        #def _debug
    2626
     
    5050
    5151        def _get_wrkfiles(self,sw_remote=False,available=False):
    52                 if task_type=='available':
     52                if available:
    5353                        wrk_dir=self.available_tasks_dir
    5454                else:
Note: See TracChangeset for help on using the changeset viewer.