public void ClearAsyncCallbacks() { lock (waiting_object_lock) { waiting_object = null; } }
private Printer(PrinterProfile profile, SpoolerClient client) { this.client = client; mylockID = Guid.Empty; m_printer_profile.Value = profile; thread_sync = new object(); spool_lock = new object(); spool_up_to_date = false; incoming_data = null; Found = new ThreadSafeVariable <bool> { Value = false }; _connected = new ThreadSafeVariable <bool> { Value = false }; log = new CircularArray <string>(200); LogWaits = true; LogFeedback = true; waiting_object = null; waiting_object_lock = new object(); lockstatus = new ThreadSafeVariable <PrinterLockStatus>(PrinterLockStatus.Unlocked); lockstepmode = new ThreadSafeVariable <bool>(true); lockTimeOutSeconds = new ThreadSafeVariable <int>(0); keeplockalive_clock = new Stopwatch(); keeplockalive_limit_clock = new Stopwatch(); finished_lock = new object(); m_ChangedKeyValuePairs = new ConcurrentDictionary <string, string>(); }
public SpoolerResult AcquireLock(AsyncCallback callback, object state, EventLockTimeOutCallBack LockTimeOutCallBack, int locktimeoutseconds) { if (HasLock && callback != null) { callback(new AsyncCallObject(callback, state, (IPrinter)this) { callresult = CommandResult.Success_LockAcquired }); return(SpoolerResult.OK); } AsyncCallObject newWaitingObject = CreateNewWaitingObject(callback, state, false); if (newWaitingObject == null) { return(SpoolerResult.Fail_PreviousCommandNotComplete); } newWaitingObject.callbackType = CallBackType.Special; lockstatus.Value = PrinterLockStatus.OurLockPending; lockTimeOutSeconds.Value = locktimeoutseconds; lock (timeout_lock_sync) { __LockTimeOutCallBack = LockTimeOutCallBack; } return(SendRPCToSpooler(nameof(AcquireLock), newWaitingObject.callID)); }
private SpoolerResult SendRPCToSpooler(AsyncCallback callback, object state, CallBackType callbacktype, bool always_send, string function_name, params object[] options) { if (!HasLock && !always_send) { if (callback != null) { var ar = (IAsyncCallResult) new SimpleAsyncCallResult(state, CommandResult.Failed_PrinterDoesNotHaveLock); callback(ar); } return(SpoolerResult.Fail_DoesNotHaveLock); } AsyncCallObject newWaitingObject = CreateNewWaitingObject(callback, state, LockStepMode && !always_send); if (newWaitingObject == null) { callback?.Invoke(new AsyncCallObject(callback, state, (IPrinter)this) { callresult = CommandResult.Failed_PreviousCommandNotCompleted }); return(SpoolerResult.Fail_PreviousCommandNotComplete); } newWaitingObject.callbackType = callbacktype; return(SendRPCToSpooler(function_name, newWaitingObject.callID, options)); }
public SpoolerResult ReleaseLock(AsyncCallback callback, object state) { AsyncCallObject newWaitingObject = CreateNewWaitingObject(callback, state, false); if (newWaitingObject == null) { return(SpoolerResult.Fail_PreviousCommandNotComplete); } newWaitingObject.callbackType = CallBackType.Special; lockstatus.Value = PrinterLockStatus.OurReleasePending; return(SendRPCToSpooler(nameof(ReleaseLock), newWaitingObject.callID)); }
private AsyncCallObject CreateNewWaitingObject(AsyncCallback callback, object state, bool lockstepmode) { var asyncCallObject = (AsyncCallObject)null; lock (waiting_object_lock) { if (!lockstepmode && waiting_object != null) { AsyncCallObject waitingObject = waiting_object; waitingObject.callresult = CommandResult.OverridedByNonLockStepCall; ThreadPool.QueueUserWorkItem(new WaitCallback(DoAsyncCallBack), waitingObject); waiting_object = null; } if (waiting_object == null) { waiting_object = new AsyncCallObject(callback, state, this); can_check_idle.Value = false; asyncCallObject = waiting_object; } } return(asyncCallObject); }
public void ProcessSpoolerMessage(SpoolerMessage message) { var asyncCallObject = (AsyncCallObject)null; var flag = false; if (message.Type == MessageType.RawData) { lock (thread_sync) { incoming_data = message.GetRawData(); } } else if (message.Type == MessageType.PluginMessage) { ProcessPluginMessageFromSpooler(message); } else if (message.Type == MessageType.LoggingMessage) { AddMessageToLog(Base64Convert.Base64Decode(message.Message)); lock (log) { log_updated = true; } } else if (message.Type == MessageType.FullLoggingData) { string[] strArray = Base64Convert.Base64Decode(message.Message).Split('\n'); log.Clear(); foreach (var message1 in strArray) { AddMessageToLog(message1); } lock (log) { log_updated = true; } } else if (message.Type == MessageType.BedLocationMustBeCalibrated || message.Type == MessageType.BedOrientationMustBeCalibrated || message.Type == MessageType.CheckGantryClips) { mylockID = Guid.Empty; lockstatus.Value = PrinterLockStatus.Unlocked; lock (waiting_object_lock) { if (waiting_object != null) { asyncCallObject = waiting_object; waiting_object = null; asyncCallObject.callresult = CommandResult.Failed_GantryClipsOrInvalidZ; } } } else if ((message.Type == MessageType.LockConfirmed || message.Type == MessageType.LockResult) && message.SerialNumber == Info.serial_number) { uint num = 0; EventLockTimeOutCallBack callback = null; CommandResult commandResult; if (message.Type == MessageType.LockResult) { var s = message.Message.Substring(0, 8); var str = message.Message.Substring(8); try { num = uint.Parse(s); commandResult = (CommandResult)Enum.Parse(typeof(CommandResult), str); } catch (ArgumentException ex) { commandResult = CommandResult.Failed_Exception; } if (commandResult == CommandResult.Success) { can_check_idle.Value = true; return; } if (commandResult == CommandResult.Pending) { lockstatus.Value = PrinterLockStatus.OurLockPending; return; } if (commandResult == CommandResult.LockForcedOpen) { lockstatus.Value = PrinterLockStatus.Unlocked; } else if (commandResult == CommandResult.LockLost_TimedOut) { lock (timeout_lock_sync) { callback = __LockTimeOutCallBack; __LockTimeOutCallBack = null; } } if (commandResult != CommandResult.CommandInterruptedByM0) { flag = true; } } else { mylockID = Guid.Parse(message.Message); commandResult = CommandResult.Success_LockAcquired; lockstatus.Value = PrinterLockStatus.WeOwnLocked; } lock (waiting_object_lock) { if (waiting_object != null) { if (commandResult == CommandResult.SuccessfullyReceived) { if (waiting_object.callbackType != CallBackType.SuccessfullyReceived) { goto label_59; } } asyncCallObject = waiting_object; waiting_object = null; } } label_59: if (flag) { mylockID = Guid.Empty; lockstatus.Value = PrinterLockStatus.Unlocked; } if (asyncCallObject != null) { if (num != 0U && (int)num != (int)asyncCallObject.callID) { commandResult = CommandResult.Failed_AsyncCallbackError; } asyncCallObject.callresult = commandResult; } if (callback != null) { ThreadPool.QueueUserWorkItem(new WaitCallback(DoTimeoutCallBack), new Printer.TimeoutProperties(callback, (IPrinter)this)); } } if (asyncCallObject != null) { ThreadPool.QueueUserWorkItem(new WaitCallback(DoAsyncCallBack), asyncCallObject); } if (OnProcessSpoolerMessage == null) { return; } OnProcessSpoolerMessage(message); }
public void UpdateData(PrinterInfo info) { printer_info.CopyFrom(info); current_job = printer_info.current_job == null ? null : new JobInfo(printer_info.current_job); var other = new FilamentSpool(printer_info.filament_info); if (spool_up_to_date) { if (other == current_spool) { spool_up_to_date = false; } } else { current_spool = new FilamentSpool(other); } CheckForUpdatedValues(); var asyncCallObject = (AsyncCallObject)null; var flag1 = false; var flag2 = false; lock (waiting_object_lock) { if (waiting_object != null) { var lastCompletedRpcid = Info.synchronization.LastCompletedRPCID; if (Info.Status == PrinterStatus.Firmware_Idle && can_check_idle.Value) { flag1 = true; } if (waiting_object.callbackType == CallBackType.FirmwareMode && !Info.InFirmwareMode || waiting_object.callbackType == CallBackType.BootloaderMode && !Info.InBootloaderMode) { inRequestedMode = false; } if (waiting_object.callbackType == CallBackType.CallID && (int)waiting_object.callID == (int)lastCompletedRpcid || !inRequestedMode && (waiting_object.callbackType == CallBackType.FirmwareMode && Info.InFirmwareMode || waiting_object.callbackType == CallBackType.BootloaderMode && Info.InBootloaderMode)) { flag2 = true; flag1 = false; } if (flag1 | flag2) { asyncCallObject = waiting_object; waiting_object = null; } } } if (asyncCallObject != null) { asyncCallObject.callresult = CommandResult.Success; asyncCallObject.idle_callback = flag1; ThreadPool.QueueUserWorkItem(new WaitCallback(DoAsyncCallBack), asyncCallObject); lock (finished_lock) { AllCommandsFinished?.Invoke(new SimpleAsyncCallResult((object)this, CommandResult.Success)); } } if (HasLock && Info.IsIdle) { var num = lockTimeOutSeconds.Value; if (!keeplockalive_clock.IsRunning) { keeplockalive_clock.Restart(); } if (!keeplockalive_limit_clock.IsRunning && num > 0) { keeplockalive_limit_clock.Restart(); } if (keeplockalive_clock.Elapsed.TotalSeconds > 15.0 && (num <= 0 || keeplockalive_limit_clock.Elapsed.TotalSeconds < num)) { var spooler = (int)SendRPCToSpooler("KeepLockAlive", 0U); keeplockalive_clock.Restart(); } } else if (keeplockalive_clock.IsRunning) { keeplockalive_clock.Stop(); keeplockalive_limit_clock.Stop(); } if (Info.InBootloaderMode) { m_bPluginsRegistered = false; } else if (!m_bPluginsRegistered) { DoPluginRegistration(); } if (OnUpdateData == null) { return; } OnUpdateData(info); }