Mercurial > libervia-web

comparison libervia/server/tasks/manager.py @ 1509:106bae41f5c8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
massive refactoring from camelCase -> snake_case. See backend commit log for more details
author Goffi <goffi@goffi.org>
date Sat, 08 Apr 2023 13:44:11 +0200
parents 822bd0139769
children
comparison
equal deleted inserted replaced
1508:ec3ad9abf9f9 1509:106bae41f5c8
54 54
55 @property 55 @property
56 def build_path(self): 56 def build_path(self):
57 """path where generated files will be build for this site""" 57 """path where generated files will be build for this site"""
58 if self._build_path is None: 58 if self._build_path is None:
59 self._build_path = self.host.getBuildPath(self.site_name) 59 self._build_path = self.host.get_build_path(self.site_name)
60 return self._build_path 60 return self._build_path
61 61
62 @property 62 @property
63 def site_name(self): 63 def site_name(self):
64 return self.resource.site_name 64 return self.resource.site_name
65 65
66 def validateData(self, task): 66 def validate_data(self, task):
67 """Check workflow attributes in task""" 67 """Check workflow attributes in task"""
68 68
69 for var, allowed in (("ON_ERROR", ("continue", "stop")), 69 for var, allowed in (("ON_ERROR", ("continue", "stop")),
70 ("LOG_OUTPUT", bool), 70 ("LOG_OUTPUT", bool),
71 ("WATCH_DIRS", list)): 71 ("WATCH_DIRS", list)):
81 else: 81 else:
82 if not value in allowed: 82 if not value in allowed:
83 raise ValueError(_("Unexpected value for {var}: {value!r}").format( 83 raise ValueError(_("Unexpected value for {var}: {value!r}").format(
84 var=var, value=value)) 84 var=var, value=value))
85 85
86 async def importTask( 86 async def import_task(
87 self, 87 self,
88 task_name: str, 88 task_name: str,
89 task_path: Path, 89 task_path: Path,
90 to_import: Dict[str, Path] 90 to_import: Dict[str, Path]
91 ) -> None: 91 ) -> None:
106 pre_task_path = to_import[pre_task_name] 106 pre_task_path = to_import[pre_task_name]
107 except KeyError: 107 except KeyError:
108 raise ValueError( 108 raise ValueError(
109 f"task {task_name!r} must be run after {pre_task_name!r}, " 109 f"task {task_name!r} must be run after {pre_task_name!r}, "
110 f"however there is no task with such name") 110 f"however there is no task with such name")
111 await self.importTask(pre_task_name, pre_task_path, to_import) 111 await self.import_task(pre_task_name, pre_task_path, to_import)
112 112
113 # we launch prepare, which is a method used to prepare 113 # we launch prepare, which is a method used to prepare
114 # data at runtime (e.g. set WATCH_DIRS using config) 114 # data at runtime (e.g. set WATCH_DIRS using config)
115 try: 115 try:
116 prepare = task.prepare 116 prepare = task.prepare
118 pass 118 pass
119 else: 119 else:
120 log.info(_('== preparing task "{task_name}" for {site_name} =='.format( 120 log.info(_('== preparing task "{task_name}" for {site_name} =='.format(
121 task_name=task_name, site_name=self.site_name or DEFAULT_SITE_LABEL))) 121 task_name=task_name, site_name=self.site_name or DEFAULT_SITE_LABEL)))
122 try: 122 try:
123 await utils.asDeferred(prepare) 123 await utils.as_deferred(prepare)
124 except exceptions.CancelError as e: 124 except exceptions.CancelError as e:
125 log.debug(f"Skipping {task_name} which cancelled itself: {e}") 125 log.debug(f"Skipping {task_name} which cancelled itself: {e}")
126 return 126 return
127 127
128 self.tasks[task_name] = task 128 self.tasks[task_name] = task
129 self.validateData(task) 129 self.validate_data(task)
130 if self.host.options['dev-mode']: 130 if self.host.options['dev-mode']:
131 dirs = task.WATCH_DIRS or [] 131 dirs = task.WATCH_DIRS or []
132 for dir_ in dirs: 132 for dir_ in dirs:
133 self.host.files_watcher.watchDir( 133 self.host.files_watcher.watch_dir(
134 dir_, auto_add=True, recursive=True, 134 dir_, auto_add=True, recursive=True,
135 callback=self._autorunTask, task_name=task_name) 135 callback=self._autorun_task, task_name=task_name)
136 136
137 async def parseTasksDir(self, dir_path: Path) -> None: 137 async def parse_tasks_dir(self, dir_path: Path) -> None:
138 log.debug(f"parsing tasks in {dir_path}") 138 log.debug(f"parsing tasks in {dir_path}")
139 tasks_paths = sorted(dir_path.glob('task_*.py')) 139 tasks_paths = sorted(dir_path.glob('task_*.py'))
140 to_import = {} 140 to_import = {}
141 for task_path in tasks_paths: 141 for task_path in tasks_paths:
142 if not task_path.is_file(): 142 if not task_path.is_file():
150 name=task_name)) 150 name=task_name))
151 log.debug(f"task {task_name} found") 151 log.debug(f"task {task_name} found")
152 to_import[task_name] = task_path 152 to_import[task_name] = task_path
153 153
154 for task_name, task_path in to_import.items(): 154 for task_name, task_path in to_import.items():
155 await self.importTask(task_name, task_path, to_import) 155 await self.import_task(task_name, task_path, to_import)
156 156
157 async def parseTasks(self): 157 async def parse_tasks(self):
158 # implicit tasks are always run 158 # implicit tasks are always run
159 implicit_path = Path(implicit.__file__).parent 159 implicit_path = Path(implicit.__file__).parent
160 await self.parseTasksDir(implicit_path) 160 await self.parse_tasks_dir(implicit_path)
161 # now we check if there are tasks specific to this site 161 # now we check if there are tasks specific to this site
162 if not self.tasks_dir.is_dir(): 162 if not self.tasks_dir.is_dir():
163 log.debug(_("{name} has no task to launch.").format( 163 log.debug(_("{name} has no task to launch.").format(
164 name = self.resource.site_name or DEFAULT_SITE_LABEL)) 164 name = self.resource.site_name or DEFAULT_SITE_LABEL))
165 return 165 return
166 else: 166 else:
167 await self.parseTasksDir(self.tasks_dir) 167 await self.parse_tasks_dir(self.tasks_dir)
168 168
169 def _autorunTask(self, host, filepath, flags, task_name): 169 def _autorun_task(self, host, filepath, flags, task_name):
170 """Called when an event is received from a watched directory""" 170 """Called when an event is received from a watched directory"""
171 if flags == ['create']: 171 if flags == ['create']:
172 return 172 return
173 try: 173 try:
174 task = self.tasks[task_name] 174 task = self.tasks[task_name]
175 on_dir_event_cb = task.onDirEvent 175 on_dir_event_cb = task.on_dir_event
176 except AttributeError: 176 except AttributeError:
177 return defer.ensureDeferred(self.runTask(task_name)) 177 return defer.ensureDeferred(self.run_task(task_name))
178 else: 178 else:
179 return utils.asDeferred( 179 return utils.as_deferred(
180 on_dir_event_cb, host, Path(filepath.path.decode()), flags) 180 on_dir_event_cb, host, Path(filepath.path.decode()), flags)
181 181
182 async def runTaskInstance(self, task: Task) -> None: 182 async def run_task_instance(self, task: Task) -> None:
183 self._current_task = task.name 183 self._current_task = task.name
184 log.info(_('== running task "{task_name}" for {site_name} =='.format( 184 log.info(_('== running task "{task_name}" for {site_name} =='.format(
185 task_name=task.name, site_name=self.site_name or DEFAULT_SITE_LABEL))) 185 task_name=task.name, site_name=self.site_name or DEFAULT_SITE_LABEL)))
186 os.chdir(self.site_path) 186 os.chdir(self.site_path)
187 try: 187 try:
188 await utils.asDeferred(task.start) 188 await utils.as_deferred(task.start)
189 except Exception as e: 189 except Exception as e:
190 on_error = task.ON_ERROR 190 on_error = task.ON_ERROR
191 if on_error == 'stop': 191 if on_error == 'stop':
192 raise e 192 raise e
193 elif on_error == 'continue': 193 elif on_error == 'continue':
195 .format(task_name=task.name, site_name=self.site_name, reason=e)) 195 .format(task_name=task.name, site_name=self.site_name, reason=e))
196 else: 196 else:
197 raise exceptions.InternalError("we should never reach this point") 197 raise exceptions.InternalError("we should never reach this point")
198 self._current_task = None 198 self._current_task = None
199 199
200 async def runTask(self, task_name: str) -> None: 200 async def run_task(self, task_name: str) -> None:
201 """Run a single task 201 """Run a single task
202 202
203 @param task_name(unicode): name of the task to run 203 @param task_name(unicode): name of the task to run
204 """ 204 """
205 task = self.tasks[task_name] 205 task = self.tasks[task_name]
206 await self.runTaskInstance(task) 206 await self.run_task_instance(task)
207 207
208 async def runTasks(self): 208 async def run_tasks(self):
209 """Run all the tasks found""" 209 """Run all the tasks found"""
210 old_path = os.getcwd() 210 old_path = os.getcwd()
211 for task_name, task_value in self.tasks.items(): 211 for task_name, task_value in self.tasks.items():
212 await self.runTask(task_name) 212 await self.run_task(task_name)
213 os.chdir(old_path) 213 os.chdir(old_path)