Changeset 6755


Ignore:
Timestamp:
Feb 2, 2018, 1:23:44 AM (19 months ago)
Author:
Juanma
Message:

WIP on modes(new approach)

Location:
taskscheduler/trunk/fuentes
Files:
5 edited

Legend:

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

    r6394 r6755  
    4040        def process_tasks(self,data=None):
    4141                self._debug("Scheduling tasks")
    42                 prefixes=['remote','local']
     42                prefixes={'remote':True,'local':False}
    4343                try:
    4444                        socket.gethostbyname('server')
    4545                except:
    46                         prefixes=['local']
    47                 for prefix in prefixes:
     46                                prefixes={'local':False}
     47                for prefix,sw_remote in prefixes.items():
    4848                        if prefix=='remote':
    4949                                n4d=xmlrpc.ServerProxy("https://server:9779")
    5050                        else:
    5151                                n4d=xmlrpc.ServerProxy("https://localhost:9779")
    52                         tasks=n4d.get_tasks("","SchedulerServer",prefix)['data']
     52                        tasks=n4d.get_tasks("","SchedulerServer",sw_remote,False)['data']
    5353                        #Delete files
    5454                        for f in os.listdir(self.cron_dir):
  • taskscheduler/trunk/fuentes/python3-taskscheduler.install/usr/share/taskscheduler/taskscheduler.py

    r6392 r6755  
    4949        #def get_available_tasks
    5050
    51         def get_scheduled_tasks(self,task_type):
    52                 task_list=[]
    53                 self._debug("Retrieving %s task list"%task_type)
    54                 if task_type=='remote' and self.n4dserver:
    55                         result=self.n4dserver.get_tasks("","SchedulerServer",task_type)
    56                 elif task_type=='local':
    57                         result=self.n4dclient.get_tasks("","SchedulerServer",task_type)
     51        def get_scheduled_tasks(self,sw_remote):
     52                tasks={}
     53                self._debug("Retrieving %s task list"%sw_remote)
     54                if self.n4dserver:
     55                        result=self.n4dserver.get_tasks("","SchedulerServer",True)
     56                        if type(result)==type({}):
     57                                tasks=result['data'].copy()
     58                result=self.n4dclient.get_tasks("","SchedulerServer",False)
    5859                if type(result)==type({}):
    59                         task_list=result['data']
    60                 return task_list
     60                        tasks.update(result['data'].copy())
     61                return tasks
    6162        #def get_scheduled_tasks
    6263
    63         def get_task_description(self,task_cmd):
    64                 desc=task_cmd
     64        def get_task_description(self,i18n_desc):
     65                desc=i18n_desc
    6566                sw_found=False
    66                 self._debug("Getting desc for %s"%task_cmd)
     67                self._debug("Getting desc for %s"%i18n_desc)
    6768                tasks=self.get_available_tasks()
    6869                try:
    6970                        for task_desc,task_data in tasks.items():
    7071                                for action,cmd in task_data.items():
    71                                         if cmd==task_cmd:
     72                                        if cmd==i18n_desc:
    7273                                                desc=action
    7374                                                sw_found=True
     
    8182        #def get_task_description
    8283
    83         def get_task_command(self,task_description):
    84                 cmd=task_description
     84        def get_task_command(self,i18n_cmd):
     85                cmd=i18n_cmd
    8586                sw_found=False
    86                 self._debug("Getting cmd for %s"%task_description)
     87                self._debug("Getting cmd for %s"%i18n_cmd)
    8788                tasks=self.get_available_tasks()
    8889                for task_desc,task_data in tasks.items():
    8990                        if task_description in task_data.keys():
    90                                 cmd=task_data[task_description]
     91                                cmd=task_data[i18n_cmd]
    9192                                sw_found=True
    9293                                break
     
    9495        #def get_task_command
    9596
    96         def _get_wrkfiles(self,task_type=None):
    97                 if task_type=='available':
     97        def _get_wrkfiles(self,sw_remote=None):
     98                if sw_remote=='available':
    9899                        wrkdir=self.tasks_dir
    99100                else:
     
    147148        #def _read_tasks_file
    148149
    149         def write_tasks(self,tasks,task_type):
     150        def write_tasks(self,tasks,sw_remote):
    150151                status=False
    151                 self._debug("Sending task info to %s server"%task_type)
    152                 if task_type=='remote':
    153                         result=self.n4dserver.write_tasks(self.credentials,"SchedulerServer",task_type,tasks)
     152                self._debug("Sending task info to %s server"%sw_remote)
     153                if sw_remote=='remote':
     154                        result=self.n4dserver.write_tasks(self.credentials,"SchedulerServer",sw_remote,tasks)
    154155                else:
    155                         result=self.n4dclient.write_tasks(self.credentials,"SchedulerServer",task_type,tasks)
     156                        result=self.n4dclient.write_tasks(self.credentials,"SchedulerServer",sw_remote,tasks)
    156157                if type(result)==type({}):
    157158                        status=result['status']
     
    159160        #def write_tasks
    160161
    161         def remove_task(self,task_name,task_serial,task_cmd,task_type):
     162        def remove_task(self,task_name,task_serial,task_cmd,sw_remote):
    162163                status=False
    163                 self._debug("Removing task from %s server"%task_type)
    164                 if task_type=='remote':
    165                         result=self.n4dserver.remove_task(self.credentials,"SchedulerServer",task_type,task_name,task_serial,task_cmd)
     164                self._debug("Removing task from %s server"%sw_remote)
     165                if sw_remote=='remote':
     166                        result=self.n4dserver.remove_task(self.credentials,"SchedulerServer",sw_remote,task_name,task_serial,task_cmd)
    166167                else:
    167                         result=self.n4dclient.remove_task(self.credentials,"SchedulerServer",task_type,task_name,task_serial,task_cmd)
     168                        result=self.n4dclient.remove_task(self.credentials,"SchedulerServer",sw_remote,task_name,task_serial,task_cmd)
    168169                if type(result)==type({}):
    169170                        status=result['status']
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/DetailBox.py

    r6754 r6755  
    3434                self.scheduler_client=scheduler
    3535                self.parser=cronParser()
    36                 self.task_serial="0"
    37                 self.task_type="remote"
     36                self.task={}
     37                self.task['serial']="0"
     38                self.task['type']="remote"
    3839                self.btn_apply=Gtk.Button(stock=Gtk.STOCK_APPLY)
    3940                try:
     
    4748                        print("taskDetails: %s"%msg)
    4849        #def _debug
     50
     51        def set_task_data(self,task):
     52                self.task['name']=''
     53                self.task['serial']=''
     54                self.task['data']=''
     55                self.task['cmd']=''
     56                self.task['type']=''
     57                self.task['remote']=''
     58                self.task.update(task)
    4959
    5060        def _format_widget_for_grid(self,widget):
     
    341351
    342352
    343         def load_task_details(self,task_name,task_serial,task_data,task_type):
     353        def load_task_details(self,*args):
    344354                self.clear_screen()
    345355                for widget,handler in self.cmb_handler.items():
    346356                        widget.handler_block(handler)
    347                 self.task_name=task_name
    348                 self.task_serial=task_serial
    349                 self.task_cmd=task_data['cmd']
    350                 self.task_type=task_type
     357#               self.task['name']=task_name
     358#               self.task['serial']=task_serial
     359#               self.task['cmd']=task_data['cmd']
     360#               self.task['type']=task_type
    351361                self.lbl_info.set_text('')
    352                 if task_data['m'].isdigit():
     362                if self.task['data']['m'].isdigit():
    353363#                       self.cmb_minutes.set_active(cursor-1)
    354                         self.spin_min.set_value(int(task_data['m']))
     364                        self.spin_min.set_value(int(self.task['data']['m']))
    355365                else:
    356366#                       self.cmb_minutes.set_active(0)
    357367                        self.spin_min.set_value(0)
    358368
    359                 if task_data['h'].isdigit():
    360                         self.spin_hour.set_value(int(task_data['h']))
     369                if self.task['data']['h'].isdigit():
     370                        self.spin_hour.set_value(int(self.task['data']['h']))
    361371                else:
    362372#                       self.cmb_minutes.set_active(0)
    363                         self._parse_date_details(task_data['h'],None,'hour')
     373                        self._parse_date_details(self.task['data']['h'],None,'hour')
    364374
    365375#               self._parse_date_details(task_data['h'],self.cmb_hours,'hour')
    366                 self._parse_date_details(task_data['dom'],self.cmb_days,'dom')
    367                 self._parse_date_details(task_data['mon'],self.cmb_months,'mon')
     376                self._parse_date_details(self.task['data']['dom'],self.cmb_days,'dom')
     377                self._parse_date_details(self.task['data']['mon'],self.cmb_months,'mon')
    368378                widget_dict={'0':self.chk_sunday,'1':self.chk_monday,'2':self.chk_tuesday,\
    369379                                        '3':self.chk_wednesday,'4':self.chk_thursday,'5':self.chk_friday,\
    370380                                        '6':self.chk_saturday,'7':self.chk_sunday}
    371                 self._parse_date_details(task_data['dow'],None,'dow',widget_dict)
    372                 if 'lmd' in task_data.keys():
     381                self._parse_date_details(self.task['data']['dow'],None,'dow',widget_dict)
     382                if 'lmd' in self.task['data'].keys():
    373383                        self.chk_special_dates.set_active(True)
    374384                for widget,handler in self.cmb_handler.items():
     
    574584
    575585        def update_task_details(self,widget=None):
    576                 if self.task_name and self.task_serial:
     586                if self.task['name'] and self.task['serial']:
    577587                        task_data=self.get_task_details()
    578                         return self.scheduler_client.write_tasks(task_data,self.task_type)
     588                        return self.scheduler_client.write_tasks(task_data,self.task['type'])
    579589        #def update_task_details
    580590
    581         def get_task_details(self,widget=None,task_name=None,task_serial=None,task_cmd=None,task_type=None):
    582                 if task_name:
    583                         self.task_name=task_name
    584                 if task_serial:
    585                         self.task_serial=task_serial
    586                 if task_cmd:
    587                         self.task_cmd=task_cmd
    588                 if task_type:
    589                         self.task_type=task_type
     591        def get_task_details(self,*args):
     592#               if task_name:
     593#                       self.task['name']=task_name
     594#               if task_serial:
     595#                       self.task['serial']=task_serial
     596#               if task_cmd:
     597#                       self.task['cmd']=task_cmd
     598#               if task_type:
     599#                       self.task['type']=task_type
    590600                details=self._parse_screen()
    591                 details['cmd']=self.scheduler_client.get_task_command(self.task_cmd)
     601                details['cmd']=self.scheduler_client.get_task_command(self.task['cmd'])
     602                #Search for a "last day month" cmd
    592603                if 'lmd' in details.keys():
    593604                        details['cmd']=self.ldm_helper+' '+details['cmd']
    594605                task={}
    595                 task[self.task_name]={self.task_serial:details}
     606                task[self.task['name']]={self.task['serial']:details}
    596607                self._debug("Saving %s"%task)
    597608                return task
  • taskscheduler/trunk/fuentes/scheduler-gui.install/usr/share/taskscheduler/bin/taskScheduler.py

    r6742 r6755  
    4545                self.last_task_type='remote'
    4646                self.ldm_helper='/usr/sbin/sched-ldm.sh'
    47                 self.orig_tasks={}
    48                 self.orig_cmd={}
     47                self.i18n={}
     48                self.types={'fix':TaskDetails,'repeat':'TaskRepeat','days':TaskDetails}
    4949                       
    5050        #def __init__           
     
    119119                self.btn_remote_tasks=builder.get_object("btn_remote_tasks")
    120120                self.btn_local_tasks=builder.get_object("btn_local_tasks")
    121                 self.handler_remote=self.btn_remote_tasks.connect("clicked",self.view_tasks_clicked,'remote')
    122                 self.handler_local=self.btn_local_tasks.connect("clicked",self.view_tasks_clicked,'local')
     121                self.handler_remote=self.btn_remote_tasks.connect("clicked",self.view_tasks_clicked,True)
     122                self.handler_local=self.btn_local_tasks.connect("clicked",self.view_tasks_clicked,False)
    123123                self.txt_search=builder.get_object("txt_search")
    124124                self.txt_search.connect('changed',self.match_tasks)
     
    165165                self.task_details_grid.btn_apply.connect("clicked",self.update_task)
    166166                self.task_details_grid.chk_node.connect("toggled",self._reload_grid)
    167                 self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,str)
     167                self.tasks_store=Gtk.ListStore(str,str,str,GdkPixbuf.Pixbuf,str,str)
    168168                self.tasks_store_filter=self.tasks_store.filter_new()
    169169                self.tasks_store_filter.set_visible_func(self.filter_tasklist)
     
    207207                column.pack_start(cell,True)
    208208                column.add_attribute(cell,"markup",4)
     209                column.set_expand(True)
     210                column.set_visible(False)
     211                self.tasks_tv.append_column(column)
     212               
     213                column=Gtk.TreeViewColumn(_("Type"))
     214                cell=Gtk.CellRendererText()
     215                column.pack_start(cell,True)
     216                column.add_attribute(cell,"markup",5)
    209217                column.set_expand(True)
    210218                column.set_visible(False)
     
    242250                cmb_cmds=Gtk.ComboBoxText()
    243251                cmds=self.scheduler_client.get_commands()
    244                 orig_cmd={}
     252                i18n_cmd={}
    245253                for cmd in cmds.keys():
    246                         orig_cmd[_(cmd)]=cmd
     254                        i18n_cmd[_(cmd)]=cmd
    247255                        cmb_cmds.append_text(_(cmd))
    248256
     
    267275                btn_file.set_sensitive(False)
    268276                self.btn_apply_manage=builder.get_object("btn_apply_manage")
    269                 self.btn_apply_manage.connect("clicked",self._add_custom_task,txt_taskname,cmb_cmds,txt_params,chk_parm_is_file,btn_file,orig_cmd)
     277                self.btn_apply_manage.connect("clicked",self._add_custom_task,txt_taskname,cmb_cmds,txt_params,chk_parm_is_file,btn_file,i18n_cmd)
    270278                self.btn_back_manage=builder.get_object("btn_back_manage")
    271279                self.btn_back_manage.connect("clicked",self._cancel_manage_clicked)
     
    281289        #def _enable_filechooser
    282290
    283         def _add_custom_task(self,widget,w_name,w_cmd,w_parms,w_chk,w_file,orig_cmd):
     291        def _add_custom_task(self,widget,w_name,w_cmd,w_parms,w_chk,w_file,i18n_cmd):
    284292                name=w_name.get_text()
    285293                cmd=w_cmd.get_active_text()
    286                 cmd_desc=orig_cmd[cmd]
     294                cmd_desc=i18n_cmd[cmd]
    287295                parms=w_parms.get_text()
    288296                cmd=self.scheduler_client.get_command_cmd(cmd_desc)
     
    306314        #def _signin
    307315
    308         def populate_tasks_tv(self,task_type):
     316        def populate_tasks_tv(self,sw_remote=False):
    309317                self._debug("Populating task list")
    310318                self.task_details_grid.btn_apply.set_sensitive(False)
     
    312320                tasks=[]
    313321                sw_tasks=False
    314                 tasks=self.scheduler_client.get_scheduled_tasks(task_type)
     322                tasks=self.scheduler_client.get_scheduled_tasks(sw_remote)
    315323                self.tasks_store.clear()
    316324                if type(tasks)==type([]):       
     
    325333                                                task['cmd']=task['cmd'].replace(self.ldm_helper+' ','')
    326334                                                task['action']=self.scheduler_client.get_task_description(task['cmd'])
    327                                                 self.orig_cmd[_(task['action'])]=task['action']
    328                                                 self.orig_tasks[_(task_name)]=task_name
     335                                                task['type']=task['type']
     336                                                self.i18n['cmd']={_(task['action']):task['action']}
     337                                                self.i18n['name']={_(task_name):task_name}
    329338                                                self.tasks_store.append(("<span font='Roboto'><b>"+_(task['action'])+"</b></span>\n"+\
    330339                                                                        "<span font='Roboto' size='small'><i>"+\
    331340                                                                        _(task_name)+"</i></span>",serial,"<span font='Roboto' size='small'>"+\
    332                                                                         parsed_calendar+"</span>",self.remove_icon,'oooo'))
     341                                                                        parsed_calendar+"</span>",self.remove_icon,'',task['type']))
    333342                if sw_tasks:
    334343                        self.task_details_grid.btn_apply.set_sensitive(True)
     
    358367                self._debug("task clicked %s"%event)
    359368                self.task_details_grid.clear_screen()
     369                task={}
    360370                sw_show=True
    361371                if event!=None:
     
    374384                if not data:
    375385                        return
    376                 task_data=model[data][0].split('\n')
    377                 task_serial=model[data][1].split('\n')[0]
    378                 cmd=task_data[0][task_data[0].find("<b>")+3:task_data[0].find("</b>")]
    379                 if cmd in self.orig_cmd.keys():
    380                         task_cmd=self.orig_cmd[cmd]
    381 
    382                 name=task_data[1][task_data[1].find("<i>")+3:task_data[1].find("</i>")]
    383                 if name in self.orig_tasks.keys():
    384                         task_name=self.orig_tasks[name]
    385 
    386                 task_serial=model[data][1]
     386                task['data']=model[data][0].split('\n')
     387                task['serial']=model[data][1].split('\n')[0]
     388                cmd=task['data'][0][task['data'][0].find("<b>")+3:task['data'][0].find("</b>")]
     389                if cmd in self.i18n['cmd'].keys():
     390                        task['cmd']=self.i18n['cmd'][cmd]
     391                else:
     392                        task['cmd']=cmd
     393
     394                name=task['data'][1][task['data'][1].find("<i>")+3:task['data'][1].find("</i>")]
     395                if name in self.i18n['name'].keys():
     396                        task['name']=self.i18n['name'][name]
     397                else:
     398                        task['name']=name
     399
     400                task['serial']=model[data][1]
    387401                if self.btn_remote_tasks.get_active():
    388402                        task_type='remote'
     403                        task['sw_remote']=True
    389404                else:
    390405                        task_type='local'
     406                        task['sw_remote']=False
    391407                if sw_show:
    392                         if task_name in self.scheduled_tasks.keys():
    393                                 if task_serial in self.scheduled_tasks[task_name].keys():
    394                                         task_data=self.scheduled_tasks[task_name][task_serial]
    395                                         self._debug("Loading details of %s task %s of group %s"% (task_type,task_serial,task_name))
    396                                         self.task_details_grid.load_task_details(task_name,task_serial,task_data,task_type)
     408                        if task['name'] in self.scheduled_tasks.keys():
     409                                if task['serial'] in self.scheduled_tasks[task['name']].keys():
     410                                        task['data']=self.scheduled_tasks[task['name']][task['serial']]
     411                                        self._debug("Loading details of task %s of group %s remote %s"% (task['serial'],task['name'],task['sw_remote']))
     412                                        self.task_details_grid.set_task_data(task)
     413                                        self.task_details_grid.load_task_details()
    397414                else:
    398415                        self.lbl_question.set_text(_("Are you sure to delete this task?"))
     
    409426
    410427        def save_task_details(self,widget):
     428                task={}
    411429                name=self.cmb_task_names.get_active_text()
    412                 task_name=self.orig_tasks[name]
     430#               task_name=self.orig_tasks[name]
     431                task['name']=self.i18n['name'][name]
    413432                action=self.cmb_task_cmds.get_active_text()
    414                 task_action=self.orig_cmd[action]
     433                i18n_action=self.i18n['cmd'][action]
    415434                tasks=self.scheduler_client.get_available_tasks()
    416                 task_cmd=tasks[task_name][task_action]
    417                 task_type='local'
     435                task['cmd']=tasks[task_name][i18n_action]
     436                task['sw_remote']=False
     437#               task_type='local'
    418438                if self.btn_remote_tasks.get_active():
    419                         task_type='remote'
    420                 task=self.add_task_grid.get_task_details(self.inf_message,task_name,None,task_cmd,task_type)
    421 
    422                 taskFilter='local'
     439                        task['sw_remote']=True
     440#                       task_type='remote'
     441                self.add_task_grid.set_task_data(task)
     442                task=self.add_task_grid.get_task_details()
     443
    423444                self._debug("Writing task info...")
    424445                if self.chk_remote.get_active():
     
    433454        #def save_task_details
    434455
    435         def view_tasks_clicked(self,widget,task_type):
     456        def view_tasks_clicked(self,widget,sw_remote):
    436457                if widget:
    437458                        if not widget.get_active():
    438                                 if task_type=='remote':
     459                                if sw_remote:
    439460                                        self._block_widget_state(True,widget,self.handler_remote)
    440461                                else:                                   
    441462                                        self._block_widget_state(True,widget,self.handler_local)
    442463                                return True
    443                 self._debug("loading %s tasks" % task_type)
    444                 if task_type=='remote':
     464                self._debug("loading tasks (remote: %s)" % sw_remote)
     465                if sw_remote:
    445466                        self.btn_local_tasks.set_active(False)
    446467                        self.btn_local_tasks.props.active=False
     
    451472                        self.last_task_type='local'
    452473                self._debug("Task clicked")
    453                 self.populate_tasks_tv(task_type)
     474                self.populate_tasks_tv(sw_remote)
    454475                self.tasks_tv.set_model(self.tasks_store_filter)
    455476                self.tasks_tv.set_cursor(0)
     
    476497                tasks=[]
    477498                names=[]
    478                 self.orig_tasks={}
     499#               self.orig_tasks={}
    479500                self.cmb_task_names.remove_all()
    480501                tasks=self.scheduler_client.get_available_tasks()
     
    482503                        if name not in names:
    483504                                names.append(name)
    484                                 self.orig_tasks[_(name)]=name
     505                                self.i18n['name']={_(name):name}
     506#                               self.orig_tasks[_(name)]=name
    485507                                print("PROCESS %s"%name)
    486508                                self.cmb_task_names.append_text(_(name))
     
    492514        def load_add_task_details_cmds(self,widget,tasks):
    493515                actions=[]
    494                 self.orig_cmd={}
     516                self.i18n['cmd']={}
    495517                self.cmb_task_cmds.remove_all()
    496518                task_name=self.cmb_task_names.get_active_text()
    497519                if task_name:
    498                         orig_name=self.orig_tasks[task_name]
     520#                       orig_name=self.orig_tasks[task_name]
     521                        orig_name=self.i18n['name'][task_name]
    499522                        print(tasks)
    500523                        for action in tasks[orig_name].keys():
    501524                                if action not in actions:
    502                                         self.orig_cmd[_(action)]=action
     525                                        self.i18n['cmd'][_(action)]=action
    503526                                        actions.append(action)
    504527                                        self.cmb_task_cmds.append_text(_(action))
     
    560583                if response==Gtk.ResponseType.OK:
    561584                        self.inf_question.hide()
    562                         if task_name in self.orig_tasks.keys():
    563                                 name=self.orig_tasks[task_name]
     585                        if task_name in self.i18n['name'].keys():
     586                                name=self.i18n['name'][task_name]
    564587                        else:
    565588                                name=task_name
    566                         if task_cmd in self.orig_cmd.keys():
    567                                 cmd=self.orig_cmd[task_cmd]
     589                        if task_cmd in self.i18n['cmd'].keys():
     590                                cmd=self.i18n['cmd'][task_cmd]
    568591                        else:
    569592                                cmd=task_cmd
  • taskscheduler/trunk/fuentes/server-scheduler.install/usr/share/n4d/python-plugins/SchedulerServer.py

    r6383 r6755  
    1111class SchedulerServer():
    1212        def __init__(self):
    13                 self.dbg=0
     13                self.dbg=1
    1414                self.taskDir="/etc/scheduler/tasks.d"
    1515                self.schedTasksDir=self.taskDir+"/scheduled"
     
    2525        #def _debug
    2626
    27         def get_tasks(self,task_type):
    28                 result={}
    29                 tasks=[]
    30                 wrkfiles=self._get_wrkfiles(task_type)
     27        def get_tasks(self,sw_remote=False,available=False):
     28                tasks={}
     29                wrkfiles=self._get_wrkfiles(sw_remote,available)
     30                self._debug(wrkfiles)
    3131                for wrkfile in wrkfiles:
    32                         content=self._read_tasks_file(wrkfile)
    33                         tasks.append(content)
     32                        task=self._read_tasks_file(wrkfile)
     33                        if task:
     34                                tasks.update(task)
    3435                self._debug("Tasks loaded")
    3536                self._debug(str(tasks))
     
    3940        def get_available_tasks(self):
    4041                tasks={}
    41                 wrkfiles=self._get_wrkfiles('available')
     42                wrkfiles=self._get_wrkfiles(available=True)
    4243                self._debug(wrkfiles)
    4344                for wrkfile in wrkfiles:
     
    4849                return({'status':True,'data':tasks})
    4950
    50         def _get_wrkfiles(self,task_type):
    51                 if task_type=='local':
    52                         wrk_dir=self.local_tasks_dir
    53                 elif task_type=='remote':
    54                         wrk_dir=self.remote_tasks_dir
    55                 elif task_type=='available':
     51        def _get_wrkfiles(self,sw_remote=False,available=False):
     52                if task_type=='available':
    5653                        wrk_dir=self.available_tasks_dir
     54                else:
     55                        if sw_remote:
     56                                wrk_dir=self.remote_tasks_dir
     57                        elif sw_remote==False:
     58                                wrk_dir=self.local_tasks_dir
    5759                if not os.path.isdir(wrk_dir):
    5860                        os.makedirs(wrk_dir)
    59 
    6061                wrkfiles=[]
    6162                for f in os.listdir(wrk_dir):
Note: See TracChangeset for help on using the changeset viewer.