public void TestLargeSharedMemorySend()
{
string name = Guid.NewGuid().ToString();
// Create the shared memory buffer
SharedMemory readSharedMemory =
new SharedMemory
(
name,
SharedMemoryType.ReadOnly,
true
);
SharedMemory writeSharedMemory =
new SharedMemory
(
name,
SharedMemoryType.WriteOnly,
true
);
DualQueue <LocalCallDescriptor> queue = new DualQueue <LocalCallDescriptor>();
DualQueue <LocalCallDescriptor> hiPriQueue = new DualQueue <LocalCallDescriptor>();
int numberOfEvents = 2500;
LocalCallDescriptorForPostLoggingMessagesToHost LargeLogEvent = CreatePostMessageCallDescriptor(numberOfEvents);
queue.Enqueue(LargeLogEvent);
writeSharedMemory.Write(queue, hiPriQueue, false);
IList localCallDescriptorList = readSharedMemory.Read();
while (localCallDescriptorList == null || localCallDescriptorList.Count == 0)
{
writeSharedMemory.Write(queue, hiPriQueue, false);
localCallDescriptorList = readSharedMemory.Read();
}
VerifyPostMessagesToHost((LocalCallDescriptorForPostLoggingMessagesToHost)localCallDescriptorList[0], numberOfEvents);
writeSharedMemory.Reset();
readSharedMemory.Reset();
readSharedMemory = null;
writeSharedMemory = null;
}
public void TestHiPrioritySend()
{
string name = Guid.NewGuid().ToString();
// Create the shared memory buffer
SharedMemory readSharedMemory =
new SharedMemory
(
name,
SharedMemoryType.ReadOnly,
true
);
SharedMemory writeSharedMemory =
new SharedMemory
(
name,
SharedMemoryType.WriteOnly,
true
);
DualQueue <LocalCallDescriptor> queue = new DualQueue <LocalCallDescriptor>();
DualQueue <LocalCallDescriptor> hiPriQueue = new DualQueue <LocalCallDescriptor>();
int numberOfEvents = 20;
LocalCallDescriptorForPostLoggingMessagesToHost LargeLogEvent = CreatePostMessageCallDescriptor(numberOfEvents);
queue.Enqueue(LargeLogEvent);
LocalCallDescriptorForPostStatus nodeStatusExcept = new LocalCallDescriptorForPostStatus(new NodeStatus(new Exception("I am bad")));
hiPriQueue.Enqueue(nodeStatusExcept);
writeSharedMemory.Write(queue, hiPriQueue, true);
IList localCallDescriptorList = readSharedMemory.Read();
Assert.IsTrue(localCallDescriptorList.Count == 2);
VerifyNodeStatus2((LocalCallDescriptorForPostStatus)localCallDescriptorList[0]);
VerifyPostMessagesToHost((LocalCallDescriptorForPostLoggingMessagesToHost)localCallDescriptorList[1], numberOfEvents);
writeSharedMemory.Reset();
readSharedMemory.Reset();
readSharedMemory = null;
writeSharedMemory = null;
}
private bool ReadEndpoint(string sharedMemoryName, out string listenerEndpoint)
{
bool flag;
try
{
if (SharedMemory.Read(sharedMemoryName, out listenerEndpoint))
{
return(true);
}
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, 0xa000e, System.ServiceModel.SR.GetString("TraceCodeSharedManagerServiceEndpointNotExist", new object[] { this.serviceName }), (Exception)null, (Message)null);
}
flag = false;
}
catch (Win32Exception exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.WrapEndpointReadingException(exception));
}
return(flag);
}
public void TestItemsInandOutOfSharedMemory()
{
string name = Guid.NewGuid().ToString();
// Create the shared memory buffer
SharedMemory readSharedMemory =
new SharedMemory
(
name,
SharedMemoryType.ReadOnly,
true
);
SharedMemory writeSharedMemory =
new SharedMemory
(
name,
SharedMemoryType.WriteOnly,
true
);
DualQueue <LocalCallDescriptor> queue = new DualQueue <LocalCallDescriptor>();
DualQueue <LocalCallDescriptor> hiPriQueue = new DualQueue <LocalCallDescriptor>();
LocalCallDescriptorForPostLoggingMessagesToHost LargeLogEvent = CreatePostMessageCallDescriptor(1);
LocalCallDescriptorForUpdateNodeSettings updateNodeSettings = new LocalCallDescriptorForUpdateNodeSettings(true, true, true);
LocalCallDescriptorForPostBuildResult buildResult = new LocalCallDescriptorForPostBuildResult(CreateBuildResult());
LocalCallDescriptorForPostBuildRequests buildRequests = new LocalCallDescriptorForPostBuildRequests(CreateBuildRequest());
LocalCallDescriptorForRequestStatus requestStatus = new LocalCallDescriptorForRequestStatus(4);
LocalCallDescriptorForPostStatus nodeStatusNoExcept = new LocalCallDescriptorForPostStatus(new NodeStatus(1, true, 2, 3, 4, true));
LocalCallDescriptorForPostStatus nodeStatusExcept = new LocalCallDescriptorForPostStatus(new NodeStatus(new Exception("I am bad")));
LocalCallDescriptorForShutdownNode shutdownNode = new LocalCallDescriptorForShutdownNode(Node.NodeShutdownLevel.BuildCompleteSuccess, true);
LocalCallDescriptorForShutdownComplete shutdownComplete = new LocalCallDescriptorForShutdownComplete(Node.NodeShutdownLevel.BuildCompleteFailure, 0);
LocalCallDescriptorForInitializationComplete initializeComplete = new LocalCallDescriptorForInitializationComplete(99);
BuildPropertyGroup propertyGroup = new BuildPropertyGroup();
BuildProperty propertyToAdd = new BuildProperty("PropertyName", "Value");
propertyGroup.SetProperty(propertyToAdd);
CacheEntry[] entries = CreateCacheEntries();
LocalCallDescriptorForGettingCacheEntriesFromHost getCacheEntries = new LocalCallDescriptorForGettingCacheEntriesFromHost(new string[] { "Hi", "Hello" }, "Name", propertyGroup, "3.5", CacheContentType.Properties);
LocalCallDescriptorForPostingCacheEntriesToHost postCacheEntries = new LocalCallDescriptorForPostingCacheEntriesToHost(entries, "ScopeName", propertyGroup, "3.5", CacheContentType.BuildResults);
LocalReplyCallDescriptor replyDescriptor1 = new LocalReplyCallDescriptor(1, entries);
LocalReplyCallDescriptor replyDescriptor2 = new LocalReplyCallDescriptor(6, "Foo");
IDictionary environmentVariables = Environment.GetEnvironmentVariables();
Hashtable environmentVariablesHashtable = new Hashtable(environmentVariables);
string className = "Class";
string loggerAssemblyName = "Class";
string loggerFileAssembly = null;
string loggerSwitchParameters = "Class";
LoggerVerbosity verbosity = LoggerVerbosity.Detailed;
LoggerDescription description = new LoggerDescription(className, loggerAssemblyName, loggerFileAssembly, loggerSwitchParameters, verbosity);
LocalCallDescriptorForInitializeNode initializeNode = new LocalCallDescriptorForInitializeNode(environmentVariablesHashtable, new LoggerDescription[] { description }, 4, propertyGroup, ToolsetDefinitionLocations.ConfigurationFile, 5, String.Empty);
queue.Enqueue(LargeLogEvent);
queue.Enqueue(updateNodeSettings);
queue.Enqueue(buildResult);
queue.Enqueue(buildRequests);
queue.Enqueue(requestStatus);
queue.Enqueue(nodeStatusNoExcept);
queue.Enqueue(nodeStatusExcept);
queue.Enqueue(shutdownNode);
queue.Enqueue(shutdownComplete);
queue.Enqueue(initializeComplete);
queue.Enqueue(getCacheEntries);
queue.Enqueue(postCacheEntries);
queue.Enqueue(replyDescriptor1);
queue.Enqueue(replyDescriptor2);
queue.Enqueue(initializeNode);
writeSharedMemory.Write(queue, hiPriQueue, false);
IList localCallDescriptorList = readSharedMemory.Read();
Assert.IsTrue(localCallDescriptorList.Count == 15);
LocalCallDescriptorForPostLoggingMessagesToHost messageCallDescriptor = localCallDescriptorList[0] as LocalCallDescriptorForPostLoggingMessagesToHost;
VerifyPostMessagesToHost(messageCallDescriptor, 1);
LocalCallDescriptorForUpdateNodeSettings updateSettingsCallDescriptor = localCallDescriptorList[1] as LocalCallDescriptorForUpdateNodeSettings;
VerifyUpdateSettings(updateSettingsCallDescriptor);
LocalCallDescriptorForPostBuildResult buildResultCallDescriptor = localCallDescriptorList[2] as LocalCallDescriptorForPostBuildResult;
CompareBuildResult(buildResultCallDescriptor);
LocalCallDescriptorForPostBuildRequests buildRequestsCallDescriptor = localCallDescriptorList[3] as LocalCallDescriptorForPostBuildRequests;
ComparebuildRequests(buildRequestsCallDescriptor);
LocalCallDescriptorForRequestStatus requestStatusCallDescriptor = localCallDescriptorList[4] as LocalCallDescriptorForRequestStatus;
Assert.IsTrue(requestStatusCallDescriptor.RequestId == 4);
LocalCallDescriptorForPostStatus nodeStatus1CallDescriptor = localCallDescriptorList[5] as LocalCallDescriptorForPostStatus;
VerifyNodeStatus1(nodeStatus1CallDescriptor);
LocalCallDescriptorForPostStatus nodeStatus2CallDescriptor = localCallDescriptorList[6] as LocalCallDescriptorForPostStatus;
VerifyNodeStatus2(nodeStatus2CallDescriptor);
LocalCallDescriptorForShutdownNode shutdownNodeCallDescriptor = localCallDescriptorList[7] as LocalCallDescriptorForShutdownNode;
Assert.IsTrue(shutdownNodeCallDescriptor.ShutdownLevel == Node.NodeShutdownLevel.BuildCompleteSuccess);
Assert.IsTrue(shutdownNodeCallDescriptor.ExitProcess);
LocalCallDescriptorForShutdownComplete shutdownNodeCompleteCallDescriptor = localCallDescriptorList[8] as LocalCallDescriptorForShutdownComplete;
Assert.IsTrue(shutdownNodeCompleteCallDescriptor.ShutdownLevel == Node.NodeShutdownLevel.BuildCompleteFailure);
LocalCallDescriptorForInitializationComplete initializeCompleteCallDescriptor = localCallDescriptorList[9] as LocalCallDescriptorForInitializationComplete;
Assert.IsTrue(initializeCompleteCallDescriptor.ProcessId == 99);
LocalCallDescriptorForGettingCacheEntriesFromHost getCacheEntriesCallDescriptor = localCallDescriptorList[10] as LocalCallDescriptorForGettingCacheEntriesFromHost;
VerifyGetCacheEntryFromHost(getCacheEntriesCallDescriptor);
LocalCallDescriptorForPostingCacheEntriesToHost postCacheEntriesCallDescriptor = localCallDescriptorList[11] as LocalCallDescriptorForPostingCacheEntriesToHost;
Assert.IsTrue(string.Compare(postCacheEntriesCallDescriptor.ScopeName, "ScopeName", StringComparison.OrdinalIgnoreCase) == 0);
Assert.IsTrue(string.Compare(postCacheEntriesCallDescriptor.ScopeProperties["PropertyName"].Value, "Value", StringComparison.OrdinalIgnoreCase) == 0);
Assert.IsTrue(string.Compare(postCacheEntriesCallDescriptor.ScopeToolsVersion, "3.5", StringComparison.OrdinalIgnoreCase) == 0);
Assert.IsTrue(postCacheEntriesCallDescriptor.ContentType == CacheContentType.BuildResults);
VerifyGetCacheEntries(postCacheEntriesCallDescriptor.Entries);
LocalReplyCallDescriptor reply1CallDescriptor = localCallDescriptorList[12] as LocalReplyCallDescriptor;
Assert.IsTrue(reply1CallDescriptor.RequestingCallNumber == 1);
VerifyGetCacheEntries((CacheEntry[])reply1CallDescriptor.ReplyData);
LocalReplyCallDescriptor reply2CallDescriptor = localCallDescriptorList[13] as LocalReplyCallDescriptor;
Assert.IsTrue(reply2CallDescriptor.RequestingCallNumber == 6);
Assert.IsTrue(string.Compare("Foo", (string)reply2CallDescriptor.ReplyData, StringComparison.OrdinalIgnoreCase) == 0);
LocalCallDescriptorForInitializeNode initializeCallDescriptor = localCallDescriptorList[14] as LocalCallDescriptorForInitializeNode;
Assert.IsTrue(initializeCallDescriptor.ParentProcessId == 5);
Assert.IsTrue(initializeCallDescriptor.NodeId == 4);
Assert.IsTrue(initializeCallDescriptor.ToolsetSearchLocations == ToolsetDefinitionLocations.ConfigurationFile);
Assert.IsTrue(string.Compare(initializeCallDescriptor.ParentGlobalProperties["PropertyName"].Value, "Value", StringComparison.OrdinalIgnoreCase) == 0);
Assert.IsTrue(string.Compare(initializeCallDescriptor.NodeLoggers[0].Name, "Class", StringComparison.OrdinalIgnoreCase) == 0);
IDictionary variables = Environment.GetEnvironmentVariables();
Assert.IsTrue(variables.Count == initializeCallDescriptor.EnvironmentVariables.Count);
foreach (string key in variables.Keys)
{
Assert.IsTrue(string.Compare((string)initializeCallDescriptor.EnvironmentVariables[key], (string)variables[key], StringComparison.OrdinalIgnoreCase) == 0);
}
writeSharedMemory.Reset();
readSharedMemory.Reset();
readSharedMemory = null;
writeSharedMemory = null;
}
private string HandleServiceStart(bool isReconnecting)
{
string listenerEndpoint = null;
string str4;
string sharedMemoryName = this.isTcp ? "NetTcpPortSharing/endpoint" : "NetPipeActivator/endpoint";
this.serviceName = SharedConnectionListener.GetServiceName(this.isTcp);
if (!isReconnecting && this.ReadEndpoint(sharedMemoryName, out listenerEndpoint))
{
return(listenerEndpoint);
}
ServiceController service = new ServiceController(this.serviceName);
try
{
ServiceControllerStatus status = service.Status;
if (isReconnecting && (status == ServiceControllerStatus.Running))
{
try
{
string str3 = SharedMemory.Read(sharedMemoryName);
if (this.listenerEndPoint != str3)
{
return(str3);
}
}
catch (Win32Exception exception)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
}
}
status = this.ExitServiceStatus(service, 50, 50, ServiceControllerStatus.Running);
}
if (status == ServiceControllerStatus.Running)
{
goto Label_021B;
}
if (!isReconnecting)
{
try
{
service.Start();
goto Label_01FD;
}
catch (InvalidOperationException exception2)
{
Win32Exception innerException = exception2.InnerException as Win32Exception;
if (innerException == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SharedManagerBase", new object[] { this.serviceName, System.ServiceModel.SR.GetString("SharedManagerServiceStartFailureNoError") }), exception2));
}
if (innerException.NativeErrorCode == 0x422)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SharedManagerBase", new object[] { this.serviceName, System.ServiceModel.SR.GetString("SharedManagerServiceStartFailureDisabled", new object[] { this.serviceName }) }), exception2));
}
if (innerException.NativeErrorCode != 0x420)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SharedManagerBase", new object[] { this.serviceName, System.ServiceModel.SR.GetString("SharedManagerServiceStartFailure", new object[] { innerException.NativeErrorCode }) }), exception2));
}
goto Label_01FD;
}
}
switch (status)
{
case ServiceControllerStatus.StopPending:
status = this.ExitServiceStatus(service, 50, 0x3e8, status);
break;
case ServiceControllerStatus.Stopped:
status = this.ExitServiceStatus(service, 50, 0x3e8, status);
break;
}
Label_01FD:
service.Refresh();
status = service.Status;
if (status == ServiceControllerStatus.StartPending)
{
status = this.ExitServiceStatus(service, 50, 50, ServiceControllerStatus.StartPending);
}
Label_021B:
if (status != ServiceControllerStatus.Running)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SharedManagerBase", new object[] { this.serviceName, System.ServiceModel.SR.GetString("SharedManagerServiceStartFailureNoError") })));
}
}
finally
{
service.Close();
}
try
{
str4 = SharedMemory.Read(sharedMemoryName);
}
catch (Win32Exception exception4)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.WrapEndpointReadingException(exception4));
}
return(str4);
}
