/// <summary>
/// Backs up the current environment to the datastore, excluding the environment variables added by Chami.
/// </summary>
/// <param name="repository">An <see cref="EnvironmentRepository"/> where to save the backup.</param>
public static void Backup(EnvironmentRepository repository)
{
var environmentVariables = System.Environment.GetEnvironmentVariables();
environmentVariables = RemoveCurrentChamiVariables(environmentVariables, repository);
var backupEnvironment = new Environment();
var environmentName = $"Backup of {DateTime.Now:s}";
backupEnvironment.Name = environmentName;
backupEnvironment.EnvironmentType = EnvironmentType.BackupEnvironment;
foreach (DictionaryEntry entry in environmentVariables)
{
var variableName = (string)entry.Key;
var variableValue = (string)entry.Value;
var environmentVariable = new EnvironmentVariable {
Name = variableName, Value = variableValue
};
backupEnvironment.EnvironmentVariables.Add(environmentVariable);
}
repository.InsertEnvironment(backupEnvironment);
}
public OctopusAsyncRepository(IOctopusAsyncClient client, RepositoryScope repositoryScope = null)
{
Client = client;
Scope = repositoryScope ?? RepositoryScope.Unspecified();
Accounts = new AccountRepository(this);
ActionTemplates = new ActionTemplateRepository(this);
Artifacts = new ArtifactRepository(this);
Backups = new BackupRepository(this);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(this);
CertificateConfiguration = new CertificateConfigurationRepository(this);
Certificates = new CertificateRepository(this);
Channels = new ChannelRepository(this);
CommunityActionTemplates = new CommunityActionTemplateRepository(this);
Configuration = new ConfigurationRepository(this);
DashboardConfigurations = new DashboardConfigurationRepository(this);
Dashboards = new DashboardRepository(this);
Defects = new DefectsRepository(this);
DeploymentProcesses = new DeploymentProcessRepository(this);
Deployments = new DeploymentRepository(this);
Environments = new EnvironmentRepository(this);
Events = new EventRepository(this);
FeaturesConfiguration = new FeaturesConfigurationRepository(this);
Feeds = new FeedRepository(this);
Interruptions = new InterruptionRepository(this);
LibraryVariableSets = new LibraryVariableSetRepository(this);
Lifecycles = new LifecyclesRepository(this);
MachinePolicies = new MachinePolicyRepository(this);
MachineRoles = new MachineRoleRepository(this);
Machines = new MachineRepository(this);
Migrations = new MigrationRepository(this);
OctopusServerNodes = new OctopusServerNodeRepository(this);
PerformanceConfiguration = new PerformanceConfigurationRepository(this);
PackageMetadataRepository = new PackageMetadataRepository(this);
ProjectGroups = new ProjectGroupRepository(this);
Projects = new ProjectRepository(this);
ProjectTriggers = new ProjectTriggerRepository(this);
Proxies = new ProxyRepository(this);
Releases = new ReleaseRepository(this);
RetentionPolicies = new RetentionPolicyRepository(this);
Schedulers = new SchedulerRepository(this);
ServerStatus = new ServerStatusRepository(this);
Spaces = new SpaceRepository(this);
Subscriptions = new SubscriptionRepository(this);
TagSets = new TagSetRepository(this);
Tasks = new TaskRepository(this);
Teams = new TeamsRepository(this);
Tenants = new TenantRepository(this);
TenantVariables = new TenantVariablesRepository(this);
UserInvites = new UserInvitesRepository(this);
UserRoles = new UserRolesRepository(this);
Users = new UserRepository(this);
VariableSets = new VariableSetRepository(this);
Workers = new WorkerRepository(this);
WorkerPools = new WorkerPoolRepository(this);
ScopedUserRoles = new ScopedUserRoleRepository(this);
UserPermissions = new UserPermissionsRepository(this);
loadRootResource = new Lazy <Task <RootResource> >(LoadRootDocumentInner, true);
loadSpaceRootResource = new Lazy <Task <SpaceRootResource> >(LoadSpaceRootDocumentInner, true);
}
public async Task UpdateEnvironment()
{
// arrange
var serializer = new IdSerializer();
var environment = new Environment(Guid.NewGuid(), "abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
string id = serializer.Serialize("Environment", environment.Id);
// act
IExecutionResult result = await Executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"mutation($id: ID!) {
updateEnvironment(input: {
id: $id
name: ""abc2""
description: ""def2""
clientMutationId: ""ghi"" }) {
environment {
id
name
description
}
clientMutationId
}
}")
.SetVariableValue("id", id)
.Create());
// assert
result.MatchSnapshot(o =>
o.Assert(fo =>
Assert.NotNull(fo.Field<string>("Data.updateEnvironment.environment.id"))));
}
public void GetNotExistingEnvironment()
{
var repository = new EnvironmentRepository(connectionString);
var shouldBeNull = repository.GetEnvironmentById(-1);
Assert.Null(shouldBeNull);
}
public async Task GetEnvironmentsById()
{
// arrange
var serializer = new IdSerializer();
var environment = new Environment(Guid.NewGuid(), "abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
string id = serializer.Serialize("Environment", environment.Id);
// act
IExecutionResult result = await Executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"query($ids: [ID!]!) {
environmentsById(ids: $ids) {
id
name
description
}
}")
.SetVariableValue("ids", new[] { id })
.Create());
// assert
result.MatchSnapshot(o =>
o.Assert(fo =>
Assert.Equal(id, fo.Field <string>("Data.environmentsById[0].id"))));
}
public async Task ExecutePublishDocumentServer_With_SchemaFile_Handler()
{
// arrange
var handler = new PublishSchemaDocumentHandler(
Storage, SchemaRepository, PublishSchemaEventSender);
using var service = new PublishDocumentService(
PublishDocumentMessageReceiver, new
IPublishDocumentHandler[] { handler });
var schema = new Schema("abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var environment = new Environment("abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
var message = new PublishDocumentMessage(
"ghi", environment.Id, schema.Id, Array.Empty <Tag>());
IFileContainer fileContainer = await Storage.CreateContainerAsync("ghi");
using (Stream stream = await fileContainer.CreateFileAsync("schema.graphql"))
{
byte[] buffer = Encoding.UTF8.GetBytes(@"
type Query {
foo: String
}
");
await stream.WriteAsync(buffer, 0, buffer.Length);
}
await PublishDocumentMessageSender.SendAsync(message);
// act
await service.StartAsync(default);
/// <summary>
/// Opens an item.
/// </summary>
/// <param name="payload">The payload.</param>
void OpenItem(object payload)
{
var debugState = payload as IDebugState;
if (debugState == null)
{
return;
}
if (debugState.ActivityType == ActivityType.Workflow && EnvironmentRepository != null)
{
var environment = EnvironmentRepository.All().FirstOrDefault(e => e.ID == debugState.EnvironmentID);
if (environment == null || !environment.IsConnected)
{
return;
}
var resource = environment.ResourceRepository.FindSingle(r => r.ResourceName == debugState.DisplayName);
if (resource == null)
{
return;
}
EventPublishers.Aggregator.Publish(new AddWorkSurfaceMessage(resource));
}
}
public void Should_Create_New_Environment()
{
var fakeContext = new FakeContext("CreateNewEnvironment");
var fakeEnvironment = new Environment();
fakeEnvironment.Name = "full name";
using (var context = new MainContext(fakeContext.FakeOptions))
{
var repository = new EnvironmentRepository(context);
var mockValidator = new Mock <IValidator <Environment> >(MockBehavior.Strict);
mockValidator
.Setup(x => x.Validate(fakeEnvironment))
.Returns(new FluentValidation.Results.ValidationResult());
var service = new EnvironmentService(repository, mockValidator.Object);
var actual = service.Create(fakeEnvironment);
var id = actual.Id;
Assert.NotEqual(0, id);
repository.Dispose();
}
}
public async Task PublishSchema()
{
// arrange
var serializer = new IdSerializer();
var schema = new Schema("abc", "def");
await SchemaRepository.AddSchemaAsync(schema);
var environment = new Environment("abc", "def");
await EnvironmentRepository.AddEnvironmentAsync(environment);
// act
IExecutionResult result = await Executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"mutation(
$schemaName: String!
$environmentName: String!
$sourceText: String!
$version: String!) {
publishSchema(input: {
schemaName: $schemaName
environmentName: $environmentName
sourceText: $sourceText
tags: [ { key: ""version"" value: $version } ]
clientMutationId: ""ghi"" }) {
sessionId
clientMutationId
}
}")
.SetVariableValue("schemaName", "abc")
.SetVariableValue("environmentName", "abc")
.SetVariableValue("sourceText", "type Query { a: String }")
.SetVariableValue("version", "1.0.0")
.Create());
// assert
result.MatchSnapshot(o =>
o.Assert(fo =>
Assert.NotNull(fo.Field <string>("Data.publishSchema.sessionId"))));
Assert.Collection(ReceivedMessages,
t =>
{
PublishDocumentMessage message = Assert.IsType <PublishDocumentMessage>(t);
Assert.Equal(schema.Id, message.SchemaId);
Assert.Equal(environment.Id, message.EnvironmentId);
Assert.Equal(DocumentType.Schema, message.Type);
Assert.Null(message.ClientId);
Assert.NotNull(message.SessionId);
Assert.Collection(message.Tags,
t =>
{
Assert.Equal("version", t.Key);
Assert.Equal("1.0.0", t.Value);
});
});
}
public void EnvironmentRepository_GetAllValues()
{
var repo = new EnvironmentRepository();
var values = repo.GetAllValues <List <string> >();
Assert.IsNotNull(values);
Assert.IsTrue(values.Count > 0);
Assert.IsTrue(values.Contains("Q5"));
}
public ExportWindowViewModel()
{
ExportAll = true;
ExportSelected = false;
Environments = new ObservableCollection <EnvironmentExportWindowViewModel>();
SelectedEnvironments = new ObservableCollection <EnvironmentExportWindowViewModel>();
var connectionString = App.GetConnectionString();
_repository = new EnvironmentRepository(connectionString);
}
public void GetPrigPath_should_return_prig_path_in_tools_directory()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.GetPrigPath();
// Assert
Assert.AreEqual(@"C:\ProgramData\chocolatey\lib\Prig\tools\prig.exe", result);
}
public void GetRegsvr32Path_should_return_regsvr32_path_in_system32_directory()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.GetRegsvr32Path();
// Assert
Assert.That(result, Is.SamePath(@"C:\Windows\SysNative\regsvr32.exe"));
}
public void GetVsixPackageFolder_should_return_executing_assembly_directory_path()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.GetVsixPackageFolder();
// Assert
Assert.That(result, Is.StringMatching(GetShadowCopyTargetDirectoryPattern()));
}
public void GetLibPath_should_return_lib_directory_in_chocolatey_compatible_directory_path()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.GetLibPath();
// Assert
Assert.AreEqual(@"C:\ProgramData\chocolatey\lib\Prig\lib", result);
}
public void ExistsDirectory_should_return_true_if_directory_exists()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.ExistsDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
// Assert
Assert.IsTrue(result);
}
public void EnvironmentRepository_GetValue()
{
var repo = new EnvironmentRepository();
var key = "Q5";
var value = repo.GetValue <string>(key);
Assert.IsNotNull(value);
Assert.AreEqual(key, value);
}
public void ExistsFile_should_return_true_if_file_exists()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.ExistsFile(Assembly.GetExecutingAssembly().Location);
// Assert
Assert.IsTrue(result);
}
public void GetVsixLibPath_should_return_lib_directory_in_executing_assembly_directory_path()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.GetVsixLibPath();
// Assert
Assert.That(result, Is.StringMatching(ToShadowCopyTargetPattern(@"lib")));
}
public void GetFileDescription_should_return_the_file_description_of_the_specified_file()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.GetFileDescription(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"tools\x64\Urasandesu.Prig.dll"));
// Assert
Assert.That(result, Is.StringMatching(@"Prig Profiler \d+\.\d+\.\d+ Type Library"));
}
public void EnvironmentRepository_RemoveValue()
{
var repo = new EnvironmentRepository();
var key = "D3";
repo.RemoveValue(key);
var containsKey = repo.ContainsKey(key);
Assert.IsFalse(containsKey);
}
public void SelectLocalHost()
{
var localhostItem = StudioResourceRepository.FindItem(model => model.DisplayName.ToLower().Contains("localhost"));
if (localhostItem != null)
{
localhostItem.IsExplorerSelected = true;
Dev2Logger.Log.Debug("Publish message of type - " + typeof(SetActiveEnvironmentMessage));
var localHost = EnvironmentRepository.FindSingle(model => model.ID == localhostItem.EnvironmentId);
_eventPublisher.Publish(new SetActiveEnvironmentMessage(localHost));
}
}
public void OpenRegistryBaseKey_should_open_specified_registry_key()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
using (var result = envRepos.OpenRegistryBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry32))
{
// Assert
Assert.AreEqual(Registry.ClassesRoot.ToString(), result.ToString());
}
}
public void OpenRegistrySubKey_should_open_specified_registry_sub_key()
{
// Arrange
var envRepos = new EnvironmentRepository();
// Act
using (var result = envRepos.OpenRegistrySubKey(Registry.ClassesRoot, @"TypeLib\{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}\1.1"))
{
// Assert
Assert.IsNotNull(result);
}
}
public void GetExistingEnvironment()
{
var repository = new EnvironmentRepository(connectionString);
var environment = repository.GetEnvironmentById(4);
Assert.NotNull(environment);
Assert.NotEmpty(environment.EnvironmentVariables);
var environmentVariableId = environment.EnvironmentVariables.First().EnvironmentVariableId;
Assert.NotEqual(0, environmentVariableId);
}
public void Delete_NotFoundIdEnvironment()
{
var context = _contextFake.GetContext("Delete_NotFoundIdEnvironment")
.AddFakeEnvironments();
var repo = new EnvironmentRepository(context);
var controller = new EnvironmentController(repo, _mapper);
var result = controller.Delete(int.MaxValue);
var actionResult = Assert.IsType <NotFoundResult>(result);
}
public OctopusAsyncRepository(IOctopusAsyncClient client)
{
this.Client = client;
Accounts = new AccountRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
Artifacts = new ArtifactRepository(client);
Backups = new BackupRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
CertificateConfiguration = new CertificateConfigurationRepository(client);
Certificates = new CertificateRepository(client);
Channels = new ChannelRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
Configuration = new ConfigurationRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Dashboards = new DashboardRepository(client);
Defects = new DefectsRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Deployments = new DeploymentRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
Feeds = new FeedRepository(client);
Interruptions = new InterruptionRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
Lifecycles = new LifecyclesRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
MachineRoles = new MachineRoleRepository(client);
Machines = new MachineRepository(client);
Migrations = new MigrationRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
PerformanceConfiguration = new PerformanceConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Proxies = new ProxyRepository(client);
Releases = new ReleaseRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Schedulers = new SchedulerRepository(client);
ServerStatus = new ServerStatusRepository(client);
Subscriptions = new SubscriptionRepository(client);
TagSets = new TagSetRepository(client);
Tasks = new TaskRepository(client);
Teams = new TeamsRepository(client);
Tenants = new TenantRepository(client);
TenantVariables = new TenantVariablesRepository(client);
UserRoles = new UserRolesRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
Workers = new WorkerRepository(client);
WorkerPools = new WorkerPoolRepository(client);
}
public void GetAll_ShouldWork()
{
var context = _contextFake.GetContext("GetAll_ShouldWork")
.AddFakeEnvironments();
var environmentsFind = context.Environments.ToList();
var repo = new EnvironmentRepository(context);
var result = repo.GetAll();
Assert.NotNull(result);
Assert.Equal(environmentsFind, result, new EnvironmentComparer());
}
public void FindById_ShouldWork()
{
var context = _contextFake.GetContext("FindById_ShouldWork")
.AddFakeEnvironments();
var environmentFind = context.Environments.Skip(1).First();
var repo = new EnvironmentRepository(context);
var result = repo.FindById(environmentFind.Id);
Assert.NotNull(result);
Assert.Equal(environmentFind, result, new EnvironmentComparer());
}
public void ExistsDirectory_should_return_false_if_directory_does_not_exist()
{
// Arrange
var fixture = new Fixture().Customize(new AutoMoqCustomization());
var envRepos = new EnvironmentRepository();
// Act
var result = envRepos.ExistsDirectory(fixture.Create <string>());
// Assert
Assert.IsFalse(result);
}
public OctopusRepository(IOctopusClient client)
{
this.Client = client;
Feeds = new FeedRepository(client);
Backups = new BackupRepository(client);
Machines = new MachineRepository(client);
MachineRoles = new MachineRoleRepository(client);
MachinePolicies = new MachinePolicyRepository(client);
Subscriptions = new SubscriptionRepository(client);
Environments = new EnvironmentRepository(client);
Events = new EventRepository(client);
FeaturesConfiguration = new FeaturesConfigurationRepository(client);
ProjectGroups = new ProjectGroupRepository(client);
Projects = new ProjectRepository(client);
Proxies = new ProxyRepository(client);
Tasks = new TaskRepository(client);
Users = new UserRepository(client);
VariableSets = new VariableSetRepository(client);
LibraryVariableSets = new LibraryVariableSetRepository(client);
DeploymentProcesses = new DeploymentProcessRepository(client);
Releases = new ReleaseRepository(client);
Deployments = new DeploymentRepository(client);
Certificates = new CertificateRepository(client);
Dashboards = new DashboardRepository(client);
DashboardConfigurations = new DashboardConfigurationRepository(client);
Artifacts = new ArtifactRepository(client);
Interruptions = new InterruptionRepository(client);
ServerStatus = new ServerStatusRepository(client);
UserRoles = new UserRolesRepository(client);
Teams = new TeamsRepository(client);
RetentionPolicies = new RetentionPolicyRepository(client);
Accounts = new AccountRepository(client);
Defects = new DefectsRepository(client);
Lifecycles = new LifecyclesRepository(client);
OctopusServerNodes = new OctopusServerNodeRepository(client);
Channels = new ChannelRepository(client);
ProjectTriggers = new ProjectTriggerRepository(client);
Schedulers = new SchedulerRepository(client);
Tenants = new TenantRepository(client);
TagSets = new TagSetRepository(client);
BuiltInPackageRepository = new BuiltInPackageRepositoryRepository(client);
ActionTemplates = new ActionTemplateRepository(client);
CommunityActionTemplates = new CommunityActionTemplateRepository(client);
}
/// <summary>
/// Get assignments
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static void LoadPlanning(this RAssignedResource resource)
{
var rep = new EnvironmentRepository();
var assignments = rep.GetAssignments(resource.Id);
resource.Planning.AddRange(assignments);
}
