source: taskscheduler/trunk/fuentes/python3-taskscheduler.install/usr/share/taskscheduler/taskscheduler.py @ 6824

Last change on this file since 6824 was 6824, checked in by Juanma, 19 months ago

refactorized

File size: 4.9 KB
Line 
1#!/usr/bin/env python3
2###
3#
4###
5
6import os
7import json
8import sys
9try:
10        import xmlrpc.client as n4d
11except ImportError:
12        raise ImportError("xmlrpc not available. Disabling server queries")
13import ssl
14
15class TaskScheduler():
16        def __init__(self):
17                self.dbg=0
18                self.credentials=["",""]
19                self.n4dserver=None
20                self.n4dclient=self._n4d_connect('localhost')
21                self.conf_dir="/etc/scheduler/conf.d/"
22                self.tasks_dir=self.conf_dir+'/tasks'
23                self.custom_tasks=self.tasks_dir+"/personal.json"
24                self.commands_file=self.conf_dir+'/commands/commands.json'
25                self.sched_dir="/etc/scheduler/tasks.d"
26                self.local_tasks_dir=self.sched_dir+"/local"
27        #def __init__
28
29        def _debug(self,msg):
30                if (self.dbg):
31                        print("Scheduler lib: %s" % msg)
32        #def _debug
33       
34        def set_credentials(self,user,pwd,server):
35                self.credentials=[user,pwd]
36                self.n4dserver=self._n4d_connect(server)
37        #def set_credentials
38
39        def get_available_tasks(self):
40                tasks={}
41                if self.n4dserver:
42                        result=self.n4dserver.get_available_tasks("","SchedulerServer")
43                        if type(result)==type({}):
44                                tasks=result['data'].copy()
45                result=self.n4dclient.get_available_tasks("","SchedulerServer")
46                if type(result)==type({}):
47                        tasks.update(result['data'].copy())
48                return tasks
49        #def get_available_tasks
50
51        def get_scheduled_tasks(self,sw_remote):
52                tasks={}
53                self._debug("Retrieving task list remote=%s"%sw_remote)
54                if self.n4dserver:
55                        result=self.n4dserver.get_remote_tasks("","SchedulerServer")
56                        if type(result)==type({}):
57                                tasks=result.copy()
58                result=self.n4dclient.get_tasks("","SchedulerServer")['data']
59                if type(result)==type({}):
60                        if tasks:
61                                #Merge values
62                                for key,data in result.items():
63                                        if key in tasks.keys():
64                                                tasks[key].update(data)
65                                        else:
66                                                tasks[key]=data
67
68                        else:
69                                tasks.update(result.copy())
70                print(tasks)
71                return tasks
72        #def get_scheduled_tasks
73
74        def get_task_description(self,i18n_desc):
75                desc=i18n_desc
76                sw_found=False
77                self._debug("Getting desc for %s"%i18n_desc)
78                tasks=self.get_available_tasks()
79                try:
80                        for task_desc,task_data in tasks.items():
81                                for action,cmd in task_data.items():
82                                        if cmd==i18n_desc:
83                                                desc=action
84                                                sw_found=True
85                                                break
86                                if sw_found:
87                                        break
88                except Exception as e:
89                        print(e)
90                        self._debug(("Error ocurred when looking for %s")%task_cmd)
91                return desc
92        #def get_task_description
93
94        def get_task_command(self,i18n_cmd):
95                cmd=i18n_cmd
96                self._debug("Getting cmd for %s"%i18n_cmd)
97                tasks=self.get_available_tasks()
98                for task_desc,task_data in tasks.items():
99                        if task_desc in task_data.keys():
100                                cmd=task_data[i18n_cmd]
101                                break
102                return cmd
103        #def get_task_command
104
105        def _get_wrkfiles(self,sw_remote=None):
106                if sw_remote=='available':
107                        wrkdir=self.tasks_dir
108                else:
109                        wrkdir=self.local_tasks_dir
110                wrkfiles=[]
111                self._debug("Opening %s"%wrkdir)
112                if os.path.isdir(wrkdir):
113                        for f in os.listdir(wrkdir):
114                                wrkfiles.append(wrkdir+'/'+f)
115                return wrkfiles
116        #def _get_wrkfiles
117
118        def get_commands(self):
119                cmds={}
120                if os.path.isfile(self.commands_file):
121                        try:
122                                cmds=json.loads(open(self.commands_file).read())
123                        except Exception as e:
124                                print(e)
125                                self._debug(("unable to open %s") % self.commands_file)
126                return(cmds)
127        #def get_commands
128
129        def get_command_cmd(self,cmd_desc):
130                commands=self.get_commands()
131                cmd=cmd_desc
132                if cmd_desc in commands.keys():
133                        cmd=commands[cmd_desc]
134                return cmd
135        #def get_command_cmd
136
137        def write_custom_task(self,cmd_name,cmd,parms):
138                status=False
139                n4d_server=self.n4dserver
140                result=n4d_server.write_custom_task(self.credentials,"SchedulerServer",cmd_name,cmd,parms)
141                if type(result)==type({}):
142                        status=result['status']
143                return status
144        #def write_custom_task
145
146        def _read_tasks_file(self,wrkfile):
147                self._debug("Opening %s" % wrkfile)
148                tasks=None
149                if os.path.isfile(wrkfile) and wrkfile!=self.commands_file:
150                        try:
151                                tasks=json.loads(open(wrkfile).read())
152                        except Exception as e:
153                                print(e)
154                                self._debug(("unable to open %s") % wrkfile)
155                return(tasks)
156        #def _read_tasks_file
157
158        def write_tasks(self,tasks,sw_remote):
159                status=False
160                self._debug("Sending task info to %s server"%sw_remote)
161                if sw_remote=='remote':
162                        result=self.n4dserver.write_tasks(self.credentials,"SchedulerServer",sw_remote,tasks)
163                else:
164                        result=self.n4dclient.write_tasks(self.credentials,"SchedulerServer",sw_remote,tasks)
165                if type(result)==type({}):
166                        status=result['status']
167                return status
168        #def write_tasks
169
170        def remove_task(self,task):
171                status=False
172                sw_remote=False
173                self._debug("Removing task %s"%task)
174                if task['spread']:
175                        result=self.n4dserver.remove_task(self.credentials,"SchedulerServer",task)
176                else:
177                        result=self.n4dclient.remove_task(self.credentials,"SchedulerServer",task)
178                if type(result)==type({}):
179                        status=result['status']
180                self._debug("Status %s"%status)
181                return status
182        #def remove_task
183
184        def _n4d_connect(self,server):
185                #Setup SSL
186                context=ssl._create_unverified_context()
187                n4dclient = n4d.ServerProxy("https://"+server+":9779",context=context,allow_none=True)
188                return(n4dclient)
189        #def _n4d_connect
Note: See TracBrowser for help on using the repository browser.