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");
}
