public void ReturnsCorrectProjectDetailsFromProjectsAndQueuesXml()
{
DashboardXmlParser parser = new DashboardXmlParser();
CruiseServerSnapshot snapshot = parser.ExtractAsCruiseServerSnapshot(CRUISE_SERVER_XML);
Assert.IsNotNull(snapshot);
Assert.AreEqual(2, snapshot.ProjectStatuses.Length);
AssertProjectsSerializedCorrectly(snapshot);
Assert.AreEqual(2, snapshot.QueueSetSnapshot.Queues.Count);
QueueSnapshot queueSnapshot1 = snapshot.QueueSetSnapshot.Queues[0];
Assert.AreEqual("Queue1", queueSnapshot1.QueueName);
Assert.AreEqual("projectName", queueSnapshot1.Requests[0].ProjectName);
Assert.AreEqual(ProjectActivity.CheckingModifications, queueSnapshot1.Requests[0].Activity);
Assert.AreEqual("SVNTest", queueSnapshot1.Requests[1].ProjectName);
Assert.AreEqual(ProjectActivity.Pending, queueSnapshot1.Requests[1].Activity);
QueueSnapshot queueSnapshot2 = snapshot.QueueSetSnapshot.Queues[1];
Assert.AreEqual("Queue2", queueSnapshot2.QueueName);
Assert.AreEqual("Missing", queueSnapshot2.Requests[0].ProjectName);
Assert.AreEqual(ProjectActivity.Building, queueSnapshot2.Requests[0].Activity);
}
public void GetIntegrationQueueSnapshotForSingleProjectOnSingleQueue()
{
project1Mock.SetupGet(project => project.CurrentActivity).Returns(ProjectActivity.CheckingModifications);
queueNotifier1Mock.Setup(notifier => notifier.NotifyEnteringIntegrationQueue()).Verifiable();
integrationQueue1.Enqueue(integrationQueueItem1);
QueueSetSnapshot queueSetSnapshot = integrationQueues.GetIntegrationQueueSnapshot();
Assert.IsNotNull(queueSetSnapshot);
Assert.AreEqual(2, queueSetSnapshot.Queues.Count);
QueueSnapshot queueSnapshot = queueSetSnapshot.Queues[0];
Assert.IsNotNull(queueSnapshot);
Assert.IsFalse(queueSnapshot.IsEmpty);
Assert.AreEqual(TestQueueName, queueSnapshot.QueueName);
Assert.AreEqual(1, queueSnapshot.Requests.Count);
Assert.AreEqual(queueSnapshot, queueSetSnapshot.FindByName(TestQueueName));
QueuedRequestSnapshot queuedRequestSnapshot = queueSnapshot.Requests[0];
Assert.AreEqual("ProjectOne", queuedRequestSnapshot.ProjectName);
Assert.AreEqual(ProjectActivity.CheckingModifications, queuedRequestSnapshot.Activity);
QueueSnapshot queueSnapshot2 = queueSetSnapshot.Queues[1];
Assert.IsNotNull(queueSnapshot2);
Assert.IsTrue(queueSnapshot2.IsEmpty);
VerifyAll();
queueNotifier1Mock.VerifyNoOtherCalls();
}
public void GetIntegrationQueueSnapshotForMultipleProjectsOnSingleQueue()
{
project1Mock.SetupGet(project => project.CurrentActivity).Returns(ProjectActivity.CheckingModifications);
queueNotifier1Mock.Setup(notifier => notifier.NotifyEnteringIntegrationQueue()).Verifiable();
integrationQueue1.Enqueue(integrationQueueItem1);
// Second item is different project but same queue
project2Mock.SetupGet(project => project.QueueName).Returns(TestQueueName);
project2Mock.SetupGet(project => project.CurrentActivity).Returns(ProjectActivity.Pending);
queueNotifier2Mock.Setup(notifier => notifier.NotifyEnteringIntegrationQueue()).Verifiable();
integrationQueue1.Enqueue(integrationQueueItem2);
QueueSetSnapshot queueSetSnapshot = integrationQueues.GetIntegrationQueueSnapshot();
Assert.AreEqual(2, queueSetSnapshot.Queues.Count);
QueueSnapshot queueSnapshot = queueSetSnapshot.Queues[0];
Assert.AreEqual(2, queueSnapshot.Requests.Count);
QueuedRequestSnapshot firstQueuedRequestSnapshot = queueSnapshot.Requests[0];
Assert.AreEqual("ProjectOne", firstQueuedRequestSnapshot.ProjectName);
Assert.AreEqual(ProjectActivity.CheckingModifications, firstQueuedRequestSnapshot.Activity);
QueuedRequestSnapshot secondQueuedRequestSnapshot = queueSnapshot.Requests[1];
Assert.AreEqual("ProjectTwo", secondQueuedRequestSnapshot.ProjectName);
Assert.AreEqual(ProjectActivity.Pending, secondQueuedRequestSnapshot.Activity);
VerifyAll();
queueNotifier1Mock.VerifyNoOtherCalls();
queueNotifier2Mock.VerifyNoOtherCalls();
}
public void GetIntegrationQueueSnapshotForMultipleProjectsOnSingleQueue()
{
project1Mock.SetupResult("CurrentActivity", ProjectActivity.CheckingModifications);
queueNotifier1Mock.Expect("NotifyEnteringIntegrationQueue");
queueNotifier1Mock.ExpectNoCall("NotifyExitingIntegrationQueue", typeof(bool));
integrationQueue1.Enqueue(integrationQueueItem1);
// Second item is different project but same queue
project2Mock.ExpectAndReturn("QueueName", TestQueueName);
project2Mock.SetupResult("CurrentActivity", ProjectActivity.Pending);
queueNotifier2Mock.Expect("NotifyEnteringIntegrationQueue");
queueNotifier2Mock.ExpectNoCall("NotifyExitingIntegrationQueue", typeof(bool));
integrationQueue1.Enqueue(integrationQueueItem2);
QueueSetSnapshot queueSetSnapshot = integrationQueues.GetIntegrationQueueSnapshot();
Assert.AreEqual(2, queueSetSnapshot.Queues.Count);
QueueSnapshot queueSnapshot = queueSetSnapshot.Queues[0];
Assert.AreEqual(2, queueSnapshot.Requests.Count);
QueuedRequestSnapshot firstQueuedRequestSnapshot = queueSnapshot.Requests[0];
Assert.AreEqual("ProjectOne", firstQueuedRequestSnapshot.ProjectName);
Assert.AreEqual(ProjectActivity.CheckingModifications, firstQueuedRequestSnapshot.Activity);
QueuedRequestSnapshot secondQueuedRequestSnapshot = queueSnapshot.Requests[1];
Assert.AreEqual("ProjectTwo", secondQueuedRequestSnapshot.ProjectName);
Assert.AreEqual(ProjectActivity.Pending, secondQueuedRequestSnapshot.Activity);
VerifyAll();
}
public void QueueNameGetSetTest()
{
QueueSnapshot activity = new QueueSnapshot();
activity.QueueName = "testing";
Assert.AreEqual("testing", activity.QueueName);
}
public void GetIntegrationQueueSnapshotForSingleProjectOnSingleQueue()
{
project1Mock.SetupResult("CurrentActivity", ProjectActivity.CheckingModifications);
queueNotifier1Mock.Expect("NotifyEnteringIntegrationQueue");
queueNotifier1Mock.ExpectNoCall("NotifyExitingIntegrationQueue", typeof(bool));
integrationQueue1.Enqueue(integrationQueueItem1);
QueueSetSnapshot queueSetSnapshot = integrationQueues.GetIntegrationQueueSnapshot();
Assert.IsNotNull(queueSetSnapshot);
Assert.AreEqual(2, queueSetSnapshot.Queues.Count);
QueueSnapshot queueSnapshot = queueSetSnapshot.Queues[0];
Assert.IsNotNull(queueSnapshot);
Assert.IsFalse(queueSnapshot.IsEmpty);
Assert.AreEqual(TestQueueName, queueSnapshot.QueueName);
Assert.AreEqual(1, queueSnapshot.Requests.Count);
Assert.AreEqual(queueSnapshot, queueSetSnapshot.FindByName(TestQueueName));
QueuedRequestSnapshot queuedRequestSnapshot = queueSnapshot.Requests[0];
Assert.AreEqual("ProjectOne", queuedRequestSnapshot.ProjectName);
Assert.AreEqual(ProjectActivity.CheckingModifications, queuedRequestSnapshot.Activity);
QueueSnapshot queueSnapshot2 = queueSetSnapshot.Queues[1];
Assert.IsNotNull(queueSnapshot2);
Assert.IsTrue(queueSnapshot2.IsEmpty);
VerifyAll();
}
public IntegrationQueueTreeNodeTag(IntegrationQueueTreeNodeAdaptor adaptor, QueueSnapshot queueSnapshot,
QueuedRequestSnapshot queuedRequestSnapshot, int queueIndex)
{
this.Adaptor = adaptor;
this.QueueSnapshot = queueSnapshot;
this.QueuedRequestSnapshot = queuedRequestSnapshot;
this.QueueIndex = queueIndex;
}
public void ServerReturnsUnderlyingServer()
{
var client = mocks.Create <CruiseServerClientBase>().Object;
var server = InitialiseServer();
var status = new QueueSnapshot();
var queue = new BuildQueue(client, server, status);
Assert.AreSame(server, queue.Server);
}
/// <summary>
/// Wraps the specified queue status.
/// </summary>
/// <param name="owningClient">The owning client.</param>
/// <param name="queueStatus">The queue status.</param>
/// <param name="connection">The connection.</param>
/// <returns>
/// The new <see cref="CCProject"/>.
/// </returns>
internal static CCQueue Wrap(CruiseServerClientBase owningClient, QueueSnapshot queueStatus, CCConnection connection)
{
var queue = new CCQueue(owningClient, queueStatus.QueueName, queueStatus.Requests)
{
Connection = connection
};
return(queue);
}
/// <summary>
/// Initialise a new build queue.
/// </summary>
/// <param name="client">The underlying client.</param>
/// <param name="server">The server this queue belongs to.</param>
/// <param name="buildQueue">The actual build queue details.</param>
public BuildQueue(CruiseServerClientBase client,Server server, QueueSnapshot buildQueue)
{
if (client == null) throw new ArgumentNullException("client");
if (server == null) throw new ArgumentNullException("server");
if (buildQueue == null) throw new ArgumentNullException("buildQueue");
this.client = client;
this.server = server;
this.buildQueue = buildQueue;
}
public void ServerReturnsUnderlyingServer()
{
var client = mocks.DynamicMock <CruiseServerClientBase>();
var server = InitialiseServer();
var status = new QueueSnapshot();
var queue = new BuildQueue(client, server, status);
mocks.ReplayAll();
Assert.AreSame(server, queue.Server);
}
public void NameReturnsQueueNameFromSnapshot()
{
var client = mocks.Create <CruiseServerClientBase>().Object;
var server = InitialiseServer();
var status = new QueueSnapshot {
QueueName = "Test BuildQueue"
};
var queue = new BuildQueue(client, server, status);
Assert.AreEqual(status.QueueName, queue.Name);
}
public void DetectQueueSetChangedWithDifferingProjectStatus()
{
snapshot1.Queues.Add(new QueueSnapshot("Test1"));
snapshot2.Queues.Add(new QueueSnapshot("Test1"));
QueueSnapshot queue1 = snapshot1.Queues[0];
QueueSnapshot queue2 = snapshot2.Queues[0];
queue1.Requests.Add(new QueuedRequestSnapshot("Project1", ProjectActivity.CheckingModifications));
queue2.Requests.Add(new QueuedRequestSnapshot("Project1", ProjectActivity.Building));
AssertQueueSetChanged(true, snapshot1, snapshot2);
}
public ProbeResult Execute <T>(T snapshot)
{
QueueSnapshot data = snapshot as QueueSnapshot;
ProbeResult result;
if (_config.IsNull() || _config.Probes.IsNull())
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.NA, out var article);
result = new NotApplicableProbeResult(null,
null,
Metadata.Id,
Metadata.Name,
ComponentType,
article);
NotifyObservers(result);
return(result);
}
var probeData = new List <ProbeData>
{
new ProbeDataImpl("Messages.Incoming.Total", data.Messages.Incoming.Total.ToString()),
new ProbeDataImpl("QueueLowFlowThreshold", _config.Probes.QueueLowFlowThreshold.ToString())
};
if (data.Messages.Incoming.Total <= _config.Probes.QueueLowFlowThreshold)
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Unhealthy, out var article);
result = new UnhealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
else
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Healthy, out var article);
result = new HealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
NotifyObservers(result);
return(result);
}
private static void WriteQueueSnapshot(XmlWriter xmlWriter, QueueSnapshot queue)
{
xmlWriter.WriteStartElement("Queue");
xmlWriter.WriteAttributeString("name", queue.QueueName);
foreach (QueuedRequestSnapshot request in queue.Requests)
{
WriteQueuedRequestSnapshot(xmlWriter, request);
}
xmlWriter.WriteEndElement();
}
public void ToStringSerialisesAllValues()
{
QueueSnapshot queueSnapshot = new QueueSnapshot("queue1");
queueSnapshot.Requests.Add(new QueuedRequestSnapshot("test project", ProjectActivity.Pending));
QueueSetSnapshot queueSetSnapshot = new QueueSetSnapshot();
queueSetSnapshot.Queues.Add(queueSnapshot);
ProjectStatus projectStatus = new ProjectStatus("test project", IntegrationStatus.Success, DateTime.Now);
CruiseServerSnapshot snapshot = new CruiseServerSnapshot(
new ProjectStatus[] { projectStatus },
queueSetSnapshot);
SnapshotResponse response = new SnapshotResponse();
response.ErrorMessages.Add(new ErrorMessage("Error 1"));
response.ErrorMessages.Add(new ErrorMessage("Error 2"));
response.RequestIdentifier = "request";
response.Result = ResponseResult.Success;
response.Timestamp = DateTime.Now;
response.Snapshot = snapshot;
string actual = response.ToString();
string expected = string.Format(System.Globalization.CultureInfo.CurrentCulture, "<snapshotResponse xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " +
"timestamp=\"{2:yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz}\" identifier=\"{0}\" result=\"{1}\">" +
"<error>Error 1</error>" +
"<error>Error 2</error>" +
"<snapshot>" +
"<projects>" +
"<projectStatus showForceBuildButton=\"true\" showStartStopButton=\"true\" serverName=\"{6}\" status=\"Running\" buildStatus=\"Success\" name=\"test project\" " +
"queuePriority=\"0\" lastBuildDate=\"{3:yyyy-MM-ddTHH:mm:ss.FFFFFFF}\" nextBuildTime=\"{4:yyyy-MM-ddTHH:mm:ss.FFFFFFF}\">" +
"<activity type=\"Sleeping\" />" +
"<parameters />" +
"</projectStatus>" +
"</projects>" +
"<queueSet>" +
"<queue name=\"queue1\">" +
"<queueRequest projectName=\"test project\" time=\"{5:yyyy-MM-ddTHH:mm:ss.FFFFFFF}\">" +
"<activity type=\"Pending\" />" +
"</queueRequest>" +
"</queue>" +
"</queueSet>" +
"</snapshot>" +
"</snapshotResponse>",
response.RequestIdentifier,
response.Result,
response.Timestamp,
projectStatus.LastBuildDate,
projectStatus.NextBuildTime,
DateTime.MinValue,
Environment.MachineName);
XDocument.Parse(actual).Should().BeEquivalentTo(XDocument.Parse(expected));
}
private CruiseServerSnapshot CreateEmptyQueuesSnapshot()
{
QueueSetSnapshot queueSetSnapshot = new QueueSetSnapshot();
QueueSnapshot queueSnapshot1 = new QueueSnapshot("Queue1");
queueSetSnapshot.Queues.Add(queueSnapshot1);
QueueSnapshot queueSnapshot2 = new QueueSnapshot("Queue2");
queueSetSnapshot.Queues.Add(queueSnapshot2);
return(new CruiseServerSnapshot(null, queueSetSnapshot));
}
public void DetectQueueSetNotChanged()
{
snapshot1.Queues.Add(new QueueSnapshot("Test1"));
snapshot2.Queues.Add(new QueueSnapshot("Test1"));
QueueSnapshot queue1 = snapshot1.Queues[0];
QueueSnapshot queue2 = snapshot2.Queues[0];
// Same number of projects with no content
AssertQueueSetChanged(false, snapshot1, snapshot2);
// Same number of projects with content
queue1.Requests.Add(new QueuedRequestSnapshot("Project1", ProjectActivity.CheckingModifications));
queue2.Requests.Add(new QueuedRequestSnapshot("Project1", ProjectActivity.CheckingModifications));
AssertQueueSetChanged(false, snapshot1, snapshot2);
}
public void RequestsReturnsRequestsFromStatus()
{
var client = mocks.Create <CruiseServerClientBase>().Object;
var server = InitialiseServer();
var status = new QueueSnapshot
{
Requests =
{
new QueuedRequestSnapshot {
ProjectName = "Project 1"
}
}
};
var queue = new BuildQueue(client, server, status);
}
public QueueSnapshot GetQueueSnapShot(int queueId)
{
QueueSnapshot snapShot = new QueueSnapshot();
List<PDSFill> selectedPDSFillList = new List<PDSFill>();
var pdsQueues = new List<PDSQueue>()
{
new PDSQueue { StateId = (int)QueueStates.DUE, Name="DUE", Code="DUE"},
new PDSQueue { StateId = (int)QueueStates.ThirdPartyRejects, Name="3RD PARTY REJECTS", Code="MAR"},
new PDSQueue { StateId = (int)QueueStates.PrintLabel, Name="PRINT LABEL", Code="PLABEL"},
new PDSQueue { StateId = (int)QueueStates.RPHVerificaiton, Name="RPH VERIFICATION", Code="RPH"},
new PDSQueue { StateId = (int)QueueStates.WillCall, Name="WILL CALL", Code="WILLCALL"}
};
using (var context = new PDSEntities())
{
var groupedFills = context.PDSFills.GroupBy(p => p.State);
foreach (var fillGroup in groupedFills)
{
int stateId = fillGroup.Key.Value;
if (pdsQueues.Count(p => p.StateId == stateId) > 0)
{
pdsQueues.Single(p => p.StateId == stateId).Count = fillGroup.Count();
}
if (fillGroup.Key.Value == queueId)
{
selectedPDSFillList = fillGroup.ToList();
}
}
}
List<Fill> selectedFills = new List<Fill>();
foreach (var pdsFill in selectedPDSFillList)
{
var fill = new Fill();
MapPDSFilltoFill(pdsFill, fill);
selectedFills.Add(fill);
}
snapShot.Queues = pdsQueues;
snapShot.SelectedQueueFills = selectedFills;
return snapShot;
}
public void UpdateValidatesArguments()
{
var client = mocks.Create <CruiseServerClientBase>().Object;
var server = InitialiseServer();
var status = new QueueSnapshot {
QueueName = "Testing"
};
var queue = new BuildQueue(client, server, status);
try
{
queue.Update(null);
Assert.Fail("ArgumentNullException was expected");
}
catch (ArgumentNullException) { }
}
private CruiseServerSnapshot CreatePopulatedQueuesSnapshot()
{
CruiseServerSnapshot cruiseServerSnapshot = CreateEmptyQueuesSnapshot();
QueueSetSnapshot queueSetSnapshot = cruiseServerSnapshot.QueueSetSnapshot;
QueueSnapshot queueSnapshot1 = queueSetSnapshot.Queues[0];
QueuedRequestSnapshot queuedRequestSnapshot1 = new QueuedRequestSnapshot("Project1", ProjectActivity.CheckingModifications);
queueSnapshot1.Requests.Add(queuedRequestSnapshot1);
QueuedRequestSnapshot queuedRequestSnapshot2 = new QueuedRequestSnapshot("Project2", ProjectActivity.Pending);
queueSnapshot1.Requests.Add(queuedRequestSnapshot2);
return(cruiseServerSnapshot);
}
/// <summary>
/// Initialise a new build queue.
/// </summary>
/// <param name="client">The underlying client.</param>
/// <param name="server">The server this queue belongs to.</param>
/// <param name="buildQueue">The actual build queue details.</param>
public BuildQueue(CruiseServerClientBase client, Server server, QueueSnapshot buildQueue)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
if (server == null)
{
throw new ArgumentNullException("server");
}
if (buildQueue == null)
{
throw new ArgumentNullException("buildQueue");
}
this.client = client;
this.server = server;
this.buildQueue = buildQueue;
}
public void UpdateFiresPropertyChangedWhenMessageIsRemoved()
{
mocks = new MockRepository();
var client = mocks.DynamicMock <CruiseServerClientBase>();
var server = InitialiseServer();
var status = new QueueSnapshot
{
Requests =
{
new QueuedRequestSnapshot {
ProjectName = "Project 1"
},
new QueuedRequestSnapshot {
ProjectName = "Project 2"
}
}
};
var queue = new BuildQueue(client, server, status);
mocks.ReplayAll();
var eventFired = false;
queue.Update(status);
var newStatus = new QueueSnapshot
{
Requests =
{
new QueuedRequestSnapshot {
ProjectName = "Project 2"
}
}
};
queue.BuildQueueRequestRemoved += (o, e) =>
{
eventFired = true;
};
queue.Update(newStatus);
Assert.IsTrue(eventFired, "BuildQueueRequestRemoved for Requests change not fired");
}
private static QueueSnapshot BuildQueueSnapshot(IIntegrationQueue queue)
{
QueueSnapshot queueSnapshot = new QueueSnapshot(queue.Name);
for (int index = 0; index < queue.Count; index++)
{
IIntegrationQueueItem integrationQueueItem = (IIntegrationQueueItem)queue[index];
// The first request in the queue shows it's real activity of CheckingModifications or Building
// Everything else is in a pending state.
ProjectActivity projectActivity = ProjectActivity.Pending;
if (index == 0)
{
projectActivity = integrationQueueItem.Project.CurrentActivity;
}
QueuedRequestSnapshot queuedRequestSnapshot = new QueuedRequestSnapshot(
integrationQueueItem.Project.Name,
projectActivity,
integrationQueueItem.IntegrationRequest.RequestTime);
queueSnapshot.Requests.Add(queuedRequestSnapshot);
}
return(queueSnapshot);
}
public void GetIntegrationQueueSnapshotForMultipleQueues()
{
project1Mock.SetupResult("CurrentActivity", ProjectActivity.CheckingModifications);
queueNotifier1Mock.Expect("NotifyEnteringIntegrationQueue");
queueNotifier1Mock.ExpectNoCall("NotifyExitingIntegrationQueue", typeof(bool));
integrationQueue1.Enqueue(integrationQueueItem1);
// Second item is different project and different queue
project2Mock.SetupResult("CurrentActivity", ProjectActivity.Pending);
queueNotifier2Mock.Expect("NotifyEnteringIntegrationQueue");
queueNotifier2Mock.ExpectNoCall("NotifyExitingIntegrationQueue", typeof(bool));
integrationQueue2.Enqueue(integrationQueueItem2);
QueueSetSnapshot queueSetSnapshot = integrationQueues.GetIntegrationQueueSnapshot();
Assert.AreEqual(2, queueSetSnapshot.Queues.Count);
foreach (QueueSnapshot namedQueueSnapshot in queueSetSnapshot.Queues)
{
Assert.AreEqual(1, namedQueueSnapshot.Requests.Count);
}
QueueSnapshot firstQueueSnapshot = queueSetSnapshot.Queues[0];
Assert.AreEqual(1, firstQueueSnapshot.Requests.Count);
QueuedRequestSnapshot firstQueuedRequestSnapshot = firstQueueSnapshot.Requests[0];
Assert.AreEqual("ProjectOne", firstQueuedRequestSnapshot.ProjectName);
QueueSnapshot secondQueueSnapshot = queueSetSnapshot.Queues[1];
Assert.AreEqual(1, secondQueueSnapshot.Requests.Count);
QueuedRequestSnapshot secondQueuedRequestSnapshot = secondQueueSnapshot.Requests[0];
Assert.AreEqual("ProjectTwo", secondQueuedRequestSnapshot.ProjectName);
VerifyAll();
}
public ProbeResult Execute <T>(T snapshot)
{
QueueSnapshot data = snapshot as QueueSnapshot;
ProbeResult result;
var probeData = new List <ProbeData>
{
new ProbeDataImpl("Messages.Incoming.Rate", data.Messages.Incoming.Rate.ToString()),
new ProbeDataImpl("Messages.Acknowledged.Rate", data.Messages.Acknowledged.Rate.ToString())
};
if (data.Messages.Incoming.Rate > data.Messages.Acknowledged.Rate)
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Warning, out var article);
result = new WarningProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
else
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Healthy, out var article);
result = new HealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
NotifyObservers(result);
return(result);
}
public ProbeResult Execute <T>(T snapshot)
{
QueueSnapshot data = snapshot as QueueSnapshot;
ProbeResult result;
var probeData = new List <ProbeData>
{
new ProbeDataImpl("Memory.PagedOut.Total", data.Memory.PagedOut.Total.ToString())
};
if (data.Memory.PagedOut.Total > 0)
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Unhealthy, out var article);
result = new UnhealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
else
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Healthy, out var article);
result = new HealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
NotifyObservers(result);
return(result);
}
public void UpdateFiresPropertyChangedWhenMessageIsAdded()
{
mocks = new MockRepository(MockBehavior.Default);
var client = mocks.Create <CruiseServerClientBase>().Object;
var server = InitialiseServer();
var status = new QueueSnapshot
{
Requests =
{
new QueuedRequestSnapshot {
ProjectName = "Project 1"
}
}
};
var queue = new BuildQueue(client, server, status);
var eventFired = false;
var newStatus = new QueueSnapshot
{
Requests =
{
new QueuedRequestSnapshot {
ProjectName = "Project 1"
},
new QueuedRequestSnapshot {
ProjectName = "Project 2"
}
}
};
queue.BuildQueueRequestAdded += (o, e) =>
{
eventFired = true;
};
queue.Update(newStatus);
Assert.IsTrue(eventFired, "BuildQueueRequestAdded for Requests change not fired");
}
private QueueSetSnapshot ConvertDashboardQueues(DashboardQueue[] dashboardQueues)
{
QueueSetSnapshot queueSetSnapshot = new QueueSetSnapshot();
if (dashboardQueues != null)
{
foreach (DashboardQueue dashboardQueue in dashboardQueues)
{
QueueSnapshot queueSnapshot = new QueueSnapshot(dashboardQueue.Name);
if (dashboardQueue.Requests != null)
{
foreach (DashboardQueuedRequest dashboardQueuedRequest in dashboardQueue.Requests)
{
QueuedRequestSnapshot queuedRequestSnapshot = new QueuedRequestSnapshot(
dashboardQueuedRequest.ProjectName,
new ProjectActivity(dashboardQueuedRequest.Activity));
queueSnapshot.Requests.Add(queuedRequestSnapshot);
}
}
queueSetSnapshot.Queues.Add(queueSnapshot);
}
}
return(queueSetSnapshot);
}
/// <summary>
/// Updates the details on a build queue.
/// </summary>
/// <param name="value">The new build queue details.</param>
public void Update(QueueSnapshot value)
{
// Validate the arguments
if (value == null) throw new ArgumentNullException("value");
// Find all the changed properties
var changes = new List<string>();
var newRequests = new List<BuildQueueRequest>();
var oldRequests = new List<BuildQueueRequest>();
lock (syncLock)
{
// Check for any request differences
var requestValues = new Dictionary<BuildQueueRequest, QueuedRequestSnapshot>();
var oldRequestNames = new List<string>(requests.Keys);
foreach (var request in value.Requests)
{
// Check if this request has already been loaded
var requestName = request.ProjectName;
if (oldRequestNames.Contains(requestName))
{
requestValues.Add(requests[requestName], request);
oldRequestNames.Remove(requestName);
}
else
{
// Otherwise this is a new request
var newRequest = new BuildQueueRequest(client, this, request);
newRequests.Add(newRequest);
}
}
// Store the old request
foreach (var request in oldRequestNames)
{
oldRequests.Add(requests[request]);
}
// Perform the actual update
foreach (var request in oldRequestNames)
{
requests.Remove(request);
}
foreach (var request in newRequests)
{
if (!requests.ContainsKey(request.Name))
{
requests.Add(request.Name, request);
}
}
buildQueue = value;
// Update all the requests
foreach (var requestValue in requestValues)
{
requestValue.Key.Update(requestValue.Value);
}
}
// Tell any listeners about any changes
foreach (var request in newRequests)
{
FireBuildQueueRequestAdded(request);
}
foreach (var request in oldRequests)
{
FireBuildQueueRequestRemoved(request);
}
foreach (var change in changes)
{
FirePropertyChanged(change);
}
}
public ProbeResult Execute <T>(T snapshot)
{
ProbeResult result;
QueueSnapshot data = snapshot as QueueSnapshot;
if (_config.IsNull() || _config.Probes.IsNull())
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.NA, out var article);
result = new NotApplicableProbeResult(data.IsNotNull() ? data.Node : null,
data.IsNotNull() ? data.Identifier : null,
Metadata.Id,
Metadata.Name,
ComponentType,
article);
NotifyObservers(result);
return(result);
}
var probeData = new List <ProbeData>
{
new ProbeDataImpl("ConsumerUtilization", data.ConsumerUtilization.ToString()),
new ProbeDataImpl("ConsumerUtilizationThreshold", _config.Probes.ConsumerUtilizationThreshold.ToString())
};
if (data.ConsumerUtilization >= _config.Probes.ConsumerUtilizationThreshold &&
data.ConsumerUtilization < 1.0M &&
_config.Probes.ConsumerUtilizationThreshold <= 1.0M)
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Warning, out var article);
result = new WarningProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
else if (data.ConsumerUtilization < _config.Probes.ConsumerUtilizationThreshold &&
_config.Probes.ConsumerUtilizationThreshold <= 1.0M)
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Unhealthy, out var article);
result = new UnhealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
else
{
_kb.TryGet(Metadata.Id, ProbeResultStatus.Healthy, out var article);
result = new HealthyProbeResult(data.Node,
data.Identifier,
Metadata.Id,
Metadata.Name,
ComponentType,
probeData,
article);
}
NotifyObservers(result);
return(result);
}
/// <summary>
/// Updates the details on a build queue.
/// </summary>
/// <param name="value">The new build queue details.</param>
public void Update(QueueSnapshot value)
{
// Validate the arguments
if (value == null)
{
throw new ArgumentNullException("value");
}
// Find all the changed properties
var changes = new List <string>();
var newRequests = new List <BuildQueueRequest>();
var oldRequests = new List <BuildQueueRequest>();
lock (syncLock)
{
// Check for any request differences
var requestValues = new Dictionary <BuildQueueRequest, QueuedRequestSnapshot>();
var oldRequestNames = new List <string>(requests.Keys);
foreach (var request in value.Requests)
{
// Check if this request has already been loaded
var requestName = request.ProjectName;
if (oldRequestNames.Contains(requestName))
{
requestValues.Add(requests[requestName], request);
oldRequestNames.Remove(requestName);
}
else
{
// Otherwise this is a new request
var newRequest = new BuildQueueRequest(client, this, request);
newRequests.Add(newRequest);
}
}
// Store the old request
foreach (var request in oldRequestNames)
{
oldRequests.Add(requests[request]);
}
// Perform the actual update
foreach (var request in oldRequestNames)
{
requests.Remove(request);
}
foreach (var request in newRequests)
{
if (!requests.ContainsKey(request.Name))
{
requests.Add(request.Name, request);
}
}
buildQueue = value;
// Update all the requests
foreach (var requestValue in requestValues)
{
requestValue.Key.Update(requestValue.Value);
}
}
// Tell any listeners about any changes
foreach (var request in newRequests)
{
FireBuildQueueRequestAdded(request);
}
foreach (var request in oldRequests)
{
FireBuildQueueRequestRemoved(request);
}
foreach (var change in changes)
{
FirePropertyChanged(change);
}
}
