diff --git a/integration/dxdesigner795/QuickPartReplace.vbs b/integration/dxdesigner795/QuickPartReplace.vbs index 6366cb8..cf0f0ff 100644 --- a/integration/dxdesigner795/QuickPartReplace.vbs +++ b/integration/dxdesigner795/QuickPartReplace.vbs @@ -32,6 +32,9 @@ Dim QP_BatchSaveCommitted Dim QP_DiscoveryMode, QP_TargetSchematic, QP_TargetSheet Dim QP_FailureNumber, QP_FailureSource, QP_FailureDescription Dim QP_NcSyncSummary +Dim QP_SessionMode, QP_SessionToken, QP_SessionProject, QP_MonitorJobId +Dim QP_OwnedProjectPath, QP_SessionWaiting, QP_SessionExternalChange +Dim QP_CheckpointSchematic, QP_CheckpointSheet Dim FailureState, CloseError Set QP_Fso = CreateObject("Scripting.FileSystemObject") QP_RootTemplate = "%LOCALAPPDATA%\DxProductivity\trial-task-center\quick-run" @@ -67,6 +70,11 @@ QP_ComponentIndexContext = "" QP_CurrentJobId = "" QP_ExitCode = 0 QP_Stage = "session_startup" +QP_SessionMode = False +QP_OwnedProjectPath = "" +QP_SessionWaiting = False +QP_SessionExternalChange = False +QP_MonitorJobId = QP_ExpectedJobId Set QP_App = Nothing On Error Resume Next @@ -86,8 +94,14 @@ Else If QP_DiscoveryMode Then QPDiscoverSheets Else - QPMain - If Err.Number = 0 And QP_BatchMode Then QPFinishBatchItem + Do + QPMain + If Err.Number <> 0 Then Exit Do + If QP_BatchMode Then QPFinishBatchItem + If Err.Number <> 0 Or Not QP_SessionMode Then Exit Do + QPSessionNext + If Err.Number <> 0 Or Not QP_SessionMode Then Exit Do + Loop End If If Err.Number <> 0 Then QP_FailureNumber = Err.Number @@ -96,7 +110,7 @@ Else If QP_DiscoveryMode Then QPCleanupDiscoveryFailure FailureState = "hard_failure" CloseError = "" - If QP_BatchMode Then + If QP_BatchMode Or QP_SessionMode Then QPDiscardFailedBatchProject CloseError If Len(CloseError) = 0 Then If QP_BatchSaveCommitted Then @@ -173,6 +187,7 @@ Sub QPBootstrapSession() Err.Raise vbObjectError + 872, "QuickPartReplace.Discovery", "sheet discovery authorization does not match this job" QP_DiscoveryMode = True End If + QPReadSessionRequest QPProgress "session_startup", 0, 0 TargetPath = QPConfirmedProjectPath() If QP_Fso.FileExists(QP_Fso.BuildPath(QP_Root, "recovery.request")) Then @@ -184,6 +199,7 @@ Sub QPBootstrapSession() Set QP_App = GetObject(, "Viewdraw.Application") Else Set QP_App = QPAttachOrStart(QPDesignerProcessCount()) + If QP_SessionMode Then WScript.ConnectObject QP_App, "QPEvent_" QPEnsureProject QP_App, TargetPath End If QP_Stage = "session_ready" @@ -193,7 +209,9 @@ End Sub Sub QPCleanupDiscoveryFailure() On Error Resume Next - If QP_OwnedProject And Not QP_App Is Nothing Then QP_App.CloseProject + If QP_OwnedProject And Not QP_App Is Nothing Then + If QPCanonicalPath(QPProjectPath()) = QPCanonicalPath(QP_OwnedProjectPath) Then QP_App.CloseProject + End If QP_OwnedProject = False Err.Clear On Error GoTo 0 @@ -220,15 +238,21 @@ Sub QPWaitForMonitor() End Sub Sub QPProgress(ByVal Stage, ByVal Done, ByVal Total) - Dim Safe, StopPath + Dim Safe, StopPath, Job, Suffix If Len(CStr(QP_AttemptToken)) = 0 Then Exit Sub Safe = 0 If Not CBool(QP_NativeMutationPossible) And Not CBool(QP_RestoreTransactionOpen) And _ Not CBool(QP_NativeCallActive) Then Safe = 1 QP_ProgressSequence = CLng(QP_ProgressSequence) + 1 + Job = QP_ExpectedJobId + Suffix = "" + If QP_SessionMode Then + Job = QP_MonitorJobId + Suffix = vbTab & QP_ExpectedJobId + End If WScript.StdOut.WriteLine "DX_PROGRESS" & vbTab & QP_AttemptToken & vbTab & _ - QP_ExpectedJobId & vbTab & CStr(QP_ProgressSequence) & vbTab & Stage & _ - vbTab & CStr(Done) & vbTab & CStr(Total) & vbTab & CStr(Safe) + Job & vbTab & CStr(QP_ProgressSequence) & vbTab & Stage & _ + vbTab & CStr(Done) & vbTab & CStr(Total) & vbTab & CStr(Safe) & Suffix If Safe = 1 And Stage <> "finished" Then StopPath = QP_Fso.BuildPath(QP_Root, "monitor-" & QP_AttemptToken & ".stop") If QP_Fso.FileExists(StopPath) Then @@ -239,6 +263,111 @@ Sub QPProgress(ByVal Stage, ByVal Done, ByVal Total) End If End Sub +Sub QPReadSessionRequest() + Dim Path, Fields, Index, Character + Path = QP_Fso.BuildPath(QP_Root, "project-session.request") + If Not QP_Fso.FileExists(Path) Then Exit Sub + If Not QP_BatchMode Or QP_DiscoveryMode Or _ + QP_Fso.FileExists(QP_Fso.BuildPath(QP_Root, "recovery.request")) Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid project session mode" + Fields = Split(Trim(QPReadUtf8(Path)), vbTab) + If UBound(Fields) <> 2 Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid session request" + QP_SessionToken = CStr(Fields(0)) + If Len(QP_SessionToken) <> 32 Or Fields(2) <> QP_ExpectedJobId Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "session authorization mismatch" + For Index = 1 To 32 + Character = Mid(QP_SessionToken, Index, 1) + If InStr(1, "0123456789abcdef", Character, vbBinaryCompare) = 0 Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid session token" + Next + QP_SessionProject = CStr(Fields(1)) + If QPCanonicalPath(QPConfirmedProjectPath()) <> QPCanonicalPath(QP_SessionProject) Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "session project mismatch" + QP_SessionMode = True +End Sub + +Sub QPSessionNext() + Dim Path, Fields, Attempt, TargetPath, Documents, Document, View + Path = QP_Fso.BuildPath(QP_Root, "project-session-next.tsv") + QPProgress "session_wait", 1, 1 + For Attempt = 1 To 1500 + If QP_Fso.FileExists(Path) Then + Fields = Split(Trim(QPReadUtf8(Path)), vbTab) + If UBound(Fields) <> 1 Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid continuation" + If Fields(0) <> QP_SessionToken Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "continuation token mismatch" + QP_Fso.DeleteFile Path, True + QPRequireSessionCheckpoint + QP_SessionWaiting = False + If Fields(1) = "close" Then + QPCloseBatchProject QP_SessionProject, False + QP_SessionMode = False + Exit Sub + End If + QP_ExpectedJobId = CStr(Fields(1)) + QP_CurrentJobId = QP_ExpectedJobId + QP_BatchMode = True + QP_BatchState = "" + QP_BatchSaveCommitted = False + QP_NativeMutationPossible = False + If Trim(QPReadUtf8(QP_Fso.BuildPath(QP_Root, "batch.request"))) <> QP_ExpectedJobId Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "next batch authorization mismatch" + TargetPath = QPConfirmedProjectPath() + If QPCanonicalPath(TargetPath) <> QPCanonicalPath(QP_SessionProject) Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "cannot switch project inside a session" + Set View = QP_App.ActiveView + If Not View Is Nothing Then + If CStr(View.GetName(0)) <> QP_TargetSchematic Or CStr(View.Block.SheetNum) <> QP_TargetSheet Then + Set Documents = QP_App.SchematicSheetDocuments() + If Documents.Count <> 1 Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "owned sheet set changed" + Set Document = Documents.Item(1) + Document.Close False, "" + End If + End If + QPEnsureProject QP_App, TargetPath + Exit Sub + End If + WScript.Sleep 100 + Next + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "supervisor did not release project checkpoint" +End Sub + +Sub QPEvent_DocumentModified() + If QP_SessionWaiting Then QP_SessionExternalChange = True +End Sub + +Sub QPEvent_BlockModified(ByVal Block) + If QP_SessionWaiting Then QP_SessionExternalChange = True +End Sub + +Sub QPEvent_ProjectModified(ByVal NewProject) + If QP_SessionWaiting Then QP_SessionExternalChange = True +End Sub + +Sub QPEvent_BeforeProjectModified() + If QP_SessionWaiting Then QP_SessionExternalChange = True +End Sub + +Sub QPEvent_SourceFileModified(ByVal FileName) + If QP_SessionWaiting Then QP_SessionExternalChange = True +End Sub + +Sub QPRequireSessionCheckpoint() + Dim Documents, View + If Not QP_OwnedProject Or Len(QP_OwnedProjectPath) = 0 Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "session project ownership was lost" + If QPCanonicalPath(QPProjectPath()) <> QPCanonicalPath(QP_OwnedProjectPath) Or _ + QPCanonicalPath(QP_OwnedProjectPath) <> QPCanonicalPath(QP_SessionProject) Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "active project changed; no automatic save or close" + If QP_SessionExternalChange Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "project modified outside worker at checkpoint; no automatic save or close" + Set Documents = QP_App.SchematicSheetDocuments() + Set View = QP_App.ActiveView + If Documents.Count <> 1 Or View Is Nothing Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "owned sheet set changed at checkpoint" + If CStr(View.GetName(0)) <> QP_CheckpointSchematic Or CStr(View.Block.SheetNum) <> QP_CheckpointSheet Then _ + Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "active sheet changed at checkpoint" +End Sub + Sub QPInvalidatePinIndex() Set QP_PinIndex = Nothing QP_PinContext = "" @@ -443,7 +572,7 @@ Sub QPEnsureProject(ByRef App, ByVal TargetPath) CurrentPath = "" If Not ProjectData Is Nothing Then CurrentPath = CStr(ProjectData.GetProjectFilePath()) If Len(Trim(CurrentPath)) > 0 Then - If QP_BatchMode Then Err.Raise vbObjectError + 870, "QuickPartReplace.Batch", _ + If QP_BatchMode And Not (QP_SessionMode And QP_OwnedProject) Then Err.Raise vbObjectError + 870, "QuickPartReplace.Batch", _ "batch cannot take over an already open project; save your wanted edits and close the project before starting the queue" If QPCanonicalPath(CurrentPath) <> QPCanonicalPath(TargetPath) Then _ Err.Raise vbObjectError + 853, "QuickPartReplace.Session", _ @@ -455,6 +584,7 @@ Sub QPEnsureProject(ByRef App, ByVal TargetPath) Opened = App.OpenProject(CStr(TargetPath)) If Not Opened Then Err.Raise vbObjectError + 854, "QuickPartReplace.Session", "DxDesigner refused to open the target project" QP_OwnedProject = True + QP_OwnedProjectPath = TargetPath End If Set ProjectData = App.GetProjectData() If ProjectData Is Nothing Then _ @@ -678,7 +808,9 @@ End Sub Sub QPCloseBatchProject(ByVal ExpectedPath, ByVal SaveChanges) Dim Documents, Document If Not QP_OwnedProject Or QP_RestoreTransactionOpen Then _ - Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "project ownership or restoration transaction is not safe to close" + Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "project ownership or restoration transaction is not safe to close" + If QPCanonicalPath(ExpectedPath) <> QPCanonicalPath(QP_OwnedProjectPath) Or QP_SessionExternalChange Then _ + Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "owned project changed; no automatic close" If QPCanonicalPath(QPProjectPath()) <> QPCanonicalPath(ExpectedPath) Then _ Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "active project changed before save and close" Set Documents = QP_App.SchematicSheetDocuments() @@ -692,6 +824,7 @@ Sub QPCloseBatchProject(ByVal ExpectedPath, ByVal SaveChanges) If Len(CStr(QP_App.GetProjectData().GetProjectFilePath())) > 0 Then _ Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "project did not close; queue stopped" QP_OwnedProject = False + QP_OwnedProjectPath = "" QPInvalidatePinIndex QPInvalidateComponentIndex End Sub @@ -699,9 +832,9 @@ End Sub Sub QPDiscardFailedBatchProject(ByRef ErrorDescription) Dim ErrorNumber, ErrorSource, Description ErrorDescription = "" - If Not QP_BatchMode Or Not QP_OwnedProject Or QP_App Is Nothing Then Exit Sub + If (Not QP_BatchMode And Not QP_SessionMode) Or Not QP_OwnedProject Or QP_App Is Nothing Then Exit Sub On Error Resume Next - QPCloseBatchProject QPProjectPath(), False + QPCloseBatchProject QP_OwnedProjectPath, False ErrorNumber = Err.Number ErrorSource = Err.Source Description = Err.Description @@ -741,8 +874,10 @@ Sub QPFinishBatchItem() ValueStates.Item(CStr(Index)).Add "custom_value", QPCustomValue(Command) Next End If - QPCloseBatchProject TargetPath, True - QP_BatchSaveCommitted = True + If FinalState = "restored_ok" Or Not QP_SessionMode Then + QPCloseBatchProject TargetPath, True + QP_BatchSaveCommitted = True + End If If FinalState = "restored_ok" Then QPProgress "verify_saved_project", 0, 1 QPEnsureProject QP_App, TargetPath @@ -757,12 +892,27 @@ Sub QPFinishBatchItem() Plans.Add CStr(Index), Candidate Next QPVerifyRestoredPlans Command, Records, Plans, ValueStates - QPCloseBatchProject TargetPath, True + If Not QP_SessionMode Then QPCloseBatchProject TargetPath, True FinalState = "saved_ok" - QP_BatchMessage = QP_BatchMessage & " Saved, reopened for readback, and closed." + If QP_SessionMode Then + QP_BatchMessage = QP_BatchMessage & " Saved and reopened for readback; owned project checkpoint verified." + Else + QP_BatchMessage = QP_BatchMessage & " Saved, reopened for readback, and closed." + End If End If QP_BatchMode = False - QPWriteStatus QP_Root, QP_CurrentJobId, FinalState, "batch_closed", QP_BatchMessage + If QP_SessionMode Then + QP_NativeMutationPossible = False + QP_SessionExternalChange = False + QP_CheckpointSchematic = QP_TargetSchematic + QP_CheckpointSheet = QP_TargetSheet + QP_SessionWaiting = True + QPWriteStatus QP_Root, QP_CurrentJobId, FinalState, "session_verified", QP_BatchMessage + QPWriteUtf8 QP_Fso.BuildPath(QP_Root, "project-session-result.tsv"), _ + QP_SessionToken & vbTab & QP_CurrentJobId & vbTab & FinalState & vbTab & "session_verified" + Else + QPWriteStatus QP_Root, QP_CurrentJobId, FinalState, "batch_closed", QP_BatchMessage + End If QPProgress "finished", 1, 1 End Sub diff --git a/src/dx_productivity/trial_task_center/batch.py b/src/dx_productivity/trial_task_center/batch.py index 1401f7a..f79b00c 100644 --- a/src/dx_productivity/trial_task_center/batch.py +++ b/src/dx_productivity/trial_task_center/batch.py @@ -45,6 +45,7 @@ def execute_batch( expected_item, stop_event: Event, continue_after_backup_failure: bool = False, + reuse_project_session: bool = True, ) -> BatchRunResult: preparer = service._quick_run_preparer retention = maintain_quick_run_storage(preparer.data_root) @@ -112,7 +113,7 @@ def execute_batch( ) else: progress = session.progress - with backups: + with backups, preparer.project_session_scope(enabled=reuse_project_session) as project_session: while not progress.queue_complete: if stop_event.is_set(): backups.commit_prefetched(progress) @@ -123,6 +124,7 @@ def execute_batch( if current is None: raise TaskCenterError('quick_run_queue_progress', '队列未结束但找不到下一项,已停止。') current_key = _path_key(current) + project_session.prepare(current) backups.prepare(current, progress) service._batch_feedback = (task_id, progress, f'正在处理 {current.name}') if stop_event.is_set(): @@ -139,7 +141,8 @@ def execute_batch( new_part_number=expected[2], job_id=session.commands[session.next_index][1]) as metric: try: last_result = preparer.execute_step(task_id, projects, rules, copy_part_number_to_value=task.copy_part_number_to_value, - expected_item=expected, batch_mode=True, batch_session=session) + expected_item=expected, batch_mode=True, batch_session=session, + **({'project_session': project_session} if project_session.enabled else {})) metric['state'] = last_result.state metric['completed_units'] = int(last_result.state in {'saved_ok', 'restored_ok', 'no_match'}) finally: diff --git a/src/dx_productivity/trial_task_center/project_session.py b/src/dx_productivity/trial_task_center/project_session.py new file mode 100644 index 0000000..dd7dac9 --- /dev/null +++ b/src/dx_productivity/trial_task_center/project_session.py @@ -0,0 +1,139 @@ +"""A supervised worker retained between verified steps of one owned project.""" +from __future__ import annotations + +from pathlib import Path +import subprocess +from threading import Event, Thread +from uuid import uuid4 + +from .worker_monitor import WorkerMonitorError, run_monitored_process + + +def _write_control(path: Path, value: str): + temporary = path.with_name(path.name + '.' + uuid4().hex + '.tmp') + temporary.write_text(value, encoding='utf-8') + temporary.replace(path) + + +class ProjectSessionWorker: + """Only a saved-and-reopened checkpoint releases the caller for its next step. + + The VBS worker owns CAD. This driver never attaches to COM or terminates CAD. + A separate monitor thread retains the existing idle watchdog and worker job. + """ + def __init__(self, project: Path, root: Path): + self.project, self.root = Path(project), Path(root) + self.token = uuid4().hex + self._done, self._abort = Event(), Event() + self._thread = None + self._command = None + self._result = self._error = None + self._waiting = False + self._closed = False + self._failure_delivered = False + self._timeout = 150 + self.starts = 0 + + def _monitor(self, command, timeout): + try: + self._result = run_monitored_process(command, timeout, abort_event=self._abort) + except Exception as error: + self._error = error + finally: + self._done.set() + + def run_step(self, command: tuple[str, ...], timeout: float): + if self._closed: + raise WorkerMonitorError('project session is already closed') + if Path(command[3]).resolve() != self.root.resolve(): + raise WorkerMonitorError('project session evidence root changed') + if self._command is not None and command[:-1] != self._command[:-1]: + raise WorkerMonitorError('project session worker configuration changed') + job = command[-1] + if self._thread is None: + self.root.mkdir(parents=True, exist_ok=True) + _write_control(self.root / 'project-session.request', f'{self.token}\t{self.project}\t{job}') + (self.root / 'project-session-next.tsv').unlink(missing_ok=True) + (self.root / 'project-session-result.tsv').unlink(missing_ok=True) + self._command, self._timeout = command, timeout + self._thread = Thread(target=self._monitor, args=(command, timeout), daemon=True, + name='dxpart-project-session') + self.starts += 1 + self._thread.start() + else: + if not self._waiting: + raise WorkerMonitorError('project session has no verified checkpoint') + self._waiting = False + _write_control(self.root / 'project-session-next.tsv', f'{self.token}\t{job}') + while True: + if self._done.is_set(): + if self._error is not None: + raise self._error + if self._result.returncode == 0: + raise WorkerMonitorError('project session exited before authorized closing') + self._failure_delivered = True + return self._result + try: + fields = (self.root / 'project-session-result.tsv').read_text(encoding='utf-8-sig').strip().split('\t') + except (FileNotFoundError, PermissionError): + fields = () + if len(fields) == 4 and fields[:2] == [self.token, job]: + if fields[2] not in {'saved_ok', 'no_match'} or fields[3] != 'session_verified': + raise WorkerMonitorError('project session returned an invalid checkpoint') + self._waiting = True + return subprocess.CompletedProcess(command, 0, '', '') + self._done.wait(0.025) + + def close(self): + if self._closed: + return + self._closed = True + try: + if self._thread is None: + return + if not self._done.is_set(): + _write_control(self.root / 'project-session-next.tsv', f'{self.token}\tclose') + if not self._done.wait(min(30, max(10, self._timeout))): + self._abort.set() + self._done.wait(10) + raise WorkerMonitorError('owned project did not acknowledge session closing') + if self._error is not None: + raise self._error + if self._result.returncode != 0 and not self._failure_delivered: + raise WorkerMonitorError('owned project session did not close cleanly: ' + self._result.stderr) + finally: + if self._done.is_set(): + for name in ('project-session.request', 'project-session-next.tsv', 'project-session-result.tsv'): + (self.root / name).unlink(missing_ok=True) + + +class ProjectSessionScope: + """One serial task can visit projects, but can hold only one worker at a time.""" + def __init__(self, fallback, *, enabled): + self.fallback, self.enabled = fallback, enabled + self.worker = None + + def __enter__(self): + return self + + def run_step(self, project, command, timeout): + if not self.enabled: + return self.fallback(command, timeout) + self.prepare(project) + if self.worker is None: + self.worker = ProjectSessionWorker(Path(project), Path(command[3])) + return self.worker.run_step(command, timeout) + + def prepare(self, project): + if self.worker is not None and (self.worker.project.resolve() != Path(project).resolve() + or self.worker._done.is_set()): + self.worker.close() + self.worker = None + + def __exit__(self, error_type, error, traceback): + if self.worker is not None: + try: + self.worker.close() + except Exception: + self.worker._abort.set() + raise diff --git a/src/dx_productivity/trial_task_center/quick_run.py b/src/dx_productivity/trial_task_center/quick_run.py index 9cc2f83..8b79a61 100644 --- a/src/dx_productivity/trial_task_center/quick_run.py +++ b/src/dx_productivity/trial_task_center/quick_run.py @@ -3,6 +3,7 @@ from __future__ import annotations from collections.abc import Callable +from contextlib import contextmanager from dataclasses import dataclass from datetime import datetime, timezone from functools import lru_cache @@ -292,6 +293,20 @@ class QuickRunPreparer: _vbs_worker_paths(handoff.script_path, handoff.script_path.parent), ) + @contextmanager + def project_session_scope(self, *, enabled=True): + """Retain only the built-in supervised worker; injected workers stay compatible.""" + from .project_session import ProjectSessionScope + from .worker_monitor import WorkerMonitorError + try: + with ProjectSessionScope(self._process_runner, + enabled=enabled and self._process_runner is _run_process) as scope: + yield scope + except (WorkerMonitorError, subprocess.TimeoutExpired) as error: + _write_uncertain_flag(self._data_root / 'quick-run/uncertain.flag', 'project_session_cleanup') + raise TaskCenterError('quick_run_uncertain', + '工程会话未能确认安全关闭,队列已停止;请保留工程和执行证据后核验恢复。') from error + def execute_step( self, task_id: str, @@ -302,6 +317,7 @@ class QuickRunPreparer: expected_item: tuple[str, str, str, str] | None = None, batch_mode: bool = False, batch_session: QuickRunBatchSession | None = None, + project_session=None, ) -> QuickRunStepResult: """Prepare or resume a queue, then execute one replacement rule end to end.""" uncertain_path = self._data_root / "quick-run" / "uncertain.flag" @@ -378,7 +394,10 @@ class QuickRunPreparer: self.invalidate_discovery(Path(selected_command[2])) try: - completed = self._process_runner(command, IDLE_PROGRESS_TIMEOUT_SECONDS) + if project_session is not None: + completed = project_session.run_step(Path(selected_command[2]), command, IDLE_PROGRESS_TIMEOUT_SECONDS) + else: + completed = self._process_runner(command, IDLE_PROGRESS_TIMEOUT_SECONDS) except subprocess.TimeoutExpired as error: _write_uncertain_flag(uncertain_path, "worker_timeout") _append_log(handoff.log_path, "quick_run_uncertain worker_timeout") @@ -439,7 +458,9 @@ class QuickRunPreparer: _append_log(handoff.log_path, f"quick_run_uncertain uncorrelated_status exit_code={completed.returncode}") raise TaskCenterError("quick_run_uncertain", "quick-run worker returned an uncorrelated status; reconcile the project before retrying") _, state, code, message = changed - if batch_mode and completed.returncode == 0 and state in DONE_STATES and code != "batch_closed": + verified_session = bool(project_session is not None and project_session.enabled + and code == 'session_verified') + if batch_mode and completed.returncode == 0 and state in DONE_STATES and code != "batch_closed" and not verified_session: _write_uncertain_flag(uncertain_path, "batch_save_close_unverified") raise TaskCenterError("quick_run_uncertain", "批量步骤未确认保存关闭完成,队列已停止,不会继续下一工程。") check_log_rotation = ( @@ -669,63 +690,16 @@ class QuickRunPreparer: collect_components: bool = False, ) -> _ProjectDiscovery: """Enumerate sheets and requested source parts while the owned project is open.""" - project = project_path.resolve(strict=True) - token = uuid4().hex - job_id = _safe_run_token("discover_" + token) - root = self._data_root / "quick-run-history" / ("sheet-discovery-" + token) - root.mkdir(parents=True, exist_ok=False) - script = root / "QuickPartReplace.vbs" - shutil.copyfile(self._required_script_source(), script) - (root / "command.tsv").write_text( - "task_id\tjob_id\tproject_path\told_part\tnew_part\tvalue_mode\r\n" - f"sheet_discovery\t{job_id}\t{project}\tDISCOVERY_OLD\tDISCOVERY_NEW\tpreserve\r\n", - encoding="utf-8", - newline="", - ) - (root / "status.tsv").write_text("job_id\tstate\tcode\tmessage\r\n", encoding="utf-8", newline="") - (root / "batch.request").write_text(job_id, encoding="ascii") - (root / "sheet-discovery.request").write_text(job_id, encoding="ascii") - requested: dict[str, str] = {} - for old_part_number in old_part_numbers: - requested.setdefault(old_part_number.casefold(), old_part_number) - (root / "inventory-request.tsv").write_text( - "old_part\r\n" + "".join( - f"{_encode_vbs_field(old_part_number)}\r\n" - for old_part_number in requested.values() - ), - encoding="utf-8", - newline="", - ) - if collect_components: - (root / "component-inventory.request").write_text(job_id, encoding="ascii") - script_argument, root_argument = _vbs_worker_paths(script, root) - command = ( - str(self._cscript_resolver()), - "//nologo", - script_argument, - root_argument, - *_native_helper_launch_arguments(), - job_id, - ) - try: - completed = self._process_runner(command, IDLE_PROGRESS_TIMEOUT_SECONDS) - except (OSError, subprocess.SubprocessError) as error: - raise TaskCenterError( - "quick_run_sheet_discovery", - f"枚举工程图页时执行器未能安全结束:{project};{error}", - ) from error - (root / "worker-output.txt").write_text(completed.stdout + "\n" + completed.stderr, encoding="utf-8") - if completed.returncode != 0: - detail = completed.stderr.strip() or completed.stdout.strip() or "sheet discovery failed" - raise TaskCenterError("quick_run_sheet_discovery", _session_failure_message(detail)) - sheets = _read_discovered_sheets(root / "sheets.tsv", project) - matches = _read_discovery_inventory(root / "inventory.tsv", project, sheets) - if collect_components: - from .inventory import read_component_inventory - components = read_component_inventory(root / "components.tsv", project, sheets) - else: - components = () - return _ProjectDiscovery(sheets, matches, components) + from .project_discovery import DiscoveryRuntime, discover_project + + return discover_project(project_path, old_part_numbers, + data_root=self._data_root, script_source=self._required_script_source(), + collect_components=collect_components, + runtime=DiscoveryRuntime( + self._process_runner, self._cscript_resolver, _vbs_worker_paths, + _native_helper_launch_arguments, _session_failure_message, + _read_discovered_sheets, _read_discovery_inventory, + IDLE_PROGRESS_TIMEOUT_SECONDS)) @property def vbs_root_compatible(self) -> bool: diff --git a/src/dx_productivity/trial_task_center/worker_monitor.py b/src/dx_productivity/trial_task_center/worker_monitor.py index 90f4960..86b9fd5 100644 --- a/src/dx_productivity/trial_task_center/worker_monitor.py +++ b/src/dx_productivity/trial_task_center/worker_monitor.py @@ -24,6 +24,7 @@ class ProgressWatch: raise ValueError('Idle timeout must be positive') self.token = token self.job_id = job_id + self.current_job_id = job_id self.idle_timeout = idle_timeout self.last_progress = started self.sequence = 0 @@ -39,7 +40,10 @@ class ProgressWatch: def accept(self, line: bytes, now: float) -> bool: try: fields = line.decode('ascii').strip().split('\t') - if len(fields) != 8 or fields[:3] != ['DX_PROGRESS', self.token, self.job_id]: + if len(fields) not in {8, 9} or fields[:3] != ['DX_PROGRESS', self.token, self.job_id]: + return False + current_job = fields[8] if len(fields) == 9 else self.job_id + if not re.fullmatch(r'[A-Za-z0-9_.-]{1,128}', current_job): return False sequence, done, total, safe = (int(fields[index]) for index in (3, 5, 6, 7)) if not self.sequence < sequence <= 2**31 - 1 or not re.fullmatch('[a-z_]{1,64}', fields[4]): @@ -48,6 +52,11 @@ class ProgressWatch: return False except (ValueError, UnicodeError): return False + if current_job != self.current_job_id: + self.current_job_id = current_job + self.stage_seconds = {} + self.started = self.stage_started = now + self.stage = fields[4] if fields[4] != self.stage: self.stage_seconds[self.stage] = self.stage_seconds.get(self.stage, 0.0) + max(0.0, now - self.stage_started) self.stage_started = now @@ -69,7 +78,8 @@ class ProgressWatch: now = time.monotonic() if now is None else now stages = dict(self.stage_seconds) stages[self.stage] = stages.get(self.stage, 0.0) + max(0.0, now - self.stage_started) - return {name: getattr(self, name) for name in ('token', 'job_id', 'sequence', 'stage', 'done', 'total', 'safe_stop', 'stop_requested')} | { + return {name: getattr(self, name) for name in ('token', 'sequence', 'stage', 'done', 'total', 'safe_stop', 'stop_requested')} | { + 'job_id': self.current_job_id, 'elapsed_seconds': max(0.0, now - self.started), 'stage_seconds': stages} @@ -147,7 +157,7 @@ class _OwnedWorkers: self.job.Close() -def run_monitored_process(command: tuple[str, ...], idle_timeout: float) -> subprocess.CompletedProcess[str]: +def run_monitored_process(command: tuple[str, ...], idle_timeout: float, *, abort_event=None) -> subprocess.CompletedProcess[str]: root = Path(command[3]) job_id = command[-1] token = uuid4().hex @@ -195,6 +205,8 @@ def run_monitored_process(command: tuple[str, ...], idle_timeout: float) -> subp _publish_progress(progress_path, watch.snapshot()) _atomic_text(ready, token) while process.poll() is None: + if abort_event is not None and abort_event.is_set(): + raise WorkerMonitorError('project session supervisor requested worker cleanup') try: receive(*messages.get(timeout=min(0.1, idle_timeout / 10))) for pending in range(128): diff --git a/tests/v1_1/test_project_session.py b/tests/v1_1/test_project_session.py new file mode 100644 index 0000000..c7a413c --- /dev/null +++ b/tests/v1_1/test_project_session.py @@ -0,0 +1,114 @@ +import json +from pathlib import Path +import sys +import subprocess +import pytest + +from dx_productivity.trial_task_center.project_session import ProjectSessionWorker, ProjectSessionScope +from dx_productivity.trial_task_center.worker_monitor import ProgressWatch, WorkerMonitorError + + +def toy_worker(root): + script = root / 'toy_session.py' + script.write_text('''import pathlib,sys,time,json,os +root=pathlib.Path(sys.argv[1]); initial=sys.argv[4]; monitor=sys.argv[5] +while not (root/f'monitor-{monitor}.ready').exists():time.sleep(.005) +session=(root/'project-session.request').read_text(encoding='utf-8').split('\\t')[0] +job=initial; sequence=0 +with (root/'starts.txt').open('a') as f:f.write(str(os.getpid())+'\\n') +while True: + sequence+=1 + print(f'DX_PROGRESS\\t{monitor}\\t{initial}\\t{sequence}\\tsession_wait\\t1\\t1\\t1\\t{job}',flush=True) + (root/'project-session-result.tsv').write_text(f'{session}\\t{job}\\tsaved_ok\\tsession_verified',encoding='utf-8') + with (root/'steps.txt').open('a') as f:f.write(job+'\\n') + while not (root/'project-session-next.tsv').exists():time.sleep(.005) + token,job=(root/'project-session-next.tsv').read_text().split('\\t') + (root/'project-session-next.tsv').unlink() + if token!=session:sys.exit(8) + if job=='close':break +(root/'closed.txt').write_text('closed') +''', encoding='utf-8') + return (sys.executable, '-u', str(script), str(root), sys.executable, '', 'job1') + + +def test_same_project_steps_retain_one_supervised_worker_and_close(tmp_path): + command = toy_worker(tmp_path) + session = ProjectSessionWorker(tmp_path / '工程.prj', tmp_path) + try: + assert session.run_step(command, 3).returncode == 0 + assert session.run_step((*command[:-1], 'job2'), 3).returncode == 0 + finally: + session.close() + assert (tmp_path / 'closed.txt').exists() + assert (tmp_path / 'steps.txt').read_text().splitlines() == ['job1', 'job2'] + assert len((tmp_path / 'starts.txt').read_text().splitlines()) == 1 + assert not (tmp_path / 'project-session.request').exists() + + +def test_session_progress_keeps_monitor_identity_and_resets_each_step(): + watch = ProgressWatch('token', 'first', 10, 0) + first = b'DX_PROGRESS\ttoken\tfirst\t1\topen_project\t0\t1\t1\tfirst\n' + second = b'DX_PROGRESS\ttoken\tfirst\t2\tnative_replace\t0\t1\t0\tsecond\n' + assert watch.accept(first, 1) + assert watch.accept(second, 5) + value = watch.snapshot(now=6) + assert value['job_id'] == 'second' + assert value['stage_seconds'] == {'native_replace': 1} + assert value['elapsed_seconds'] == 1 + assert not watch.accept(second.replace(b'\tfirst\t2', b'\tforeign\t3'), 6) + + +def test_real_vbs_session_authorization_fails_before_cad_for_missing_project(tmp_path): + script = Path(__file__).resolve().parents[2] / 'integration/dxdesigner795/QuickPartReplace.vbs' + project = tmp_path / 'missing.prj' + (tmp_path / 'command.tsv').write_text(f'job_id\tproject_path\njob\t{project}\n') + (tmp_path / 'batch.request').write_text('job') + (tmp_path / 'project-session.request').write_text(f'{"a"*32}\t{project}\tjob') + result = subprocess.run((r'C:\Windows\SysWOW64\cscript.exe', '//nologo', str(script), + str(tmp_path), sys.executable, '', 'job'), + capture_output=True, timeout=10, text=True) + assert result.returncode == 2 + assert 'confirmed project file does not exist' in result.stderr + + +def test_switching_project_closes_previous_worker_before_starting_next(tmp_path): + roots = [tmp_path / 'first', tmp_path / 'second'] + for root in roots: + root.mkdir() + with ProjectSessionScope(None, enabled=True) as scope: + assert scope.run_step(roots[0] / 'a.prj', toy_worker(roots[0]), 3).returncode == 0 + scope.prepare(roots[1] / 'b.prj') + assert (roots[0] / 'closed.txt').exists() + assert scope.run_step(roots[1] / 'b.prj', toy_worker(roots[1]), 3).returncode == 0 + assert (roots[1] / 'closed.txt').exists() + + +def test_wrong_session_checkpoint_cannot_release_next_step(tmp_path): + command = toy_worker(tmp_path) + script = Path(command[2]) + script.write_text(script.read_text(encoding='utf-8').replace( + "f'{session}\\t{job}\\tsaved_ok\\tsession_verified'", + "f'wrong-token\\t{job}\\tsaved_ok\\tsession_verified'").replace( + "while not (root/'project-session-next.tsv').exists():time.sleep(.005)", + 'sys.exit(0)'), encoding='utf-8') + session = ProjectSessionWorker(tmp_path / 'a.prj', tmp_path) + try: + with pytest.raises(WorkerMonitorError, match='before authorized closing'): + session.run_step(command, 3) + finally: + session.close() + + +def test_completed_failure_is_delivered_and_next_step_starts_fresh_worker(tmp_path): + command = toy_worker(tmp_path) + script = Path(command[2]) + script.write_text(script.read_text(encoding='utf-8').replace( + 'job=initial; sequence=0', "job=initial; sequence=0\nif job=='failed':sys.exit(7)"), encoding='utf-8') + project = tmp_path / 'a.prj' + with ProjectSessionScope(None, enabled=True) as scope: + failed = scope.run_step(project, (*command[:-1], 'failed'), 3) + assert failed.returncode == 7 + previous = scope.worker + assert scope.run_step(project, command, 3).returncode == 0 + assert scope.worker is not previous + assert (tmp_path / 'closed.txt').exists() diff --git a/tools/measure_project_session.py b/tools/measure_project_session.py new file mode 100644 index 0000000..8180785 --- /dev/null +++ b/tools/measure_project_session.py @@ -0,0 +1,112 @@ +"""Run native replacements on a prepared disposable project, then independently read back. + +The inventory must come from native discovery of the same source project. This +runner refuses a project outside --output; prepare copies before invoking it. +""" +import argparse +from dataclasses import asdict +import json +import inspect +import os +from pathlib import Path +import sys +from threading import Event +import time +import traceback + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--output', type=Path, required=True) + parser.add_argument('--project', type=Path, required=True) + parser.add_argument('--inventory', type=Path, required=True) + parser.add_argument('--source-root', type=Path, default=Path(__file__).resolve().parents[1]) + parser.add_argument('--mode', choices=('baseline', 'reuse'), required=True) + parser.add_argument('--old', default='4100-CA0000-T7') + parser.add_argument('--new', default='4100-CA0000-T0') + parser.add_argument('--refs', default='R32A8,R39A8,RG47') + args = parser.parse_args() + output, project = args.output.resolve(), args.project.resolve() + if not project.is_relative_to(output) or not project.is_file(): + parser.error('project must be a disposable copy inside output') + sys.path.insert(0, str(args.source_root.resolve() / 'src')) + os.environ['PYTHONPATH'] = str(args.source_root.resolve() / 'src') + os.pathsep + os.environ.get('PYTHONPATH', '') + from dx_productivity.trial_task_center.logging_setup import configure_logging + from dx_productivity.trial_task_center.quick_run import QuickRunPreparer + from dx_productivity.trial_task_center.store import TaskStore + from dx_productivity.trial_task_center.service import TaskCenterService + from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow + source = json.loads(args.inventory.read_text(encoding='utf-8')) + sheets = tuple(tuple(sheet) for sheet in source['sheets']) + inventory = tuple(ComponentTarget(project, row['schematic_name'], row['sheet_number'], + row['uid'], row['refdes'], row['old_part_number'], row['old_value']) for row in source['components']) + ref_list = args.refs.split(',') + selected = set(ref_list) + assert selected <= {row.refdes for row in inventory} + output.mkdir(parents=True, exist_ok=True) + report = {'mode': args.mode, 'project': str(project), 'source_root': str(args.source_root), + 'selected': sorted(selected), 'sheets': len(sheets)} + store = TaskStore(output / 'tasks.db') + preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets) + service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer) + try: + import win32com.client + try: + app = win32com.client.GetActiveObject('Viewdraw.Application') + except Exception: + app = None + if app is not None and app.GetProjectData().GetProjectFilePath(): + raise RuntimeError('save and close existing CAD project before native measurement') + task = service.create_project_tasks(project.parent)[0] + service.add_rule(task.task_id, args.old, args.new) + store.record_target_inventory(task.task_id, inventory) + rows = tuple(TargetPlanRow(target, target.refdes in selected, args.new, + sync_nc=target.refdes != ref_list[1]) for target in inventory) + service.replace_target_plan(task.task_id, rows) + report['task_id'] = task.task_id + progress = service.quick_run_progress(task.task_id) + expected = (str(progress.next_project_path), progress.next_old_part_number, + progress.next_new_part_number, 'preserve') + print('native_start', args.mode, task.task_id, flush=True) + started = time.perf_counter() + session_option = ({'reuse_project_session': args.mode == 'reuse'} + if 'reuse_project_session' in inspect.signature(service.execute_quick_run_queue).parameters else {}) + if args.mode == 'reuse' and not session_option: + raise RuntimeError('selected source does not implement project session reuse') + result = service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=Event(), + **session_option) + report['queue_seconds'] = time.perf_counter() - started + report['result'] = asdict(result) + print('native_result', args.mode, report['queue_seconds'], result.progress, flush=True) + assert result.progress.queue_complete and result.progress.failed_items == 0 + evidence = output / 'data' / 'tasks' / task.task_id / 'quick-run' + text = (evidence / 'quick-part-replace.log').read_text(encoding='utf-8') + report['worker_starts'] = len(tuple(evidence.glob('monitor-*.ready'))) + report['open_project_calls'] = text.count('stage=open_project target=') + events = [json.loads(line) for line in service.tail_log(task.task_id, limit=None)] + report['timings'] = [event for event in events if event['operation'] in {'execution_timing', 'quick_run_executed'}] + reader = QuickRunPreparer(output / 'independent-read') + started = time.perf_counter() + actual = reader._discover_project_sheets(project, (args.old, args.new), collect_components=True) + report['readback_seconds'] = time.perf_counter() - started + by_key = {(row.schematic_name, row.sheet_number, row.uid): row for row in actual.components} + comparisons = [] + for target in inventory: + row = by_key[(target.schematic_name, target.sheet_number, target.uid)] + expected_part = args.new if target.refdes in selected else target.old_part_number + comparisons.append({'refdes': target.refdes, 'sheet': target.sheet_number, + 'expected': expected_part, 'actual': row.old_part_number}) + assert row.refdes == target.refdes and row.old_part_number == expected_part + report['comparisons'] = comparisons + report['verified'] = True + except Exception as error: + report['error'] = str(error) + traceback.print_exc() + finally: + (output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8') + store.close() + return 0 if report.get('verified') else 1 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/tools/probe_project_session_guards.py b/tools/probe_project_session_guards.py new file mode 100644 index 0000000..f7eae68 --- /dev/null +++ b/tools/probe_project_session_guards.py @@ -0,0 +1,97 @@ +"""Exercise clean closing and external-edit/foreign-project guards on copies only.""" +import argparse +import json +import os +from pathlib import Path +import shutil +import sys +import time + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src')) +from dx_productivity.trial_task_center.quick_run import QuickRunPreparer +from dx_productivity.trial_task_center.service import TaskCenterService +from dx_productivity.trial_task_center.store import TaskStore +from dx_productivity.trial_task_center.logging_setup import configure_logging + + +def run(source, output, sheets, mode): + import win32com.client + app = win32com.client.GetActiveObject('Viewdraw.Application') + assert not app.GetProjectData().GetProjectFilePath() + project_root = output / 'project' + shutil.copytree(source.parent, project_root) + project = project_root / source.name + store = TaskStore(output / 'tasks.db') + preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets) + service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer) + task = service.create_project_tasks(project_root)[0] + service.add_rule(task.task_id, 'SESSION_PROBE_ABSENT_PART', 'SESSION_PROBE_NEW_PART') + child = service.for_project_task(task.task_id) + preparer = child._quick_run_preparer + projects, rules = child.projects(task.task_id), child.rules(task.task_id) + session = preparer.begin_batch_session(task.task_id, projects, rules) + record = {'mode': mode, 'project': str(project)} + foreign = None + try: + try: + with preparer.project_session_scope() as retained: + progress = session.progress + result = preparer.execute_step(task.task_id, projects, rules, batch_mode=True, + batch_session=session, project_session=retained, + expected_item=(str(project), progress.next_old_part_number, progress.next_new_part_number, 'preserve')) + assert result.state == 'no_match' + if mode == 'edit': + for component in app.ActiveView.Query(128, 0): + attribute = component.FindAttribute('Value') + if attribute is not None: + record['previous_value'] = attribute.Value + attribute.Value = 'SESSION_EXTERNAL_EDIT_PROBE' + record['external_edit_written'] = True + break + assert record.get('external_edit_written') + time.sleep(0.2) + elif mode == 'foreign': + app.SchematicSheetDocuments().Item(1).Close(False, '') + app.CloseProject() + foreign_root = output / 'foreign' + shutil.copytree(source.parent, foreign_root) + foreign = foreign_root / source.name + assert app.OpenProject(str(foreign)) + record['closed_cleanly'] = True + except Exception as error: + record['error'] = str(error) + record['error_code'] = getattr(error, 'code', '') + active = app.GetProjectData().GetProjectFilePath() + record['active_after_guard'] = active + if mode == 'clean': + assert record.get('closed_cleanly') and not active + else: + assert record.get('error_code') == 'quick_run_uncertain' + assert Path(active).resolve() == (foreign or project).resolve() + record['preserved_external_state'] = True + record['passed'] = True + finally: + active = app.GetProjectData().GetProjectFilePath() + if active and Path(active).resolve() in {project.resolve(), (foreign or project).resolve()}: + # Explicit cleanup of this probe's own disposable edits/projects. + documents = app.SchematicSheetDocuments() + while documents.Count: + documents.Item(1).Close(False, '') + app.CloseProject() + store.close() + (output / 'guard-report.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8') + print(json.dumps(record, ensure_ascii=False), flush=True) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--source-copy', type=Path, required=True) + parser.add_argument('--inventory', type=Path, required=True) + parser.add_argument('--output', type=Path, required=True) + args = parser.parse_args() + args.output = args.output.resolve() + args.output.mkdir(parents=True, exist_ok=False) + os.environ['PYTHONPATH'] = str(Path(__file__).resolve().parents[1] / 'src') + sheets = tuple(tuple(row) for row in json.loads(args.inventory.read_text(encoding='utf-8'))['sheets']) + for mode in ('clean', 'edit', 'foreign'): + run(args.source_copy.resolve(), args.output / mode, sheets, mode) diff --git a/tools/probe_project_session_pages.py b/tools/probe_project_session_pages.py new file mode 100644 index 0000000..fa67016 --- /dev/null +++ b/tools/probe_project_session_pages.py @@ -0,0 +1,73 @@ +"""Probe real sheet transitions and between-step closing on a disposable copy.""" +import argparse +import json +import os +from pathlib import Path +import shutil +import sys +import time + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src')) +from dx_productivity.trial_task_center.quick_run import QuickRunPreparer +from dx_productivity.trial_task_center.service import TaskCenterService +from dx_productivity.trial_task_center.store import TaskStore +from dx_productivity.trial_task_center.logging_setup import configure_logging + + +def main(): + import win32com.client + parser = argparse.ArgumentParser() + parser.add_argument('--source-copy', type=Path, required=True) + parser.add_argument('--inventory', type=Path, required=True) + parser.add_argument('--output', type=Path, required=True) + args = parser.parse_args() + app = win32com.client.GetActiveObject('Viewdraw.Application') + assert not app.GetProjectData().GetProjectFilePath(), 'a project is already open' + output = args.output.resolve() + output.mkdir(parents=True, exist_ok=False) + source = args.source_copy.resolve() + project = output / 'project' / source.name + shutil.copytree(source.parent, project.parent) + sheets = tuple(tuple(row) for row in json.loads(args.inventory.read_text(encoding='utf-8'))['sheets']) + assert len(sheets) >= 4 + store = TaskStore(output / 'tasks.db') + preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets) + service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer) + report = {'project': str(project), 'steps': []} + started = time.perf_counter() + try: + task = service.create_project_tasks(project.parent)[0] + service.add_rule(task.task_id, 'SESSION_PROBE_ABSENT_PART', 'SESSION_PROBE_NEW_PART') + child = service.for_project_task(task.task_id) + preparer = child._quick_run_preparer + projects, rules = child.projects(task.task_id), child.rules(task.task_id) + session = preparer.begin_batch_session(task.task_id, projects, rules) + with preparer.project_session_scope() as retained: + for _ in range(3): + progress = session.progress + step_started = time.perf_counter() + result = preparer.execute_step(task.task_id, projects, rules, batch_mode=True, + batch_session=session, project_session=retained, + expected_item=(str(project), progress.next_old_part_number, + progress.next_new_part_number, 'preserve')) + view = app.ActiveView + actual = (view.GetName(0), view.Block.SheetNum) + assert result.state == 'no_match' + assert actual == (progress.next_schematic_name, progress.next_sheet_number) + report['steps'].append({'sheet': actual, 'state': result.state, + 'seconds': time.perf_counter() - step_started}) + assert retained.worker.starts == 1 + assert session.progress.completed_items == 3 and not session.progress.queue_complete + assert not app.GetProjectData().GetProjectFilePath() + report.update(passed=True, closed_between_steps=True, worker_starts=1, + completed_items=3, total_items=session.progress.total_items) + finally: + report['seconds'] = time.perf_counter() - started + (output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8') + store.close() + print(json.dumps(report, ensure_ascii=False), flush=True) + + +if __name__ == '__main__': + os.environ['PYTHONPATH'] = str(Path(__file__).resolve().parents[1] / 'src') + main()