Reuse supervised project sessions between verified replacement steps
This commit is contained in:
1 parent
4194c011e3
commit
2172d8faee
9 files changed
+754
-80
No files matched your search
@@ -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
|
||||
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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
|
||||
@@ -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:
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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()
|
||||
@@ -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())
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
Reference in new issue
Block a user