public static void RegisterAgentFactory(AgentFactory agentFactory)
{
IDiagnosable diagnosable = agentFactory as IDiagnosable;
if (diagnosable != null)
{
ProcessAccessManager.RegisterComponent(diagnosable);
}
}
protected override void InternalDispose(bool disposing)
{
if (disposing)
{
if (this.RegisteredDiagnosable != null)
{
ProcessAccessManager.UnregisterComponent(this.RegisteredDiagnosable);
}
this.RegisteredDiagnosable = null;
}
}
internal static void UnRegisterDiagnosticsComponents(IDiagnosable component)
{
if (component != null)
{
try
{
ProcessAccessManager.UnregisterComponent(component);
}
catch (RpcException ex)
{
ExTraceGlobals.CommonTracer.TraceError <string>(0L, "ExchangeDiagnosticsHelper::UnRegisterDiagnosticsComponents. Exception:{0}", ex.ToString());
}
}
}
public static void RegisterComponent(IDiagnosable diagnosable)
{
if (diagnosable == null)
{
throw new ArgumentNullException("diagnosable");
}
string diagnosticComponentName = diagnosable.GetDiagnosticComponentName();
if (string.IsNullOrEmpty(diagnosticComponentName))
{
throw new ArgumentNullException("diagnosable.GetDiagnosticComponentName()");
}
lock (ProcessAccessManager.RpcServerLockObject)
{
ProcessAccessManager.diagnosableComponents[diagnosticComponentName] = diagnosable;
if (ProcessAccessManager.RpcServer == null)
{
ObjectSecurity serverAdminSecurity = ProcessAccessManager.GetServerAdminSecurity();
if (serverAdminSecurity != null)
{
using (Process currentProcess = Process.GetCurrentProcess())
{
string annotation;
if (string.Equals(currentProcess.ProcessName, "w3wp", StringComparison.InvariantCultureIgnoreCase))
{
annotation = currentProcess.Id + '\t' + Environment.GetEnvironmentVariable("APP_POOL_ID", EnvironmentVariableTarget.Process);
}
else
{
annotation = currentProcess.Id + '\t' + currentProcess.ProcessName;
}
ProcessAccessManager.RpcServer = (ProcessAccessManager)ProcessAccessRpcServer.RegisterServer(typeof(ProcessAccessManager), serverAdminSecurity, 1, Guid.NewGuid(), annotation, false, 8U);
}
}
}
}
}
internal static void RegisterDiagnosticsComponents(IDiagnosable instance)
{
if (instance != null)
{
try
{
ProcessAccessManager.RegisterComponent(instance);
}
catch (RpcException ex)
{
FaultDiagnosticsComponent faultDiagnosticsComponent = new FaultDiagnosticsComponent();
faultDiagnosticsComponent.SetComponentNameAndMessage(instance.GetDiagnosticComponentName(), -998, ex.ToString());
ExTraceGlobals.CommonTracer.TraceError <string>(0L, "ExchangeDiagnosticsHelper::RegisterDiagnosticsComponents Exception:{0}", ex.ToString());
try
{
ProcessAccessManager.RegisterComponent(faultDiagnosticsComponent);
}
catch (RpcException ex2)
{
ExTraceGlobals.CommonTracer.TraceError <string>(0L, "ExchangeDiagnosticsHelper::RegisterDiagnosticsComponents Exception while registering FaultDiagnosticsComponent. {0}", ex2.ToString());
}
}
}
}
public ExchangeDiagnostics(IDiagnosable diagnosable)
{
ProcessAccessManager.RegisterComponent(diagnosable);
this.RegisteredDiagnosable = diagnosable;
}
private static string RunComponentCommand(string componentName, DiagnosableParameters componentParameters)
{
XDocument xdocument = new XDocument();
XElement xelement = new XElement("Diagnostics");
xdocument.Add(xelement);
if (string.Equals(componentName, "ProcessLocator", StringComparison.OrdinalIgnoreCase))
{
XElement xelement2 = new XElement("ProcessLocator");
xelement.Add(xelement2);
List <KeyValuePair <Guid, string> > registeredProcessGuids = ProcessAccessRpcServer.GetRegisteredProcessGuids();
int num = 0;
if (string.Equals(componentParameters.Argument, "debug", StringComparison.OrdinalIgnoreCase))
{
using (List <KeyValuePair <Guid, string> > .Enumerator enumerator = registeredProcessGuids.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <Guid, string> pair = enumerator.Current;
ProcessAccessManager.AddAsXmlElement(xelement2, pair);
num++;
}
goto IL_117;
}
}
HashSet <string> hashSet = new HashSet <string>(registeredProcessGuids.Count);
foreach (KeyValuePair <Guid, string> pair2 in registeredProcessGuids)
{
if (pair2.Key != ProcessAccessRpcServer.ProcessLocatorGuid && !hashSet.Contains(pair2.Value))
{
ProcessAccessManager.AddAsXmlElement(xelement2, pair2);
num++;
hashSet.Add(pair2.Value);
}
}
IL_117:
xelement2.AddFirst(new XElement("count", num));
}
else
{
using (Process currentProcess = Process.GetCurrentProcess())
{
DateTime dateTime = currentProcess.StartTime.ToUniversalTime();
DateTime utcNow = DateTime.UtcNow;
XElement content = new XElement("ProcessInfo", new object[]
{
new XElement("id", currentProcess.Id),
new XElement("serverName", Environment.MachineName),
new XElement("startTime", dateTime),
new XElement("currentTime", utcNow),
new XElement("lifetime", (utcNow - dateTime).ToString()),
new XElement("threadCount", currentProcess.Threads.Count),
new XElement("handleCount", currentProcess.HandleCount),
new XElement("workingSet", ByteQuantifiedSize.FromBytes((ulong)currentProcess.WorkingSet64))
});
xelement.Add(content);
}
bool flag = string.IsNullOrEmpty(componentName);
bool flag2 = componentName == "?";
if (!flag2 && !flag && !ProcessAccessManager.diagnosableComponents.ContainsKey(componentName))
{
XElement content2 = new XElement(componentName, new XElement("message", string.Format("Component \"{0}\" is not supported by this process.", componentName)));
xelement.Add(content2);
flag2 = true;
}
XElement xelement3 = new XElement("Components");
xelement.Add(xelement3);
lock (ProcessAccessManager.RpcServerLockObject)
{
if (flag)
{
using (IEnumerator <KeyValuePair <string, IDiagnosable> > enumerator3 = ProcessAccessManager.diagnosableComponents.GetEnumerator())
{
while (enumerator3.MoveNext())
{
KeyValuePair <string, IDiagnosable> keyValuePair = enumerator3.Current;
xelement3.Add(keyValuePair.Value.GetDiagnosticInfo(componentParameters));
}
goto IL_3C2;
}
}
if (flag2)
{
using (IEnumerator <KeyValuePair <string, IDiagnosable> > enumerator4 = ProcessAccessManager.diagnosableComponents.GetEnumerator())
{
while (enumerator4.MoveNext())
{
KeyValuePair <string, IDiagnosable> keyValuePair2 = enumerator4.Current;
xelement3.Add(new XElement("Component", keyValuePair2.Key));
}
goto IL_3C2;
}
}
IDiagnosable diagnosable = ProcessAccessManager.diagnosableComponents[componentName];
XElement diagnosticInfo = diagnosable.GetDiagnosticInfo(componentParameters);
xelement3.Add(diagnosticInfo);
IL_3C2 :;
}
}
string result;
try
{
using (StringWriter stringWriter = new StringWriter())
{
using (XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter))
{
xmlTextWriter.Formatting = Formatting.None;
xdocument.Save(xmlTextWriter);
}
result = stringWriter.ToString();
}
}
catch (XmlException ex)
{
foreach (XElement xelement4 in xdocument.Descendants())
{
ex.Data[xelement4.Name] = xelement4.Value;
}
throw;
}
return(result);
}
public override byte[] RunProcessCommand(byte[] inBlob)
{
string componentName = null;
string argument = null;
bool allowRestrictedData = false;
bool unlimited = false;
string userIdentity = null;
string text = null;
MdbefPropertyCollection mdbefPropertyCollection = MdbefPropertyCollection.Create(inBlob, 0, inBlob.Length);
object obj;
if (mdbefPropertyCollection.TryGetValue(2466316319U, out obj) && obj is string)
{
argument = (string)obj;
}
if (mdbefPropertyCollection.TryGetValue(2466250783U, out obj) && obj is string)
{
componentName = (string)obj;
}
if (mdbefPropertyCollection.TryGetValue(2466381835U, out obj) && obj is bool)
{
allowRestrictedData = (bool)obj;
}
if (mdbefPropertyCollection.TryGetValue(2466512907U, out obj) && obj is bool)
{
unlimited = (bool)obj;
}
if (mdbefPropertyCollection.TryGetValue(2466447391U, out obj) && obj is string)
{
userIdentity = (string)obj;
}
try
{
DiagnosableParameters componentParameters = DiagnosableParameters.Create(argument, allowRestrictedData, unlimited, userIdentity);
text = ProcessAccessManager.RunComponentCommand(componentName, componentParameters);
}
catch (XmlException ex)
{
StringBuilder stringBuilder = new StringBuilder(100 * ex.Data.Count);
foreach (object obj2 in ex.Data)
{
KeyValuePair <object, object> keyValuePair = (KeyValuePair <object, object>)obj2;
stringBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}:{1}{2}", new object[]
{
keyValuePair.Key,
keyValuePair.Value,
Environment.NewLine
});
}
text = string.Format(CultureInfo.InvariantCulture, "Message={0}{1}Data={2}{1}Stack={3}", new object[]
{
ex.Message,
Environment.NewLine,
stringBuilder,
ex.StackTrace
});
}
catch (Exception ex2)
{
text = ex2.ToString();
}
MdbefPropertyCollection mdbefPropertyCollection2 = new MdbefPropertyCollection();
if (text != null)
{
mdbefPropertyCollection2.Add(2471559199U, text);
}
return(mdbefPropertyCollection2.GetBytes());
}
public static string ClientRunProcessCommand(string server, string process, string componentName, string componentArgument, bool componentRestrictedData, bool componentUnlimited, string userIdentity)
{
if (string.IsNullOrEmpty(server))
{
server = Environment.MachineName;
}
string result;
try
{
string text;
try
{
text = ProcessAccessManager.ClientRunProcessCommand(server, ProcessAccessRpcServer.ProcessLocatorGuid, "ProcessLocator", null, false, false, null);
}
catch (RpcException rpcException)
{
return(ProcessAccessManager.ReturnFromRpcException(server, "Query registered processes", rpcException));
}
if (text == null)
{
result = new XElement("Diagnostics", new XElement("error", string.Format("No processes have registered on {0} to support this task.", server))).ToString(SaveOptions.DisableFormatting);
}
else
{
XDocument xdocument;
try
{
xdocument = XDocument.Parse(text);
}
catch (XmlException)
{
return(new XElement("Diagnostics", new object[]
{
new XElement("error", "Xml parsing error"),
new XElement("failedXml", text)
}).ToString(SaveOptions.DisableFormatting));
}
XElement root = xdocument.Root;
XElement xelement = root.Element("ProcessLocator");
if (string.IsNullOrEmpty(process))
{
result = root.ToString(SaveOptions.DisableFormatting);
}
else
{
Guid processGuid = Guid.Empty;
int num = 0;
foreach (XElement xelement2 in xelement.Elements("Process"))
{
Guid guid;
if (GuidHelper.TryParseGuid(xelement2.Element("guid").Value, out guid))
{
if (string.Equals(xelement2.Element("id").Value, process, StringComparison.OrdinalIgnoreCase))
{
processGuid = guid;
num++;
}
else if (string.Equals(xelement2.Element("name").Value, process, StringComparison.OrdinalIgnoreCase))
{
processGuid = guid;
num++;
}
}
}
if (num < 1)
{
xelement.AddFirst(new XElement("error", string.Format("Specified process is not registered. Currently registered on {0}.", server)));
result = root.ToString(SaveOptions.DisableFormatting);
}
else if (num > 1)
{
xelement.AddFirst(new XElement("error", string.Format("Specified process matches more than one registered process on {0}.", server)));
result = root.ToString(SaveOptions.DisableFormatting);
}
else
{
try
{
result = ProcessAccessManager.ClientRunProcessCommand(server, processGuid, componentName, componentArgument, componentRestrictedData, componentUnlimited, userIdentity);
}
catch (RpcException rpcException2)
{
result = ProcessAccessManager.ReturnFromRpcException(server, "Query process diagnostics", rpcException2);
}
}
}
}
}
catch (Exception arg)
{
result = new XElement("Diagnostics", new XElement("error", string.Format("ProcessAccessManager Exception: {0}", arg))).ToString(SaveOptions.DisableFormatting);
}
return(result);
}
