public void Initialise(ICruiseServer server,
ExtensionConfiguration extensionConfig)
{
var projectsElement = extensionConfig.Items
.SingleOrDefault(n => n.Name == "allowedProjects");
if (projectsElement != null)
{
this.maxCount = int.Parse(
projectsElement.InnerText) - 1;
}
this.server = server;
this.server.ProjectStarting += (o, e) =>
{
if (this.count >= this.maxCount)
{
e.Cancel = true;
}
else
{
this.count++;
}
};
this.server.ProjectStopped += (o, e) =>
{
this.count--;
};
Console.WriteLine("Initialise");
}
/// <summary>
/// Initialises the extension.
/// </summary>
/// <param name="extensionConfig"></param>
/// <param name="server">The server that this extension is for.</param>
public void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
var counters = this.PerformanceCounters ?? new DefaultPerformanceCounters();
counters.EnsureCategoryExists(
CategoryName,
"Performance counters for CruiseControl.NET",
new CounterCreationData(NumberCompletedCounter, string.Empty, PerformanceCounterType.NumberOfItems32),
new CounterCreationData(NumberFailedCounter, string.Empty, PerformanceCounterType.NumberOfItems32),
new CounterCreationData(AverageTimeCounter, string.Empty, PerformanceCounterType.AverageTimer32),
new CounterCreationData(NumberTotalCounter, string.Empty, PerformanceCounterType.AverageBase));
// Retrieve the counters
Log.Debug("Initialising performance monitoring - integration requests");
var stopwatches = new Dictionary<string, Stopwatch>();
server.IntegrationStarted += (o, e) =>
{
Log.Debug(
string.Format(CultureInfo.CurrentCulture,"Starting stopwatch for '{0}'", e.ProjectName));
// Start a stopwatch for the project
if (stopwatches.ContainsKey(e.ProjectName))
{
stopwatches[e.ProjectName].Reset();
}
else
{
var stopwatch = new Stopwatch();
stopwatches.Add(e.ProjectName, stopwatch);
stopwatch.Start();
}
};
server.IntegrationCompleted += (o, e) =>
{
Log.Debug(
string.Format(CultureInfo.CurrentCulture,"Performance logging for '{0}'", e.ProjectName));
// Stop the stopwatch and record the elapsed time
if (stopwatches.ContainsKey(e.ProjectName))
{
var stopwatch = stopwatches[e.ProjectName];
stopwatch.Stop();
stopwatches.Remove(e.ProjectName);
counters.IncrementCounter(CategoryName, NumberTotalCounter);
counters.IncrementCounter(CategoryName, AverageTimeCounter, stopwatch.ElapsedMilliseconds);
}
// Record the result
if (e.Status == IntegrationStatus.Success)
{
counters.IncrementCounter(CategoryName, NumberCompletedCounter);
}
else
{
counters.IncrementCounter(CategoryName, NumberFailedCounter);
}
};
}
/// <summary>
/// Initialises the extension.
/// </summary>
/// <param name="extensionConfig"></param>
/// <param name="server">The server that this extension is for.</param>
public void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
foreach (XmlElement itemEl in extensionConfig.Items)
{
if (itemEl.Name == "limit") numberOfRequestsAllowed = Convert.ToInt32(itemEl.InnerText);
}
server.IntegrationStarted += new EventHandler<IntegrationStartedEventArgs>(server_IntegrationStarted);
server.IntegrationCompleted += new EventHandler<IntegrationCompletedEventArgs>(server_IntegrationCompleted);
}
/// <summary>
/// Initialises the service host to use.
/// </summary>
/// <param name="server">The CruiseServer that is initialising this extension.</param>
/// <param name="extensionConfig">The configuration for the extension.</param>
public void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
// Validate the input parameters
if (server == null) throw new ArgumentNullException("server");
// Store the parameters that we need for later
cruiseServer = server;
// Create a new service host
wcfServiceHost = new ServiceHost(new CruiseControlImplementation(cruiseServer));
}
public void InitialiseLoadsTheSpaceCorrectlyForMb()
{
var server = mocks.DynamicMock<ICruiseServer>();
var extension = new DiskSpaceMonitorExtension();
var configuration = new ExtensionConfiguration();
configuration.Items = new XmlElement[] {
CreateSizeElement("Mb", 100, "C:\\")
};
extension.Initialise(server, configuration);
Assert.AreEqual(104857600, extension.RetrieveMinimumSpaceRequired("C:\\"));
}
public void ItemsGetSetTest()
{
XmlDocument document = new XmlDocument();
XmlElement element = document.CreateElement("test");
ExtensionConfiguration config = new ExtensionConfiguration();
config.Items = new XmlElement[] {
element
};
Assert.AreEqual(1, config.Items.Length);
Assert.AreEqual(element, config.Items[0]);
}
/// <summary>
/// Initialises the extension.
/// </summary>
/// <param name="extensionConfig"></param>
/// <param name="server">The server that this extension is for.</param>
public void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
foreach (var itemEl in extensionConfig.Items ?? new XmlElement[0])
{
if (itemEl.Name == "limit")
{
this.NumberOfRequestsAllowed = Convert.ToInt32(
itemEl.InnerText,
CultureInfo.CurrentCulture);
}
}
server.IntegrationStarted += server_IntegrationStarted;
server.IntegrationCompleted += server_IntegrationCompleted;
}
/// <summary>
/// Initialises the extension.
/// </summary>
/// <param name="server">The server that this extension is for.</param>
/// <param name="extensionConfig"></param>
public virtual void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
else
{
server.IntegrationStarted += (o, e) =>
{
// Check all the drives that they have sufficient space
var fileSystem = server.RetrieveService(typeof(IFileSystem)) as IFileSystem ?? new SystemIoFileSystem();
bool hasSpace = true;
foreach (var drive in driveSpaces.Keys)
{
var freeSpace = fileSystem.GetFreeDiskSpace(drive);
hasSpace &= (freeSpace >= driveSpaces[drive]);
}
e.Result = hasSpace ? IntegrationStartedEventArgs.EventResult.Continue
: IntegrationStartedEventArgs.EventResult.Cancel;
if (!hasSpace)
{
Log.Warning(string.Format(System.Globalization.CultureInfo.CurrentCulture,"Integration for '{0}' cancelled due to a lack of space.", e.ProjectName));
}
};
}
foreach (var element in extensionConfig.Items ?? new XmlElement[0])
{
if (element.Name == "drive")
{
if (element.SelectNodes("*").Count > 0) throw new ArgumentException("Drive definitions cannot contain child elements");
AddDriveSpace(element.GetAttribute("name"), element.GetAttribute("unit"), element.InnerText);
}
else
{
throw new ArgumentOutOfRangeException("Unknown configuration option: " + element.Name);
}
}
if (driveSpaces.Count == 0)
{
throw new ArgumentOutOfRangeException("At least one drive must be defined to monitor");
}
}
public void InitialiseLoadsNumberOfRequestsAllowed()
{
var extension = new IntegrationRequestThrottleExtension();
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
config.Items = new[]
{
GenerateElement("limit", "10")
};
Expect.Call(() => serverMock.IntegrationCompleted += null).IgnoreArguments();
Expect.Call(() => serverMock.IntegrationStarted += null).IgnoreArguments();
this.mocks.ReplayAll();
extension.Initialise(serverMock, config);
this.mocks.VerifyAll();
Assert.AreEqual(10, extension.NumberOfRequestsAllowed);
}
public void IntegrationStartIsAllowedWhenWithinLimit()
{
var extension = new IntegrationRequestThrottleExtension();
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
Expect.Call(() => serverMock.IntegrationCompleted += null).IgnoreArguments();
var startRaiser = Expect
.Call(() => serverMock.IntegrationStarted += null)
.IgnoreArguments()
.GetEventRaiser();
var eventArgs = new IntegrationStartedEventArgs(null, "TestProject");
this.mocks.ReplayAll();
extension.Initialise(serverMock, config);
startRaiser.Raise(serverMock, eventArgs);
this.mocks.VerifyAll();
Assert.AreEqual(IntegrationStartedEventArgs.EventResult.Continue, eventArgs.Result);
}
public void StartAndAbortDoesNothing()
{
var counters = this.InitialiseCounters();
var extension = new IntegrationPerformanceCountersExtension
{
PerformanceCounters = counters
};
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
Expect.Call(() => serverMock.IntegrationCompleted += null).IgnoreArguments();
Expect.Call(() => serverMock.IntegrationStarted += null).IgnoreArguments();
this.mocks.ReplayAll();
extension.Initialise(serverMock, config);
extension.Start();
extension.Abort();
this.mocks.VerifyAll();
}
/// <summary>
/// Retrieve the list of extensions to load.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="configContext">The context.</param>
/// <param name="section">The section that is being loaded.</param>
/// <returns>An array of strings containing the type names.</returns>
public object Create(object parent, object configContext, XmlNode section)
{
ServerConfiguration configuration = new ServerConfiguration();
// Load the extensions
foreach (XmlNode node in section.SelectNodes("extension"))
{
ExtensionConfiguration config = new ExtensionConfiguration();
config.Type = node.Attributes["type"].Value;
List<XmlElement> items = new List<XmlElement>();
foreach (XmlElement itemEl in node.SelectNodes("*"))
{
items.Add(itemEl);
}
config.Items = items.ToArray();
configuration.Extensions.Add(config);
}
return configuration;
}
public void SuccessfulIntegrationUpdatesSuccessCounter()
{
var counters = this.InitialiseCounters();
Expect.Call(() => counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.NumberCompletedCounter));
Expect.Call(() => counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.NumberTotalCounter));
Expect.Call(() => counters.IncrementCounter(
Arg<string>.Is.Equal(IntegrationPerformanceCountersExtension.CategoryName),
Arg<string>.Is.Equal(IntegrationPerformanceCountersExtension.AverageTimeCounter),
Arg<long>.Is.Anything));
var extension = new IntegrationPerformanceCountersExtension
{
PerformanceCounters = counters
};
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
var completedRaiser = Expect.Call(() => serverMock
.IntegrationCompleted += null)
.IgnoreArguments()
.GetEventRaiser();
var startRaiser = Expect
.Call(() => serverMock.IntegrationStarted += null)
.IgnoreArguments()
.GetEventRaiser();
var request = new IntegrationRequest(BuildCondition.ForceBuild, "Testing", null);
this.mocks.ReplayAll();
extension.Initialise(serverMock, config);
startRaiser.Raise(serverMock, new IntegrationStartedEventArgs(request, "TestProject"));
completedRaiser.Raise(serverMock, new IntegrationCompletedEventArgs(request, "TestProject", IntegrationStatus.Success));
this.mocks.VerifyAll();
}
public void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
HasInitialised = true;
}
public void StartAndAbortDoesNothing()
{
var extension = new DiskSpaceMonitorExtension();
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
this.mocks.ReplayAll();
extension.Start();
extension.Abort();
this.mocks.VerifyAll();
}
public void IntegrationIsSuccessfulWhenSufficientSpace()
{
// Initialise the file system
var fileSystem = mocks.DynamicMock<IFileSystem>();
SetupResult.For(fileSystem.GetFreeDiskSpace("c:\\"))
.Return(104857600);
// Initialise the server
var server = mocks.DynamicMock<ICruiseServer>();
SetupResult.For(server.RetrieveService(typeof(IFileSystem)))
.Return(fileSystem);
server.IntegrationStarted += null;
LastCall.IgnoreArguments();
var eventRaiser = LastCall.GetEventRaiser();
// Initialise the extension
var extension = new DiskSpaceMonitorExtension();
var configuration = new ExtensionConfiguration();
configuration.Items = new XmlElement[] {
CreateSizeElement("Mb", 1, "C:\\")
};
mocks.ReplayAll();
// Run the actual test
extension.Initialise(server, configuration);
var args = new IntegrationStartedEventArgs(null, "Project 1");
eventRaiser.Raise(null, args);
Assert.AreEqual(IntegrationStartedEventArgs.EventResult.Continue, args.Result);
}
public void InitialiseThrowsAnErrorWithNoDrives()
{
var server = mocks.DynamicMock<ICruiseServer>();
var extension = new DiskSpaceMonitorExtension();
var configuration = new ExtensionConfiguration();
configuration.Items = new XmlElement[] {
};
Assert.That(delegate { extension.Initialise(server, configuration); },
Throws.TypeOf<ArgumentOutOfRangeException>());
}
public void InitialiseThrowsAnErrorForUnknownUnit()
{
var server = mocks.DynamicMock<ICruiseServer>();
var extension = new DiskSpaceMonitorExtension();
var configuration = new ExtensionConfiguration();
configuration.Items = new XmlElement[] {
CreateSizeElement("garbage", 100, "C:\\")
};
Assert.That(delegate { extension.Initialise(server, configuration); },
Throws.TypeOf<ArgumentOutOfRangeException>());
}
public void StartAndAbortExtensions()
{
List<ExtensionConfiguration> extensions = new List<ExtensionConfiguration>();
ExtensionConfiguration extensionStub = new ExtensionConfiguration();
extensionStub.Type = "ThoughtWorks.CruiseControl.UnitTests.Remote.ServerExtensionStub,ThoughtWorks.CruiseControl.UnitTests";
extensions.Add(extensionStub);
configServiceMock.ExpectAndReturn("Load", configuration);
projectIntegratorListFactoryMock.ExpectAndReturn("CreateProjectIntegrators", integratorList, configuration.Projects, integrationQueue);
server = new CruiseServer((IConfigurationService)configServiceMock.MockInstance,
(IProjectIntegratorListFactory)projectIntegratorListFactoryMock.MockInstance,
(IProjectSerializer)projectSerializerMock.MockInstance,
(IProjectStateManager)stateManagerMock.MockInstance,
fileSystem,
executionEnvironment,
extensions);
Assert.IsTrue(ServerExtensionStub.HasInitialised);
server.Start();
Assert.IsTrue(ServerExtensionStub.HasStarted);
server.Abort();
Assert.IsTrue(ServerExtensionStub.HasAborted);
}
public void InitialiseingANonExistantExtensionThrowsAnException()
{
List<ExtensionConfiguration> extensions = new List<ExtensionConfiguration>();
ExtensionConfiguration extensionStub = new ExtensionConfiguration();
extensionStub.Type = "ThoughtWorks.CruiseControl.UnitTests.Remote.Garbage,ThoughtWorks.CruiseControl.UnitTests";
extensions.Add(extensionStub);
configServiceMock.ExpectAndReturn("Load", configuration);
projectIntegratorListFactoryMock.ExpectAndReturn("CreateProjectIntegrators", integratorList, configuration.Projects, integrationQueue);
Assert.That(delegate
{
new CruiseServer((IConfigurationService) configServiceMock.MockInstance,
(IProjectIntegratorListFactory)
projectIntegratorListFactoryMock.MockInstance,
(IProjectSerializer) projectSerializerMock.MockInstance,
(IProjectStateManager) stateManagerMock.MockInstance,
fileSystem,
executionEnvironment,
extensions);
},
Throws.TypeOf<NullReferenceException>().With.Message.EqualTo(
"Unable to find extension 'ThoughtWorks.CruiseControl.UnitTests.Remote.Garbage,ThoughtWorks.CruiseControl.UnitTests'"));
}
public void IntegrationStartAllowedAtTopOfQueue()
{
var extension = new IntegrationRequestThrottleExtension();
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
var completeRaiser = Expect
.Call(() => serverMock.IntegrationCompleted += null)
.IgnoreArguments()
.GetEventRaiser();
var startRaiser = Expect
.Call(() => serverMock.IntegrationStarted += null)
.IgnoreArguments()
.GetEventRaiser();
var eventArgs = new IntegrationStartedEventArgs(null, "TestProject");
this.mocks.ReplayAll();
extension.Initialise(serverMock, config);
extension.NumberOfRequestsAllowed = 1;
startRaiser.Raise(serverMock, new IntegrationStartedEventArgs(null, "First"));
startRaiser.Raise(serverMock, eventArgs);
startRaiser.Raise(serverMock, new IntegrationStartedEventArgs(null, "Third"));
completeRaiser.Raise(
serverMock,
new IntegrationCompletedEventArgs(null, "First", IntegrationStatus.Success));
startRaiser.Raise(serverMock, eventArgs);
this.mocks.VerifyAll();
Assert.AreEqual(IntegrationStartedEventArgs.EventResult.Continue, eventArgs.Result);
}
/// <summary>
/// Initialises the extension.
/// </summary>
/// <param name="extensionConfig"></param>
/// <param name="server">The server that this extension is for.</param>
public void Initialise(ICruiseServer server, ExtensionConfiguration extensionConfig)
{
if (!PerformanceCounterCategory.Exists("CruiseControl.NET"))
{
Log.Info("Initialising new performance counters for integration requests");
var collection = new CounterCreationDataCollection();
// Number of integrations completed counter
var numberOfCompletedIntegrations = new CounterCreationData();
numberOfCompletedIntegrations.CounterType = PerformanceCounterType.NumberOfItems32;
numberOfCompletedIntegrations.CounterName = "Number of Completed Integrations";
collection.Add(numberOfCompletedIntegrations);
// Number of integrations failed counter
var numberOfFailedIntegrations = new CounterCreationData();
numberOfFailedIntegrations.CounterType = PerformanceCounterType.NumberOfItems32;
numberOfFailedIntegrations.CounterName = "Number of Failed Integrations";
collection.Add(numberOfFailedIntegrations);
// Integration time counter
var integrationElapsedTime = new CounterCreationData();
integrationElapsedTime.CounterType = PerformanceCounterType.AverageTimer32;
integrationElapsedTime.CounterName = "Integration Time";
collection.Add(integrationElapsedTime);
// Integration count counter
var averageIntegrations = new CounterCreationData();
averageIntegrations.CounterType = PerformanceCounterType.AverageBase;
averageIntegrations.CounterName = "Average number of integrations";
collection.Add(averageIntegrations);
// Create the category
PerformanceCounterCategory.Create("CruiseControl.NET",
"Performance counters for CruiseControl.NET",
collection);
}
// Retrieve the counters
Log.Debug("Initialising performance monitoring - integration requests");
var numberOfCompletedIntegrationsCounter = new PerformanceCounter("CruiseControl.NET", "Number of Completed Integrations", false);
var numberOfFailedIntegrationsCounter = new PerformanceCounter("CruiseControl.NET", "Number of Failed Integrations", false);
var integrationElapsedTimeCounter = new PerformanceCounter("CruiseControl.NET", "Integration Time", false);
var averageIntegrationsCounter = new PerformanceCounter("CruiseControl.NET", "Average number of integrations", false);
var stopwatches = new Dictionary<string, Stopwatch>();
server.IntegrationStarted += (o, e) =>
{
Log.Debug(string.Format("Starting stopwatch for '{0}'", e.ProjectName));
// Start a stopwatch for the project
if (stopwatches.ContainsKey(e.ProjectName))
{
stopwatches[e.ProjectName].Reset();
}
else
{
var stopwatch = new Stopwatch();
stopwatches.Add(e.ProjectName, stopwatch);
stopwatch.Start();
}
};
server.IntegrationCompleted += (o, e) =>
{
Log.Debug(string.Format("Performance logging for '{0}'", e.ProjectName));
// Stop the stopwatch and record the elapsed time
if (stopwatches.ContainsKey(e.ProjectName))
{
var stopwatch = stopwatches[e.ProjectName];
stopwatch.Stop();
stopwatches.Remove(e.ProjectName);
averageIntegrationsCounter.Increment();
integrationElapsedTimeCounter.IncrementBy(stopwatch.ElapsedTicks);
}
// Record the result
if (e.Status == IntegrationStatus.Success)
{
numberOfCompletedIntegrationsCounter.Increment();
}
else
{
numberOfFailedIntegrationsCounter.Increment();
}
};
}
public void StartAndStopDoesNothing()
{
var extension = new IntegrationRequestThrottleExtension();
var serverMock = this.mocks.StrictMock<ICruiseServer>();
var config = new ExtensionConfiguration();
Expect.Call(() => serverMock.IntegrationCompleted += null).IgnoreArguments();
Expect.Call(() => serverMock.IntegrationStarted += null).IgnoreArguments();
this.mocks.ReplayAll();
extension.Initialise(serverMock, config);
extension.Start();
extension.Stop();
this.mocks.VerifyAll();
}
