private void StartListeners() { DebugTrace.TraceEnter(this, "StartListeners"); try { this.twoPhaseCommitCoordinatorListener.Start(); this.twoPhaseCommitParticipantListener.Start(); this.completionCoordinatorListener.Start(); this.registrationCoordinatorListener.Start(); this.activationCoordinatorListener.Start(); } catch (MessagingInitializationException exception) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Error starting a listener: {0}", exception); } this.CleanupOnFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new PluggableProtocolException(exception.Message, exception)); } catch (Exception exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error); if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Unknown exception starting a listener: {0}", exception2); } this.CleanupOnFailure(); throw; } DebugTrace.TraceLeave(this, "StartListeners"); }
public void SendReadOnly(EndpointAddress sendTo) { if (sendTo != null) { TwoPhaseCommitCoordinatorProxy proxy = this.state.TryCreateTwoPhaseCommitCoordinatorProxy(sendTo); if (proxy != null) { try { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending ReadOnly to unrecognized participant at {0}", Ports.TryGetAddress(proxy)); } IAsyncResult ar = proxy.BeginSendReadOnly(this.politeSendComplete, proxy); if (ar.CompletedSynchronously) { this.OnPoliteSendComplete(ar, proxy); } } finally { proxy.Release(); } } } }
public void bindui(Action <IUI, Variant> cb, Variant data) { if (m_bindFlag) { return; } if (g_mgr.showLoading(this)) { onLoading(); } BaseLGUI thisptr = this; m_bindFlag = true; g_mgr.getUI( this.uiName, (IUI u, Variant info) => { onLoadingEnd(); if (u == null) { DebugTrace.add(Define.DebugTrace.DTT_ERR, " bindui [" + uiName + "] Err! "); return; } m_uiF = u; m_uiF.setCtrl(thisptr); init(); cb(u, info); }, data ); }
public PerformanceCounterWrapper(string counterName) { Exception exception; string categoryName = "MSDTC Bridge 4.0.0.0"; try { this.counter = new PerformanceCounter(categoryName, counterName, string.Empty, false); this.counter.RemoveInstance(); this.counter = new PerformanceCounter(categoryName, counterName, string.Empty, false); exception = null; } catch (InvalidOperationException exception2) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); exception = exception2; } catch (Win32Exception exception3) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); exception = exception3; } if (exception != null) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Unable to initialize performance counter {0}: {1}", counterName, exception); } PerformanceCounterInitializationFailureRecord.TraceAndLog(PluggableProtocol10.ProtocolGuid, counterName, exception); } }
protected void VerifyAndTraceEnlistmentOptions() { Microsoft.Transactions.Bridge.EnlistmentOptions enlistmentOptions = this.enlistment.EnlistmentOptions; if (enlistmentOptions == null) { DiagnosticUtility.FailFast("Need EnlistmentOptions for context"); } if (enlistmentOptions.IsoLevel == IsolationLevel.Unspecified) { DiagnosticUtility.FailFast("Need IsolationLevel for context"); } if (this.enlistment.LocalTransactionId == Guid.Empty) { DiagnosticUtility.FailFast("Need LocalTransactionId for context"); } if (string.IsNullOrEmpty(this.enlistment.RemoteTransactionId)) { DiagnosticUtility.FailFast("Need RemoteTransactionId for context"); } if (DebugTrace.Info) { DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Local transactionId is {0}", this.enlistment.LocalTransactionId); DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Remote transactionId is {0}", this.enlistment.RemoteTransactionId); DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Transaction timeout is {0} seconds", enlistmentOptions.Expires.TotalSeconds); DebugTrace.TxTrace(TraceLevel.Info, this.enlistmentId, "Transaction isolation level is {0}", enlistmentOptions.IsoLevel); } }
private string CreateDirectoryForAssociatedImage(string imageName) { pathBuilder.Clear(); pathBuilder.Append(outDirectory).Append("/").Append(imageName).Append(".").Append(format); DebugTrace.Leave(pathBuilder.ToString()); return(pathBuilder.ToString()); }
public void Rejoin(Enlistment enlistment, ProtocolProviderCallback callback, object obj) { DebugTrace.TraceEnter(this, "Rejoin"); ParticipantEnlistment participant = null; try { participant = this.state.LogEntrySerialization.DeserializeParticipant(enlistment); } catch (SerializationException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Critical); if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Failed to deserialize log entry for participant: {0}", exception); } ParticipantRecoveryLogEntryCorruptRecord.TraceAndLog(enlistment.LocalTransactionId, enlistment.RemoteTransactionId, enlistment.GetRecoveryData(), exception); DiagnosticUtility.FailFast("A participant recovery log entry could not be deserialized. This is a fatal condition."); } if (ParticipantRecoveredRecord.ShouldTrace) { ParticipantRecoveredRecord.Trace(participant.EnlistmentId, participant.Enlistment.RemoteTransactionId, (participant.ParticipantProxy != null) ? participant.ParticipantProxy.To : null, this.state.ProtocolVersion); } participant.StateMachine.Enqueue(new TmRejoinEvent(participant, callback, obj)); DebugTrace.TraceLeave(this, "Rejoin"); }
public void mode_clanpt(int value) { bool flag = this._netData["clan_pt"] >= 0; if (flag) { Variant variant = this._netData; variant["clan_pt"] = variant["clan_pt"] + value; } else { this._netData["clan_pt"] = value; } bool flag2 = value > 0; if (flag2) { this._msgStr = LanguagePack.getLanguageText("LGUIItemImpl", "getClanPt"); } else { this._msgStr = LanguagePack.getLanguageText("LGUIItemImpl", "loseClanPt"); value = -value; } this._msgStr = DebugTrace.Printf(this._msgStr, new string[] { value.ToString() }); this.lgMainui.systemmsg(this._msgStr, 12u); }
public void change_meript(int value) { int meript = this.meript; int num = value - meript; bool flag = num > 0; if (flag) { this._msgStr = LanguagePack.getLanguageText("LGUIItemImpl", "getStarSoul"); } else { bool flag2 = num < 0; if (flag2) { this._msgStr = LanguagePack.getLanguageText("LGUIItemImpl", "loseStarSoul"); num = -num; } } this._msgStr = DebugTrace.Printf(this._msgStr, new string[] { num.ToString() }); this.lgMainui.systemmsg(this._msgStr, 12u); this.meript = value; }
private void dgOrchestration_SelectionChanged(object sender, EventArgs e) { this.dgDebugShapes.Rows.Clear(); if (this.dgOrchestration.SelectedRows.Count > 0) { this.dgDebugShapes.Enabled = true; this.btnGenerate.Enabled = true; string serviceName = (string)this.dgOrchestration.SelectedRows[0].Cells["ServiceName"].Value; string debugSymbols = (string)this.dgOrchestration.SelectedRows[0].Cells["DebugSymbols"].Value; DebugTrace trace = BTSOrchestrationExplorer.GetDebugTrace(serviceName, debugSymbols, FlatteningPrefixType.Indentation); foreach (DebugShape shape in trace.TraceDetails) { this.dgDebugShapes.Rows.Add( shape.shapeText, shape.shapeType.ToString(), "true", "true", "1", shape.ShapeID.ToString()); } } }
private X509Certificate2 ReadX509CertificateIdentity(ConfigurationProvider provider) { X509Certificate2 certificate; string thumbprint = provider.ReadString("X509CertificateIdentity", null); if (thumbprint == null) { certificate = null; DebugTrace.Trace(TraceLevel.Warning, "{0} value could not be read", "X509CertificateIdentity"); return(certificate); } certificate = this.FindCertificateByThumbprint(thumbprint); if (certificate == null) { ThumbPrintNotFoundRecord.TraceAndLog(thumbprint); DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with thumbprint {0} could not be found", thumbprint); return(certificate); } if (!this.ValidateIdentityCertificate(certificate)) { ThumbPrintNotValidatedRecord.TraceAndLog(thumbprint); DebugTrace.Trace(TraceLevel.Warning, "Identity certificate with thumbprint {0} could not be validated", thumbprint); certificate = null; } return(certificate); }
private void OnSendRegisterComplete(CoordinatorEnlistment coordinator, ControlProtocol protocol, IAsyncResult ar) { SynchronizationEvent event2; EndpointAddress to = null; try { RegisterResponse response = coordinator.RegistrationProxy.EndSendRegister(ar); to = response.CoordinatorProtocolService; TwoPhaseCommitCoordinatorProxy proxy = this.state.TryCreateTwoPhaseCommitCoordinatorProxy(to); if (proxy == null) { if (RegistrationCoordinatorResponseInvalidMetadataRecord.ShouldTrace) { RegistrationCoordinatorResponseInvalidMetadataRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, to, null, this.state.ProtocolVersion); } event2 = new MsgRegistrationCoordinatorSendFailureEvent(coordinator); } else { try { if (protocol == ControlProtocol.Durable2PC) { event2 = new MsgRegisterDurableResponseEvent(coordinator, response, proxy); } else { VolatileCoordinatorEnlistment asyncState = (VolatileCoordinatorEnlistment)ar.AsyncState; event2 = new MsgRegisterVolatileResponseEvent(asyncState, response, proxy); } } finally { proxy.Release(); } } } catch (WsatFaultException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); event2 = new MsgRegistrationCoordinatorFaultEvent(coordinator, protocol, exception.Fault); if (RegistrationCoordinatorFaultedRecord.ShouldTrace) { RegistrationCoordinatorFaultedRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, exception.Fault); } } catch (WsatMessagingException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); this.state.Perf.MessageSendFailureCountPerInterval.Increment(); if (RegistrationCoordinatorFailedRecord.ShouldTrace) { RegistrationCoordinatorFailedRecord.Trace(coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, exception2); } DebugTrace.TraceSendFailure(coordinator.EnlistmentId, exception2); event2 = new MsgRegistrationCoordinatorSendFailureEvent(coordinator); } coordinator.StateMachine.Enqueue(event2); }
public void Handle(object model) { // Find the full path to the template file, // using current directory if argument isn't fully qualified string templatePath = GetTemplatePath(); DebugTrace.Trace(this, "Rendering:" + templatePath); DebugTrace.Trace(this, "Model:" + model.ToString()); var templateName = Path.GetFileName(templatePath); var templateDirPath = Path.GetDirectoryName(templatePath); SparkViewEngine engine = new SparkEngineFactory().GetSparkEngine <TView>(templateDirPath); try { // compile and instantiate the template string templateResult = ProcessViewTemplate(engine, templateName, model); _fileWriter.Write(templateResult); } catch (Exception ex) { throw new SparkReportGenerationException("An exception occurred:" + ex.GetType().Name + "\r\n" + ex.Message, ex); } }
private void StopListeners() { DebugTrace.TraceEnter(this, "StopListeners"); if (this.twoPhaseCommitCoordinatorListener != null) { this.twoPhaseCommitCoordinatorListener.Stop(); this.twoPhaseCommitCoordinatorListener = null; } if (this.twoPhaseCommitParticipantListener != null) { this.twoPhaseCommitParticipantListener.Stop(); this.twoPhaseCommitParticipantListener = null; } if (this.completionCoordinatorListener != null) { this.completionCoordinatorListener.Stop(); this.completionCoordinatorListener = null; } if (this.registrationCoordinatorListener != null) { this.registrationCoordinatorListener.Stop(); this.registrationCoordinatorListener = null; } if (this.activationCoordinatorListener != null) { this.activationCoordinatorListener.Stop(); this.activationCoordinatorListener = null; } if (this.coordination != null) { this.coordination.Cleanup(); this.coordination = null; } DebugTrace.TraceLeave(this, "StopListeners"); }
public void Remove(ITimerRecipient recipient) { int count; int num2; DebugTrace.TraceEnter(this, "Remove"); lock (this.timerList.SyncRoot) { this.AssertState(); count = this.timerList.Count; this.timerList.Remove(recipient); num2 = this.timerList.Count; if ((count != num2) && (this.timerList.Count == 0)) { this.DeactivateTimer(); } } if (DebugTrace.Verbose) { if (count == num2) { DebugTrace.Trace(TraceLevel.Verbose, "Timer recipient was not present. Timer list depth is still {0}", num2); } else { DebugTrace.Trace(TraceLevel.Verbose, "Removed timer recipient. Timer list depth is now {0}", num2); } } DebugTrace.TraceLeave(this, "Remove"); }
public void bindui(Action <IUI, Variant> cb, Variant data) { bool bindFlag = this.m_bindFlag; if (!bindFlag) { bool flag = this.g_mgr.showLoading(this); if (flag) { this.onLoading(); } BaseLGUI thisptr = this; this.m_bindFlag = true; this.g_mgr.getUI(this.uiName, delegate(IUI u, Variant info) { this.onLoadingEnd(); bool flag2 = u == null; if (flag2) { DebugTrace.add(Define.DebugTrace.DTT_ERR, " bindui [" + this.uiName + "] Err! "); } else { this.m_uiF = u; this.m_uiF.setCtrl(thisptr); this.init(); cb(u, info); } }, data); } }
public void Add(ITimerRecipient recipient, object token) { int count; DebugTrace.TraceEnter(this, "Add"); TimeSpan span = recipient.NextNotification - this.state.ElapsedTime; if ((span <= TimeSpan.Zero) || (span >= this.maxNotificationTime)) { DiagnosticUtility.FailFast("The timer object has an invalid notification time"); } lock (this.timerList.SyncRoot) { this.AssertState(); this.timerList.Add(recipient, token); count = this.timerList.Count; if (count == 1) { this.ActivateTimer(); } } if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Added timer recipient to be reminded in {0} ms", (long)span.TotalMilliseconds); DebugTrace.Trace(TraceLevel.Verbose, "Timer list depth at {0}", count); } DebugTrace.TraceLeave(this, "Add"); }
public static void POSTSvrstr(string query, string param, Action <string> cb, bool rcvJSONHandler = true, string method = "POST") { bool flag = query == null || query == "" || cb == null; if (!flag) { IURLReq iURLReq = os.net.CreateURLReq(null); iURLReq.url = query; iURLReq.contentType = "application/x-www-form-urlencoded"; iURLReq.dataFormat = "text"; string text = ""; text += param; debug.Log(" POSTSvr query:" + query + "\n param:" + param); iURLReq.data = text; iURLReq.method = method; iURLReq.load(delegate(IURLReq r, object vari) { bool flag2 = vari == null; if (flag2) { DebugTrace.print(" POSTSvr urlReq.load vari Null!"); } string text2 = vari as string; DebugTrace.print(" POSTSvr urlReq.loaded str[" + text2 + "]!"); Variant variant = JsonManager.StringToVariant(text2, true); bool flag3 = cb != null; if (flag3) { cb(text2); } }, null, null); } }
public void WriteToFile(string name) { string imagePath = CreateDirectoryForAssociatedImage(name); try { using (var associatedBmp = osr.GetAssociatedImage(name)) { EncoderParameters qualityParameter = GetQualityEncoderParameter(); ImageCodecInfo formatEncoder; switch (format) { case "png": formatEncoder = GetEncoder(ImageFormat.Png); break; case "jpeg": formatEncoder = GetEncoder(ImageFormat.Jpeg); break; default: formatEncoder = GetEncoder(ImageFormat.Bmp); break; } associatedBmp.Save(imagePath, formatEncoder, qualityParameter); DebugTrace.Leave("File " + name + " succesfully saved."); } } catch (Exception) { DebugTrace.Leave("There was a problem saving the file. \nCheck the file permissions."); } }
public IObjectPlugin createInst(string name, bool single) { bool flag = !this.m_creators.ContainsKey(name); IObjectPlugin result; if (flag) { DebugTrace.print("err gameManagerBase createInst [" + name + "] notExsit!"); result = null; } else { bool flag2 = single && this.m_objectPlugins.ContainsKey(name); if (flag2) { DebugTrace.print("err gameManagerBase createInst single [" + name + "] repeated!"); result = this.m_objectPlugins[name]; } else { Func <IClientBase, IObjectPlugin> func = this.m_creators[name]; IObjectPlugin objectPlugin = func(this); objectPlugin.controlId = name; if (single) { base.regEventDispatcher(name, objectPlugin as IGameEventDispatcher); this.m_objectPlugins[name] = objectPlugin; } result = objectPlugin; } } return(result); }
public void Replay(Enlistment enlistment, ProtocolProviderCallback callback, object obj) { DebugTrace.TraceEnter(this, "Replay"); CoordinatorEnlistment coordinator = null; try { coordinator = this.state.LogEntrySerialization.DeserializeCoordinator(enlistment); } catch (SerializationException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Critical); if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Failed to deserialize log entry for coordinator: {0}", exception); } CoordinatorRecoveryLogEntryCorruptRecord.TraceAndLog(enlistment.LocalTransactionId, enlistment.RemoteTransactionId, enlistment.GetRecoveryData(), exception); DiagnosticUtility.FailFast("A coordinator recovery log entry could not be deserialized. This is a fatal condition."); } if (CoordinatorRecoveredRecord.ShouldTrace) { CoordinatorRecoveredRecord.Trace(coordinator.EnlistmentId, coordinator.Enlistment.RemoteTransactionId, (coordinator.CoordinatorProxy != null) ? coordinator.CoordinatorProxy.To : null, this.state.ProtocolVersion); } coordinator.StateMachine.Enqueue(new TmReplayEvent(coordinator, callback, obj)); DebugTrace.TraceLeave(this, "Replay"); }
public LineStatus ExecuteLine(Scenario scenario, ScenarioContext scenarioContext, string line) { DebugTrace.Trace("ScenarioLineExecter.ExecuteLine", line); InvocationChain chain = GetMatchingChain(scenarioContext, line); if (chain == null) { var suggestion = _implementationHelper.Suggest(line); _eventBus.Raise(new LinePending { Scenario = scenario, Line = line, Suggestion = suggestion }); return(LineStatus.Pending); } if (!ExecuteChain(scenario, scenarioContext, chain, line)) { return(LineStatus.Failed); } _eventBus.Raise(new LinePassed { Scenario = scenario, Line = line }); return(LineStatus.Passed); }
public override void OnEvent(MsgDurablePrepareEvent e) { CoordinatorEnlistment coordinator = e.Coordinator; Exception exception = null; try { byte[] data = base.state.LogEntrySerialization.Serialize(coordinator); coordinator.Enlistment.SetRecoveryData(data); base.state.TransactionManagerSend.Prepare(coordinator); e.StateMachine.ChangeState(base.state.States.CoordinatorPreparing); } catch (SerializationException exception2) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error); exception = exception2; } if (exception != null) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Failed to serialize log entry for coordinator: {0}", exception); } CoordinatorRecoveryLogEntryCreationFailureRecord.TraceAndLog(coordinator.EnlistmentId, coordinator.Enlistment.RemoteTransactionId, exception.Message, exception); base.state.TwoPhaseCommitParticipant.SendDurableAborted(coordinator); base.state.TransactionManagerSend.Rollback(coordinator); e.StateMachine.ChangeState(base.state.States.DurableAborted); } }
public void SendRollback(EndpointAddress sendTo) { if (sendTo != null) { TwoPhaseCommitParticipantProxy proxy = this.state.TryCreateTwoPhaseCommitParticipantProxy(sendTo); if (proxy != null) { try { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending Rollback to unrecognized participant at {0}", Ports.TryGetAddress(proxy)); } proxy.From = this.CreateForgottenSource(); IAsyncResult ar = proxy.BeginSendRollback(this.politeSendComplete, proxy); if (ar.CompletedSynchronously) { this.OnPoliteSendComplete(ar, proxy); } } finally { proxy.Release(); } } } }
public void init(string server_config_url, string server_ip, uint server_id, uint port, uint uid, uint clnt, string token, string mainConfig) { LGPlatInfo.inst.firstAnalysisPoint(server_id, uid); gameST.loadBaseData(); DebugTrace.Printf(os.sys.windowWidth + "," + os.sys.windowHeight, new string[0]); Variant variant = new Variant(); variant["server_config_url"] = server_config_url; variant["server_id"] = server_id; variant["mainConfig"] = mainConfig; variant["outgamevar"] = new Variant(); variant["outgamevar"]["server_ip"] = server_ip; variant["outgamevar"]["server_port"] = port; variant["outgamevar"]["uid"] = uid; variant["outgamevar"]["token"] = token; variant["outgamevar"]["clnt"] = clnt; debug.Log("初始化进来.............0000000000000000"); bool flag = this.main == null; if (flag) { this.main = new MuMain(); } this.main.init(variant); debug.Log("初始化进来.............1111111111111111"); }
public void on_mod_exp(Variant info) { this.data["exp"]._int += info["mod_exp"]; int num = info["mod_exp"]; string languageText = LanguagePack.getLanguageText("LGUIItemImpl", "getExp"); string languageText2 = LanguagePack.getLanguageText("LGUIItemImpl", "loseExp"); bool flag = num > 0; string val; if (flag) { val = DebugTrace.Printf(languageText, new string[] { num.ToString() }); } else { val = DebugTrace.Printf(languageText2, new string[] { Math.Abs(num).ToString() }); } Variant variant = new Variant(); variant.pushBack(val); }
public void SendCommitted(EndpointAddress sendTo) { if (sendTo != null) { CompletionParticipantProxy proxy = this.state.TryCreateCompletionParticipantProxy(sendTo); if (proxy != null) { try { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Sending Committed to unrecognized completion participant at {0}", Ports.TryGetAddress(proxy)); } IAsyncResult ar = proxy.BeginSendCommitted(this.politeSendComplete, proxy); if (ar.CompletedSynchronously) { this.OnSendComplete(ar, null, proxy); } } finally { proxy.Release(); } } } }
public IObjectPlugin createInst(string name, bool single) { if (!m_creators.ContainsKey(name)) { DebugTrace.print("err gameManagerBase createInst [" + name + "] notExsit!"); return(null); } if (single && m_objectPlugins.ContainsKey(name)) { DebugTrace.print("err gameManagerBase createInst single [" + name + "] repeated!"); return(m_objectPlugins[name] as IObjectPlugin); } Func <IClientBase, IObjectPlugin> create = m_creators[name]; IObjectPlugin obj = create(this); obj.controlId = name; if (single) { regEventDispatcher(name, obj as IGameEventDispatcher); m_objectPlugins[name] = obj; } return(obj); }
public void Stop() { DebugTrace.TraceVerbose("Stop called by: \r\n" + new StackTrace(1, true).ToString()); if (playerThread != null) { if (playerThread.IsAlive) { running = false; isRecording = false; DebugTrace.TraceInfo("Camera stop request sent. Waiting ..."); playerThread.Join(500); if (playerThread.IsAlive) { DebugTrace.TraceWarning("Killing camera thread"); playerThread.Abort(); playerThread.Join(); } } playerThread = null; } }
public void RecoveryBeginning() { DebugTrace.TraceEnter(this, "RecoveryBeginning"); if (this.config.NetworkEndpointsEnabled) { try { this.coordination = new CoordinationService(this.config.PortConfiguration, this.protocolVersion); this.activationCoordinatorListener = this.coordination.Add(this.activationCoordinator); this.registrationCoordinatorListener = this.coordination.Add(this.registrationCoordinator); this.completionCoordinatorListener = this.coordination.Add(this.completionCoordinator); this.twoPhaseCommitCoordinatorListener = this.coordination.Add(this.twoPhaseCommitCoordinator); this.twoPhaseCommitParticipantListener = this.coordination.Add(this.twoPhaseCommitParticipant); } catch (MessagingInitializationException exception) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Error initializing CoordinationService: {0}", exception); } this.CleanupOnFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new PluggableProtocolException(exception.Message, exception)); } catch (Exception exception2) { if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Unknown exception initializing CoordinationService: {0}", exception2); } this.CleanupOnFailure(); throw; } } DebugTrace.TraceLeave(this, "RecoveryBeginning"); }