public static async Task <Tenant> ToModel(this TenantResource resource, IOctopusAsyncRepository repository)
{
return(new Tenant(
new ElementIdentifier(resource.Name),
resource.TenantTags.Select(x => new ElementReference(x)).ToArray(),
await resource.ProjectEnvironments.ToModel(repository)));
}
private async void cbTenant_changed(object sender, EventArgs e)
{
try
{
cbSite.DataSource = null;
var scope = (Scope)cbTenant.SelectedItem;
if (scope.Id == -1)
{
return;
}
var tenantResource = new TenantResource();
_tenant = await tenantResource.GetTenantAsync(scope.Id);
var sites = _tenant.Sites;
cbSite.DataSource = sites;
cbSite.DisplayMember = "Name";
panelAPI.Show();
}
catch (Exception exc)
{
LogError(exc);
}
}
private static async Task <string> GetAuthUrl(int tenantId)
{
var tenantResource = new TenantResource();
var tenant = await tenantResource.GetTenantAsync(tenantId).ConfigureAwait(false);
return(HttpHelper.GetUrl(tenant.Domain));
}
public async Task <Tenant> FindTenant(TenantResource tenantResource)
{
return(await context.Tenants.SingleOrDefaultAsync(record =>
record.Name == tenantResource.Name &&
record.Email == tenantResource.Email &&
record.Mobile == tenantResource.Mobile));
}
private static string GetAuthUrl(int tenantId)
{
var tenantResource = new TenantResource();
var tenant = tenantResource.GetTenant(tenantId);
return(HttpHelper.GetUrl(tenant.Domain));
}
public void Exercise_8_Get_Tenant()
{
//create a new tenant resource
var tenantResource = new TenantResource(_apiContext);
//get an instance of the tenant
var tenant = tenantResource.GetTenantAsync(_apiContext.TenantId).Result;
Console.WriteLine($"Domain: { tenant.Domain}");
Console.WriteLine($"Tenant Id: { tenant.Id }");
Console.WriteLine("Tenant Name: " + tenant.Name);
//loop through all master catalogs
foreach (var masterCatalog in tenant.MasterCatalogs)
{
Console.WriteLine($"Master Catalog[{ masterCatalog.Id }]: { masterCatalog.Name }");
masterCatalog.Catalogs.ForEach(c => Console.WriteLine($" Catalog[{ c.Id }]: { c.Name }"));
}
//loop through sites
tenant.Sites.ForEach(site => Console.WriteLine($"Site Name: { site.Name }"));
/*
foreach (var site in tenant.Sites)
{
Console.WriteLine($"Site Name: { site.Name }");
Console.WriteLine("Site Id: " + site.Id);
}
*/
}
public async Task List()
{
TenantResource tenant = await Client.GetTenants().GetAllAsync().FirstOrDefaultAsync(_ => true);
SubscriptionResource subscription = await tenant.GetSubscriptions().GetAllAsync().FirstOrDefaultAsync(_ => true);
string rgName = Recording.GenerateAssetName("testRg-");
ResourceGroupResource rg = await CreateResourceGroup(subscription, rgName);
string vnName1 = Recording.GenerateAssetName("testVn-");
string vnName2 = Recording.GenerateAssetName("testVn-");
string vnName3 = Recording.GenerateAssetName("testVn-");
GenericResource vn1 = await CreateGenericVirtualNetwork(subscription, rg, vnName1);
GenericResource vn2 = await CreateGenericVirtualNetwork(subscription, rg, vnName2);
GenericResource vn3 = await CreateGenericVirtualNetwork(subscription, rg, vnName3);
string resourceLinkName1 = Recording.GenerateAssetName("link-");
string resourceLinkName2 = Recording.GenerateAssetName("link-");
_ = await CreateResourceLink(tenant, vn1, vn2, resourceLinkName1);
_ = await CreateResourceLink(tenant, vn1, vn3, resourceLinkName2);
int count = 0;
await foreach (var resourceLink in tenant.GetResourceLinks(vn1.Id).GetAllAsync())
{
count++;
}
Assert.AreEqual(count, 2);
}
public void ShouldTryLoadTenant()
{
var tenant1 = new TenantResource()
{
Id = "Tenant-1", Name = "Tenant One"
};
Repository.Tenants
.Get(Arg.Is <string[]>(t => t.SequenceEqual(new[] { "Tenant-1" })))
.Returns(new List <TenantResource>()
{
tenant1
});
taskResource.State = TaskState.Success;
CommandLineArgs.Add("--project=" + ProjectName);
CommandLineArgs.Add("--deploymenttimeout=00:00:01");
CommandLineArgs.Add("--deployto=TestEnvironment");
CommandLineArgs.Add("--tenant=*");
CommandLineArgs.Add("--version=latest");
CommandLineArgs.Add("--progress");
CommandLineArgs.Add("--cancelontimeout");
deployReleaseCommand.Execute(CommandLineArgs.ToArray()).GetAwaiter().GetResult();
Repository.Deployments.Received(1).Create(Arg.Any <DeploymentResource>());
Repository.Deployments.Received()
.Create(Arg.Is <DeploymentResource>(dr => dr.TenantId == tenant1.Id && dr.EnvironmentId == "Env-1"));
}
protected override void ProcessRecord()
{
object baseresource = null;
switch (Resource)
{
case "Environment":
baseresource = new EnvironmentResource();
break;
case "Project":
baseresource = new ProjectResource();
break;
case "ProjectGroup":
baseresource = new ProjectGroupResource();
break;
case "NugetFeed":
case "ExternalFeed":
baseresource = new NuGetFeedResource();
break;
case "LibraryVariableSet":
baseresource = new LibraryVariableSetResource();
break;
case "Machine":
case "Target":
baseresource = new MachineResource();
break;
case "Lifecycle":
baseresource = new LifecycleResource();
break;
case "Team":
baseresource = new TeamResource();
break;
case "User":
baseresource = new UserResource();
break;
case "Channel":
baseresource = new ChannelResource();
break;
case "Tenant":
baseresource = new TenantResource();
break;
case "TagSet":
baseresource = new TagSetResource();
break;
}
WriteObject(baseresource);
}
private static TenantResourceExtensionClient GetExtensionClient(TenantResource tenantResource)
{
return(tenantResource.GetCachedClient((client) =>
{
return new TenantResourceExtensionClient(client, tenantResource.Id);
}
));
}
public void GetTenantAsyncTest()
{
var tenantResource = new TenantResource();
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(3));
var tenant = tenantResource.GetTenantAsync(8088, ct: cts.Token).Result;
}
public void SetUp()
{
createAutoDeployOverrideCommand = new CreateAutoDeployOverrideCommand(RepositoryFactory, FileSystem, ClientFactory, CommandOutputProvider);
environment = new EnvironmentResource {
Name = "Production", Id = "Environments-001"
};
project = new ProjectResource("Projects-1", "OctoFx", "OctoFx");
release = new ReleaseResource("1.2.0", "Projects-1", "Channels-1");
release2 = new ReleaseResource("somedockertag", "Projects-1", "Channels-1");
octopusTenant = new TenantResource
{
Id = "Tenants-1",
Name = "Octopus",
ProjectEnvironments = { ["Projects-1"] = new ReferenceCollection("Environments-001") }
};
Repository.Environments.FindByName("Production")
.Returns(
environment
);
Repository.Projects.FindByName("OctoFx")
.Returns(
project
);
Repository.Projects.GetReleaseByVersion(Arg.Any <ProjectResource>(), "1.2.0")
.Returns(
release
);
Repository.Projects.GetReleaseByVersion(Arg.Any <ProjectResource>(), "somedockertag")
.Returns(
release2
);
Repository.Tenants.FindByNames(Arg.Any <IEnumerable <string> >())
.Returns(
new List <TenantResource>
{
octopusTenant
}
);
Repository.Tenants.FindAll(null, Arg.Any <string[]>())
.Returns(
new List <TenantResource>
{
octopusTenant
}
);
Repository.Projects.When(x => x.Modify(Arg.Any <ProjectResource>()))
.Do(x => savedProject = x.Args()[0] as ProjectResource);
}
private static Site GetSite(int tenantId, int siteId)
{
var tenantResource = new TenantResource();
var tenant = tenantResource.GetTenant(tenantId);
var site = tenant.Sites.SingleOrDefault(x => x.Id.Equals(siteId));
if (site == null)
{
throw new Exception(string.Format("{0} not found for tenant {1}", siteId, tenantId));
}
return(site);
}
protected async Task <ResourceLinkResource> CreateResourceLink(TenantResource tenant, GenericResource vn1, GenericResource vn2, string resourceLinkName)
{
ResourceIdentifier resourceLinkId = new ResourceIdentifier(vn1.Id + "/providers/Microsoft.Resources/links/" + resourceLinkName);
ResourceLinkProperties properties = new ResourceLinkProperties(vn2.Id);
ResourceLinkData data = new ResourceLinkData()
{
Properties = properties
};
ArmOperation <ResourceLinkResource> lro = await tenant.GetResourceLinks(resourceLinkId).CreateOrUpdateAsync(WaitUntil.Completed, data);
return(lro.Value);
}
public async Task ClearAndInitialize()
{
if (Mode == RecordedTestMode.Record || Mode == RecordedTestMode.Playback)
{
await InitializeClients();
AsyncPageable <TenantResource> tenantResourcesResponse = ArmClient.GetTenants().GetAllAsync();
List <TenantResource> tenantResources = await tenantResourcesResponse.ToEnumerableAsync();
Tenant = tenantResources.ToArray()[0];
}
}
private static async Task <Site> GetSite(int tenantId, int siteId)
{
var tenantResource = new TenantResource();
var tenant = await tenantResource.GetTenantAsync(tenantId).ConfigureAwait(false);
var site = tenant.Sites.SingleOrDefault(x => x.Id.Equals(siteId));
if (site == null)
{
throw new Exception(string.Format("{0} not found for tenant {1}", siteId, tenantId));
}
return(site);
}
private static string NormaliseTenantName(TenantResource tenant)
{
if (!string.IsNullOrWhiteSpace(tenant.Description))
{
return(tenant.Description);
}
if (StringComparer.InvariantCultureIgnoreCase.Equals(x: tenant.Name, y: "CasinoFair"))
{
return("TTM");
}
return(tenant.Name);
}
void TagCustomerByConvention(TenantResource customer, TagResource[] allTags)
{
var getTag = new Func <string, TagResource>(name => allTags.Single(t => t.Name == name));
var sharedTags = allTags.Where(t => t.Name.StartsWith("Shared"));
customer.WithTag(getTag("External"));
customer.WithTag(customer.IsVIP() ? getTag("VIP") : customer.IsTrial() ? getTag("Trial") : getTag("Standard"));
customer.WithTag(customer.IsVIP() ? getTag("Dedicated") : sharedTags.GetRandom());
customer.WithTag(customer.IsEarlyAdopter() ? getTag("Early adopter") : getTag("Stable"));
if (customer.IsBetaTester())
{
customer.WithTag(getTag("2.x Beta"));
}
}
private static bool Validate(IApiContext apiContext, string formToken, string cookieToken, bool isSubNavLink)
{
try
{
AntiForgery.Validate(cookieToken, formToken);
}
catch (Exception)
{
return(false);
}
//Validate tenant access
if (apiContext.TenantId < 0)
{
return(false);
}
if (String.IsNullOrEmpty(apiContext.HMACSha256))
{
throw new UnauthorizedAccessException();
}
var stringToHash = String.Concat(apiContext.TenantId.ToString(), cookieToken, formToken);
if (!String.IsNullOrEmpty(apiContext.UserId) && isSubNavLink)
{
_logger.Info("Userid:" + apiContext.UserId);
stringToHash = String.Concat(stringToHash, apiContext.UserId);
}
var computedHash = Security.SHA256Generator.GetHash(string.Empty, stringToHash);
if (apiContext.HMACSha256 != computedHash)
{
_logger.Info("Header hash : " + HttpUtility.UrlDecode(apiContext.HMACSha256));
_logger.Info("Computed hash : " + computedHash);
return(false);
}
try
{
var tenantResource = new TenantResource();
var tennat = Task.Factory.StartNew(() => tenantResource.GetTenantAsync(apiContext.TenantId).Result, TaskCreationOptions.LongRunning).Result;
}
catch (ApiException ae)
{
return(false);
}
return(true);
}
public void CreateAndRemoveTenant()
{
#region TenantCreate
var resource = new TenantResource()
{
Name = TestResourceName,
};
var createParameters = new List <CmdletParameter>
{
new CmdletParameter()
{
Name = "Resource",
Resource = resource
}
};
var createPowershell = new CmdletRunspace().CreatePowershellcmdlet(CreateCmdletName, CreateCmdletType, createParameters);
//The fact that the line below doesn't throw is enough to prove that the cmdlet returns the expected object type really. Couldn't figure out a way to make the assert around the Powershell.invoke call
var createResult = createPowershell.Invoke <TenantResource>().FirstOrDefault();
if (createResult != null)
{
Assert.AreEqual(createResult.Name, TestResourceName);
Console.WriteLine("Created resource [{0}] of type [{1}]", createResult.Name, createResult.GetType());
}
#endregion
#region TenantDelete
var removeParameters = new List <CmdletParameter>
{
new CmdletParameter()
{
Name = "Resource",
Resource = createResult
}
};
var removePowershell = new CmdletRunspace().CreatePowershellcmdlet(RemoveCmdletName, RemoveCmdletType);
var removeResult = removePowershell.Invoke <bool>(removeParameters).FirstOrDefault();
Assert.IsTrue(removeResult);
Console.WriteLine("Deleted resource [{0}] of type [{1}]", createResult.Name, createResult.GetType());
#endregion
}
public override string BeforeContentReplacements(string content, TenantResource tenantResource)
{
var portalMasterPageId = new Guid(BuiltInResources.MasterPages.Omnia);
string favicoResourceId = "$newGuid$";
if (tenantResource.Id == portalMasterPageId ||
(tenantResource.Meta != null &&
tenantResource.Meta == Omnia.Foundation.Extensibility.Constants.TenantResource.Meta.PageWithoutMasterPage))
{
content = content.Replace(
"/_layouts/15/images/favicon.ico?rev=40",
"{{CdnUrl}}/resources/" + favicoResourceId + "?tid={{TenantId}}");
}
return(content);
}
public static TenantResource UpdateWith(this TenantResource resource, Tenant model, IOctopusRepository repository)
{
resource.Name = model.Identifier.Name;
resource.TenantTags = new ReferenceCollection(model.TenantTags.Select(x => x.Name));
resource.ProjectEnvironments.Clear();
foreach (var projectEnvironment in model.ProjectEnvironments)
{
var project = repository.Projects.FindByName(projectEnvironment.Key);
var envs = new ReferenceCollection(projectEnvironment.Value.Select(x => repository.Environments.FindByName(x).Id));
resource.ProjectEnvironments.Add(project.Id, envs);
}
return(resource);
}
//[HttpPost]
//[ConfigurationAuthFilter]
public async Task <ActionResult> Index(int?tenantId)
{
if (tenantId.HasValue)
{
var tenantResource = new TenantResource();
var tenant = await tenantResource.GetTenantAsync(tenantId.Value);
}
string cookieToken;
string formToken;
AntiForgery.GetTokens(null, out cookieToken, out formToken);
ViewBag.cookieToken = cookieToken;
ViewBag.formToken = formToken;
return(View());
}
public static async Task <TenantResource> UpdateWith(this TenantResource resource, Tenant model, IOctopusAsyncRepository repository)
{
resource.Name = model.Identifier.Name;
resource.TenantTags = new ReferenceCollection(model.TenantTags.Select(x => x.Name));
resource.ProjectEnvironments.Clear();
foreach (var projectEnvironment in model.ProjectEnvironments)
{
var project = await repository.Projects.FindByName(projectEnvironment.Key);
var environments = await Task.WhenAll(projectEnvironment.Value.Select(async e => await repository.Environments.FindByName(e)));
resource.ProjectEnvironments.Add(project.Id, new ReferenceCollection(environments.Select(e => e.Id)));
}
return(resource);
}
public async Task <IActionResult> CreateTenant([FromBody] TenantResource tenantResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var tenant = await repository.FindTenant(tenantResource);
if (tenant != null)
{
ModelState.AddModelError("Message", "Tenant creation error. Sorry, this tenant already exists!");
return(BadRequest(ModelState));
}
tenant = mapper.Map <TenantResource, Tenant>(tenantResource);
repository.Add(tenant);
await unitOfWork.CompleteAsync();
return(Ok(tenant));
}
/// <summary>
/// Initializes a new instance of the <see cref="ArmClient"/> class.
/// </summary>
/// <param name="credential"> A credential used to authenticate to an Azure Service. </param>
/// <param name="defaultSubscriptionId"> The id of the default Azure subscription. </param>
/// <param name="options"> The client parameters to use in these operations. </param>
/// <exception cref="ArgumentNullException"> If <see cref="TokenCredential"/> is null. </exception>
public ArmClient(TokenCredential credential, string defaultSubscriptionId, ArmClientOptions options)
{
Argument.AssertNotNull(credential, nameof(credential));
options ??= new ArmClientOptions();
ArmEnvironment environment = options.Environment.HasValue ? options.Environment.Value : ArmEnvironment.AzurePublicCloud;
Argument.AssertNotNull(environment.Endpoint, nameof(environment.Endpoint));
Endpoint = environment.Endpoint;
Pipeline = HttpPipelineBuilder.Build(options, new BearerTokenAuthenticationPolicy(credential, environment.DefaultScope));
Diagnostics = options.Diagnostics;
_subscriptionClientDiagnostics = new ClientDiagnostics("Azure.ResourceManager", SubscriptionResource.ResourceType.Namespace, Diagnostics);
CopyApiVersionOverrides(options);
_tenant = new TenantResource(this);
_defaultSubscription = string.IsNullOrWhiteSpace(defaultSubscriptionId) ? null :
new SubscriptionResource(this, SubscriptionResource.CreateResourceIdentifier(defaultSubscriptionId));
}
public async Task CreateOrUpdate()
{
TenantResource tenant = await Client.GetTenants().GetAllAsync().FirstOrDefaultAsync(_ => true);
SubscriptionResource subscription = await tenant.GetSubscriptions().GetAllAsync().FirstOrDefaultAsync(_ => true);
string rgName = Recording.GenerateAssetName("testRg-");
ResourceGroupResource rg = await CreateResourceGroup(subscription, rgName);
string vnName1 = Recording.GenerateAssetName("testVn-");
string vnName2 = Recording.GenerateAssetName("testVn-");
GenericResource vn1 = await CreateGenericVirtualNetwork(subscription, rg, vnName1);
GenericResource vn2 = await CreateGenericVirtualNetwork(subscription, rg, vnName2);
string resourceLinkName = Recording.GenerateAssetName("link-");
ResourceLinkResource resourceLink = await CreateResourceLink(tenant, vn1, vn2, resourceLinkName);
Assert.AreEqual(resourceLinkName, resourceLink.Data.Name);
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await tenant.GetResourceLinks(null).CreateOrUpdateAsync(WaitUntil.Completed, null));
Assert.ThrowsAsync <ArgumentNullException>(async() => _ = await tenant.GetResourceLinks(rg.Id).CreateOrUpdateAsync(WaitUntil.Completed, null));
}
public async Task <Site> GetSite(IApiContext apiContext)
{
if (apiContext.SiteId.GetValueOrDefault(0) == 0)
{
throw new Exception("Site ID is missing in api context");
}
var tenant = apiContext.Tenant;
if (tenant == null)
{
var tenantResource = new TenantResource();
tenant = await tenantResource.GetTenantAsync(apiContext.TenantId);
}
var site = tenant.Sites.SingleOrDefault(x => x.Id == apiContext.SiteId);
if (site == null)
{
throw new Exception("Site " + apiContext.SiteId + " not found for tenant " + tenant.Name);
}
return(site);
}
public async Task <IActionResult> UpdateTenant(int id, [FromBody] TenantResource tenantResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var tenant = await repository.GetTenant(id);
if (tenant == null)
{
return(NotFound());
}
var existingTenant = await repository.FindTenant(tenantResource);
if (existingTenant != null)
{
ModelState.AddModelError("Message", "Tenant update error. Sorry, this tenant already exists!");
return(BadRequest(ModelState));
}
mapper.Map <TenantResource, Tenant>(tenantResource, tenant);
await unitOfWork.CompleteAsync();
return(Ok(tenant));
}
public async Task Delete()
{
TenantResource tenant = await Client.GetTenants().GetAllAsync().FirstOrDefaultAsync(_ => true);
SubscriptionResource subscription = await tenant.GetSubscriptions().GetAllAsync().FirstOrDefaultAsync(_ => true);
string rgName = Recording.GenerateAssetName("testRg-");
ResourceGroupResource rg = await CreateResourceGroup(subscription, rgName);
string vnName1 = Recording.GenerateAssetName("testVn-");
string vnName2 = Recording.GenerateAssetName("testVn-");
GenericResource vn1 = await CreateGenericVirtualNetwork(subscription, rg, vnName1);
GenericResource vn2 = await CreateGenericVirtualNetwork(subscription, rg, vnName2);
string resourceLinkName = Recording.GenerateAssetName("link-");
ResourceLinkResource resourceLink = await CreateResourceLink(tenant, vn1, vn2, resourceLinkName);
await resourceLink.DeleteAsync(WaitUntil.Completed);
var ex = Assert.ThrowsAsync <RequestFailedException>(async() => await resourceLink.GetAsync());
Assert.AreEqual(404, ex.Status);
}
