/// <summary>
/// Serialize and encrypt configuration object
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
public byte[] EncodeConfigurationToken(ExtensionConfiguration configuration)
{
byte[] payload = SerializeConfigurationToken(configuration);
// Encrypt the token
return(Encrypt(payload));
}
public async Task <IEnumerable <TitleInfo> > SearchTitleInfo(string query)
{
ExtensionConfiguration config = null;
if (this.HasExtensionConfiguration())
{
config = this.GetExtensionConfiguration();
}
if (config?.ActiveConfig == ActiveConfig.Steam)
{
return(await _steamApiService.SearchTitle(query));
}
else
{
var searchResult = await _xApiService.SearchTitle(query, config?.XBoxLiveConfig);
return(searchResult.Products.Select(product =>
new TitleInfo
{
Platform = ActiveConfig.XBoxLive,
TitleId = product.AlternateIds?.FirstOrDefault(id => id.IdType == "XboxTitleId")?.Value ?? "",
ProductTitle = product.LocalizedProperties?.FirstOrDefault()?.ProductTitle ?? "Unknown",
ProductDescription = product.LocalizedProperties?.FirstOrDefault()?.ProductDescription ?? "-",
LogoUri = product.LocalizedProperties?.FirstOrDefault()?.Images?.FirstOrDefault(i => i.ImagePurpose == "Logo" || i.ImagePurpose == "BoxArt" || i.ImagePurpose == "FeaturePromotionalSquareArt")?.Uri,
}
));
}
}
public ExtensionConfiguration ToConfiguration()
{
ExtensionConfiguration config = new ExtensionConfiguration();
foreach (var id in allRoles)
{
config.AllRoles.Add(new ExtensionConfiguration.Extension
{
Id = id
});
}
foreach (var r in namedRoles)
{
if (r.Value.Any())
{
var nr = new ExtensionConfiguration.NamedRole
{
RoleName = r.Key
};
foreach (var v in r.Value)
{
nr.Extensions.Add(new ExtensionConfiguration.Extension
{
Id = v
});
}
config.NamedRoles.Add(nr);
}
}
return(config);
}
public void IntegrationIsStoppedWhenInsufficientSpace()
{
// Initialise the file system
var fileSystem = mocks.DynamicMock <IFileSystem>();
SetupResult.For(fileSystem.GetFreeDiskSpace("c:\\"))
.Return(102400);
// 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.Cancel, args.Result);
}
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 override Task ProcessAsync(ExtensionContext context, ExtensionConfiguration config)
{
if (context.Application.Services.Any(s => s.Name == "zipkin"))
{
context.Output.WriteDebugLine("zipkin service already configured. Skipping...");
}
else
{
context.Output.WriteDebugLine("Injecting zipkin service...");
var service = new ContainerServiceBuilder("zipkin", "openzipkin/zipkin")
{
Bindings =
{
new BindingBuilder()
{
Port = 9411,
ContainerPort = 9411,
Protocol = "http",
},
},
};
context.Application.Services.Add(service);
foreach (var s in context.Application.Services)
{
if (object.ReferenceEquals(s, service))
{
continue;
}
// make zipkin available as a dependency of everything.
if (!s.Dependencies.Contains(service.Name))
{
s.Dependencies.Add(service.Name);
}
}
}
if (context.Operation == ExtensionContext.OperationKind.LocalRun)
{
if (context.Options !.DistributedTraceProvider is null)
{
// For local development we hardcode the port and hostname
context.Options.DistributedTraceProvider = "zipkin=http://localhost:9411";
}
}
else if (context.Operation == ExtensionContext.OperationKind.Deploy)
{
foreach (var project in context.Application.Services.OfType <DotnetProjectServiceBuilder>())
{
var sidecar = DiagnosticAgent.GetOrAddSidecar(project);
// Use service discovery to find zipkin
sidecar.Args.Add("--provider:zipkin=service:zipkin");
sidecar.Dependencies.Add("zipkin");
}
}
return(Task.CompletedTask);
}
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 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.Setup(service => service.Load()).Returns(configuration).Verifiable();
projectIntegratorListFactoryMock.Setup(factory => factory.CreateProjectIntegrators(configuration.Projects, It.IsAny <IntegrationQueueSet>()))
.Returns(integratorList).Verifiable();
server = new CruiseServer((IConfigurationService)configServiceMock.Object,
(IProjectIntegratorListFactory)projectIntegratorListFactoryMock.Object,
(IProjectSerializer)projectSerializerMock.Object,
(IProjectStateManager)stateManagerMock.Object,
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.Setup(service => service.Load()).Returns(configuration).Verifiable();
projectIntegratorListFactoryMock.Setup(factory => factory.CreateProjectIntegrators(configuration.Projects, It.IsAny <IntegrationQueueSet>()))
.Returns(integratorList).Verifiable();
Assert.That(delegate
{
new CruiseServer((IConfigurationService)configServiceMock.Object,
(IProjectIntegratorListFactory)
projectIntegratorListFactoryMock.Object,
(IProjectSerializer)projectSerializerMock.Object,
(IProjectStateManager)stateManagerMock.Object,
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);
}
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");
}
public ExtensionConfiguration UpdateExtensionState(ExtensionConfigurationInput input)
{
var extConfig = new ExtensionConfiguration();
if (input.Roles == null || input.Roles.Count == 1 && input.Roles[0].RoleType == ExtensionRoleType.AllRoles)
{
extConfig.AllRoles = new List <ExtensionConfiguration.Extension>();
extConfig.AllRoles.Add(new ExtensionConfiguration.Extension
{
Id = input.Id,
State = input.State
});
}
else
{
extConfig.NamedRoles = new List <ExtensionConfiguration.NamedRole>();
foreach (var role in input.Roles)
{
var ext = new List <ExtensionConfiguration.Extension>();
ext.Add(new ExtensionConfiguration.Extension
{
Id = input.Id,
State = input.State
});
extConfig.NamedRoles.Add(new ExtensionConfiguration.NamedRole
{
RoleName = role.RoleName,
Extensions = ext
});
}
}
return(extConfig);
}
/// <summary>
/// Gets a boolean indicating whether or not the file is a
/// recognized source file.
/// </summary>
/// <param name="fileName">File to test.</param>
/// <param name="extensions">Extension configurations.</param>
/// <returns>A boolean indicating whehther or not the file is recognized.</returns>
private static bool IsRecognizedFile(string fileName, ExtensionConfigurationCollection extensions)
{
bool isRecognizedFile = true;
string extension = GetExtension(fileName);
ExtensionConfiguration extensionConfiguration = null;
foreach (ExtensionConfiguration extensionEntry in extensions)
{
if (extensionEntry.Name == extension)
{
extensionConfiguration = extensionEntry;
break;
}
}
if (extensionConfiguration != null && extensionConfiguration.FilterBy != null)
{
FilterBy filterBy = extensionConfiguration.FilterBy;
FileFilter fileFilter = new FileFilter(filterBy.Condition);
if (File.Exists(fileName))
{
isRecognizedFile = fileFilter.IsMatch(new FileInfo(fileName));
}
}
return(isRecognizedFile);
}
public ExtensionConfigurationBuilder Add(ExtensionConfiguration config)
{
if (config != null)
{
if (config.AllRoles != null)
{
foreach (var e in config.AllRoles)
{
AddDefault(e.Id);
}
}
if (config.NamedRoles != null)
{
foreach (var r in config.NamedRoles)
{
foreach (var e in r.Extensions)
{
if (namedRoles.ContainsKey(r.RoleName))
{
namedRoles[r.RoleName].Add(e.Id);
}
else
{
namedRoles.Add(r.RoleName, new HashSet <string>(new string[] { e.Id }));
}
}
}
}
}
return(this);
}
/// <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);
}
};
}
public void SuccessfulIntegrationUpdatesSuccessCounter()
{
var counters = this.InitialiseCounters();
Mock.Get(counters).Setup(_counters => _counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.NumberCompletedCounter)).Verifiable();
Mock.Get(counters).Setup(_counters => _counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.NumberTotalCounter)).Verifiable();
Mock.Get(counters).Setup(_counters => _counters.IncrementCounter(
IntegrationPerformanceCountersExtension.CategoryName,
IntegrationPerformanceCountersExtension.AverageTimeCounter,
It.IsAny <long>())).Verifiable();
var extension = new IntegrationPerformanceCountersExtension
{
PerformanceCounters = counters
};
var serverMock = this.mocks.Create <ICruiseServer>(MockBehavior.Strict).Object;
var config = new ExtensionConfiguration();
Mock.Get(serverMock).SetupAdd(_serverMock => _serverMock.IntegrationCompleted += It.IsAny <EventHandler <IntegrationCompletedEventArgs> >()).Verifiable();
Mock.Get(serverMock).SetupAdd(_serverMock => _serverMock.IntegrationStarted += It.IsAny <EventHandler <IntegrationStartedEventArgs> >()).Verifiable();
var request = new IntegrationRequest(BuildCondition.ForceBuild, "Testing", null);
extension.Initialise(serverMock, config);
Mock.Get(serverMock).Raise(_serverMock => _serverMock.IntegrationStarted += null, new IntegrationStartedEventArgs(request, "TestProject"));
Mock.Get(serverMock).Raise(_serverMock => _serverMock.IntegrationCompleted += null, new IntegrationCompletedEventArgs(request, "TestProject", IntegrationStatus.Success));
mocks.VerifyAll();
}
public void ExecuteCommand()
{
InitializeAntimalwareSettings();
ValidateParameters();
RemoveAntimalwareExtension();
RemoveExistingAntimalwareMonitoringConfig();
ExtensionConfigurationInput[] extConfigInputs = null;
if (AntimalwareExtensionConfigurationInput != null && AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[2];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
extConfigInputs[1] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
}
// process any pending deployment changes
if (extConfigInputs != null)
{
ExtensionConfiguration newExtConfig = ExtensionManager.Add(Deployment, extConfigInputs, Slot);
ChangeDeployment(newExtConfig);
}
}
public void IntegrationIsStoppedWhenInsufficientSpace()
{
// Initialise the file system
var fileSystem = mocks.Create <IFileSystem>().Object;
Mock.Get(fileSystem)
.Setup(_fileSystem => _fileSystem.GetFreeDiskSpace("c:\\"))
.Returns(102400);
// Initialise the server
var server = mocks.Create <ICruiseServer>().Object;
Mock.Get(server)
.Setup(_server => _server.RetrieveService(typeof(IFileSystem)))
.Returns(fileSystem);
// Initialise the extension
var extension = new DiskSpaceMonitorExtension();
var configuration = new ExtensionConfiguration();
configuration.Items = new XmlElement[] {
CreateSizeElement("Mb", 1, "C:\\")
};
// Run the actual test
extension.Initialise(server, configuration);
var args = new IntegrationStartedEventArgs(null, "Project 1");
Mock.Get(server).Raise(_server => _server.IntegrationStarted += null, args);
Assert.AreEqual(IntegrationStartedEventArgs.EventResult.Cancel, args.Result);
}
public ConfigurationToken SetConfiguration(ExtensionConfiguration configuration)
{
return(new ConfigurationToken
{
ConfigToken = Convert.ToBase64String(_tokenService.EncodeConfigurationToken(configuration))
});
}
internal RateLimits GetXApiRateLimits(ExtensionConfiguration extensionConfiguration)
{
if (extensionConfiguration.ActiveConfig != ActiveConfig.XBoxLive)
{
throw new ArgumentException("Only valid on XBoxLive configs");
}
return(_xApiService.GetRateLimit(extensionConfiguration.XBoxLiveConfig.XApiKey));
}
public void CreateTest()
{
ExtensionConfiguration extensionConfiguration = new ExtensionConfiguration();
//
// Verify default state
//
Assert.IsNull(extensionConfiguration.Name, "Unexpected default value for Name.");
}
/// <summary>
/// Adds the currently selected connection to the configuration so it is persisted
/// in the MRU cache as well as the auto-startup connection
/// </summary>
/// <param name="configuration"></param>
public void UpdateConfigFromSelections(ExtensionConfiguration configuration)
{
var connection = GetConnectionFromTreeView();
if (connection != null)
{
configuration.CachedConnections?.AddToCache(connection);
configuration.SavedConnection = connection;
}
}
public void ToStringTest()
{
ExtensionConfiguration extensionConfiguration = new ExtensionConfiguration();
extensionConfiguration.Name = "cs";
string str = extensionConfiguration.ToString();
Assert.AreEqual("Extension: cs", str, "Unexpected string representation.");
}
public void ConfigureExtensionConfiguration <TConfiguration>(TConfiguration configuration)
{
var type = typeof(TConfiguration);
if (ExtensionConfiguration.ContainsKey(type))
{
var builder = ExtensionConfiguration[type] as BootstrapExtensionConfiguration <TConfiguration>;
builder.ConfigurationBuilder(configuration);
}
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot,
DeploymentGetResponse deployment, DeploymentGetResponse peerDeployment)
{
Func <DeploymentGetResponse, ExtensionConfiguration> func = (d) => d == null ? null : d.ExtensionConfiguration;
ExtensionConfiguration extConfig = func(deployment);
ExtensionConfiguration secondSlotExtConfig = func(peerDeployment);
return(InstallExtension(context, slot, extConfig, secondSlotExtConfig));
}
public void ExecuteCommand()
{
ValidateParameters();
// prepare diagnostics extension
switch (monitoringAction)
{
case MonitoringActionType.Enable: EnableMonitoring(); break;
case MonitoringActionType.Disable: RemoveExistingAntimalwareMonitoringConfig(); break;
default: break;
}
// prepare antimalware extension
if (isAntimalwareEnabled)
{
InitializeAntimalwareSettings();
ExtensionConfigurationInput amExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareExtensionConfigurationInput = amExtConfigInput;
}
// update extensions as appropriate
ExtensionConfigurationInput[] extConfigInputs = null;
if (AntimalwareExtensionConfigurationInput != null && AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[2];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
extConfigInputs[1] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
}
// process any pending deployment changes
if (extConfigInputs != null)
{
ExtensionConfiguration newExtConfig = ExtensionManager.Add(Deployment, PeerDeployment, extConfigInputs, Slot);
ChangeDeployment(newExtConfig);
}
}
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>());
}
/// <summary>
/// Updates the MRU list of servers from the configuration
/// Depending on whether we are logged in, we update the server combo box selection to
/// the MRU server or to the currently connected server
/// </summary>
/// <param name="configuration"></param>
public void UpdateFromConfig(ExtensionConfiguration configuration)
{
if (InteractionAllowed) // in case team projects were already being loaded (todo: cancel old task)
{
this.ServerComboBox.ItemsSource = configuration.CachedConnections?.GetCachedConnections().ToList();
ConnectionInfo connectionInfo = AzureDevOps.ConnectedToAzureDevOps ?
AzureDevOps.Configuration.SavedConnection :
configuration.CachedConnections?.GetMostRecentConnection();
this.ServerComboBox.Text = connectionInfo?.ServerUri == null ? string.Empty : connectionInfo.ServerUri.AbsoluteUri;
InitializeView();
}
}
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]);
}
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 ExtensionConfigurationBuilder Add(ExtensionConfiguration config)
{
if (config != null)
{
if (config.AllRoles != null)
{
foreach (var e in config.AllRoles)
{
AddDefault(e.Id);
}
}
if (config.NamedRoles != null)
{
foreach (var r in config.NamedRoles)
{
foreach (var e in r.Extensions)
{
if (namedRoles.ContainsKey(r.RoleName))
{
namedRoles[r.RoleName].Add(e.Id);
}
else
{
namedRoles.Add(r.RoleName, new HashSet<string>(new string[] { e.Id }));
}
}
}
}
}
return this;
}
public ExtensionConfiguration ToConfiguration()
{
ExtensionConfiguration config = new ExtensionConfiguration
{
AllRoles = new AllRoles(),
NamedRoles = new NamedRoles()
};
config.AllRoles.AddRange(from id in allRoles select new Extension(id));
config.NamedRoles.AddRange(from r in namedRoles
where r.Value.Any()
select new RoleExtensions
{
RoleName = r.Key,
Extensions = new ExtensionList(from id in r.Value select new Extension(id))
});
return config;
}
protected void ChangeDeployment(ExtensionConfiguration extConfig)
{
DeploymentChangeConfigurationParameters changeConfigInput = new DeploymentChangeConfigurationParameters
{
Configuration = Deployment.Configuration,
ExtensionConfiguration = Deployment.ExtensionConfiguration = extConfig,
Mode = DeploymentChangeConfigurationMode.Auto,
TreatWarningsAsError = false
};
ExecuteClientActionNewSM(
null,
CommandRuntime.ToString(),
() => this.ComputeClient.Deployments.ChangeConfigurationBySlot(
ServiceName,
(DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), Slot, true),
changeConfigInput));
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot, ExtensionConfiguration extConfig)
{
ExtensionConfigurationBuilder builder = GetBuilder(extConfig);
foreach (ExtensionRole r in context.Roles)
{
string roleName = r.RoleType == ExtensionRoleType.AllRoles ? DefaultAllRolesNameStr : r.RoleName;
var extensionIds = (from index in Enumerable.Range(0, ExtensionIdLiveCycleCount)
select GetExtensionId(roleName, context.Type, slot, index)).ToList();
string availableId = (from extensionId in extensionIds
where !builder.ExistAny(extensionId)
select extensionId).FirstOrDefault();
var extensionList = (from id in extensionIds
let e = GetExtension(id)
where e != null
select e).ToList();
string thumbprint = context.CertificateThumbprint;
string thumbprintAlgorithm = context.ThumbprintAlgorithm;
if (context.X509Certificate != null)
{
thumbprint = context.X509Certificate.Thumbprint;
}
else
{
GetExtensionThumbprintAndAlgorithm(extensionList, availableId, ref thumbprint, ref thumbprintAlgorithm);
}
context.CertificateThumbprint = string.IsNullOrWhiteSpace(context.CertificateThumbprint) ? thumbprint : context.CertificateThumbprint;
context.ThumbprintAlgorithm = string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm) ? thumbprintAlgorithm : context.ThumbprintAlgorithm;
if (!string.IsNullOrWhiteSpace(context.CertificateThumbprint) && string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = ThumbprintAlgorithmStr;
}
var existingExtension = extensionList.Find(e => e.Id == availableId);
if (existingExtension != null)
{
DeleteExtension(availableId);
}
AddExtension(new HostedServiceExtensionInput
{
Id = availableId,
Thumbprint = context.CertificateThumbprint,
ThumbprintAlgorithm = context.ThumbprintAlgorithm,
ProviderNameSpace = context.ProviderNameSpace,
Type = context.Type,
PublicConfiguration = context.PublicConfiguration,
PrivateConfiguration = context.PrivateConfiguration
});
if (r.RoleType == ExtensionRoleType.NamedRoles)
{
builder.Remove(roleName, context.ProviderNameSpace, context.Type);
builder.Add(roleName, availableId);
}
else
{
builder.RemoveDefault(context.ProviderNameSpace, context.Type);
builder.AddDefault(availableId);
}
}
return builder.ToConfiguration();
}
public ExtensionConfigurationBuilder GetBuilder(ExtensionConfiguration config)
{
return GetBuilder().Add(config);
}
public ExtensionConfiguration ToConfiguration()
{
ExtensionConfiguration config = new ExtensionConfiguration();
foreach (var id in allRoles)
{
config.AllRoles.Add(new ExtensionConfiguration.Extension
{
Id = id
});
}
foreach (var r in namedRoles)
{
if (r.Value.Any())
{
var nr = new ExtensionConfiguration.NamedRole
{
RoleName = r.Key
};
foreach (var v in r.Value)
{
nr.Extensions.Add(new ExtensionConfiguration.Extension
{
Id = v
});
}
config.NamedRoles.Add(nr);
}
}
return config;
}
public ExtensionConfigurationBuilder(ExtensionManager extensionManager, ExtensionConfiguration config)
: this(extensionManager)
{
Add(config);
}
public void Uninstall(string nameSpace, string type, ExtensionConfiguration extConfig)
{
var extBuilder = GetBuilder(extConfig);
Channel.ListHostedServiceExtensions(SubscriptionId, ServiceName).ForEach(e =>
{
if (CheckNameSpaceType(e, nameSpace, type) && !extBuilder.ExistAny(e.Id))
{
Channel.DeleteHostedServiceExtension(SubscriptionId, ServiceName, e.Id);
}
});
}
protected void ChangeDeployment(ExtensionConfiguration extConfig)
{
ChangeConfigurationInput changeConfigInput = new ChangeConfigurationInput
{
Configuration = Deployment.Configuration,
ExtendedProperties = Deployment.ExtendedProperties,
ExtensionConfiguration = Deployment.ExtensionConfiguration = extConfig,
Mode = ChangeConfigurationModeStr,
TreatWarningsAsError = false
};
ExecuteClientActionInOCS(null, CommandRuntime.ToString(), s => Channel.ChangeConfigurationBySlot(s, ServiceName, Slot, changeConfigInput));
}
public ExtensionConfigurationBuilder GetBuilder(ExtensionConfiguration config)
{
return new ExtensionConfigurationBuilder(this, config);
}
