public WebSiteManagementClient GetWebSiteManagementClient(RecordedDelegatingHandler handler)
{
handler.IsPassThrough = false;
var token = new TokenCloudCredentials(Guid.NewGuid().ToString(), "abc123");
var client = new WebSiteManagementClient(token).WithHandler(handler);
client = client.WithHandler(handler);
return client;
}
static void Main(string[] args)
{
if (args.Length < 1)
{
throw new ArgumentNullException("publish settings informations");
}
SubscriptionCloudCredentials cred = GetCredentials(args[0]);
//WATM
TrafficManagerManagementClient watmClient = new TrafficManagerManagementClient(cred);
string atmDns = "adxsdk12345.trafficmanager.net";
DnsPrefixAvailabilityCheckResponse watmResp =
watmClient.Profiles.CheckDnsPrefixAvailability("adxsdk12345.trafficmanager.net");
Console.WriteLine("Invoke WATM->CheckDnsPrefixAvailability(\'{0}\'). Result: {1}", atmDns, watmResp.Result);
//Compute
ComputeManagementClient computeClient = new ComputeManagementClient(cred);
string hostServiceName = "adxsdk12345";
HostedServiceCheckNameAvailabilityResponse computeResp =
computeClient.HostedServices.CheckNameAvailability(hostServiceName);
Console.WriteLine("Invoke Compute->CheckNameAvailability(\'{0}\'). Result: {1}",
hostServiceName, computeResp.IsAvailable);
//Websites
WebSiteManagementClient websiteClient = new WebSiteManagementClient(cred);
string webSiteName = "adxsdk12345";
WebSiteIsHostnameAvailableResponse webSiteResp = websiteClient.WebSites.IsHostnameAvailable(webSiteName);
Console.WriteLine("Invoke WebSite->IsHostnameAvailable(\'{0}\'). Result: {1}",
webSiteName, webSiteResp.IsAvailable);
//Scheduler
SchedulerManagementClient schedulerClient = new SchedulerManagementClient(cred);
string schedulerCloudServiceName = "foobarrr";
string expectedSchedulerException = string.Format(
"ResourceNotFound: The cloud service with name {0} was not found.", schedulerCloudServiceName);
bool exceptionFromSchedulerServiceOccurred = false;
try
{
schedulerClient.JobCollections.CheckNameAvailability(schedulerCloudServiceName, "doesnotmatter");
}
catch (Exception ex)
{
if (ex.Message == expectedSchedulerException)
{
exceptionFromSchedulerServiceOccurred = true;
Console.WriteLine("Invoke Scheduler->CheckNameAvailability(\'{0}\'). Get back correct exception",
schedulerCloudServiceName, expectedSchedulerException);
}
}
if (!exceptionFromSchedulerServiceOccurred)
{
throw new Exception("we didn't get expected exception message from scheduler service");
}
Console.WriteLine("Smoke test is good");
}
protected override void Clone(ServiceClient <WebSiteManagementClient> client)
{
base.Clone(client);
WebSiteManagementClient management = client as WebSiteManagementClient;
if (management != null)
{
management._credentials = Credentials;
management._baseUri = BaseUri;
management.Credentials.InitializeServiceClient(management);
}
}
public ManagementController(ManagementControllerParameters parameters)
{
_parameters = parameters;
// To authenticate against the Microsoft Azure service management API we require management certificate
// load this from a publish settings file and later use it with the Service Management Libraries
var credential = GetSubscriptionCloudCredentials(parameters.PublishSettingsFilePath);
_webSiteManagementClient = CloudContext.Clients.CreateWebSiteManagementClient(credential);
_webSpaceDetails = CreateWebSpaceDetails(_parameters.GeoRegion);
}
public Program(ScheduledWebJobCreatorParameters parms)
{
// auth
_credential = TokenCredentialHelper<MyPersonalConfiguration>.GetCredentials(
new MyPersonalConfiguration(parms),
parms.subscriptionId);
// create the clients needed
_cloudServiceManagementClient = CloudContext.Clients.CreateCloudServiceManagementClient(_credential);
_webSiteMgmtClient = CloudContext.Clients.CreateWebSiteManagementClient(_credential);
_schedulerMgmtClient = CloudContext.Clients.CreateSchedulerManagementClient(_credential);
}
public EarzyProvisioningCore()
{
//Get credentials from subscription ID & Certificate
var credential = CertificateAuthenticationHelper.GetCredentials(
ConfigurationManager.AppSettings["SubscriptionId"],
ConfigurationManager.AppSettings["Certificate"]);
//Initialize clients
_storageManagementClient = CloudContext.Clients.CreateStorageManagementClient(credential);
_computeManagementClient = CloudContext.Clients.CreateComputeManagementClient(credential);
_webSitesManagementClient = CloudContext.Clients.CreateWebSiteManagementClient(credential);
}
private async Task<HomePageViewModel> GetHomePageViewModel(WebSiteManagementClient client)
{
var viewModel = new HomePageViewModel();
var listWebSpacesResponse = await client.WebSpaces.ListAsync();
foreach (var webSpace in listWebSpacesResponse.WebSpaces)
{
viewModel.WebSpaces.Add(new WebSpaceListItem
{
GeoRegion = webSpace.GeoRegion,
WebSpaceName = webSpace.Name
});
}
return viewModel;
}
private static HomePageViewModel GetHomePageViewModel(WebSiteManagementClient client)
{
var viewModel = new HomePageViewModel();
var webSpaceFunc = new Action<WebSpacesListResponse.WebSpace>((x) =>
{
viewModel.WebSpaces.Add(new WebSpaceListItem
{
GeoRegion = x.GeoRegion,
WebSpaceName = x.Name
});
});
var webSiteListFunc = new Action<WebSpacesListResponse.WebSpace>((webSpace) =>
{
var webSitesInWebSpace = client.WebSpaces.ListWebSites(
webSpace.Name,
new WebSiteListParameters
{
PropertiesToInclude = new List<string>()
});
viewModel.WebSites = webSitesInWebSpace.WebSites.Select(s => new WebSiteRowItem
{
WebSpace = viewModel.WebSpaces.First(a => a.WebSpaceName == webSpace.Name),
WebSiteName = s.Name,
DomainNames = s.HostNames.ToList()
}).ToList();
});
var listWebSpacesResponse = client.WebSpaces.List();
listWebSpacesResponse.WebSpaces.ToList().ForEach(x =>
{
webSpaceFunc(x);
webSiteListFunc(x);
});
return viewModel;
}
public ActionResult NewSite(string SiteName, string WebSpaceName)
{
var cred = GetCredentials();
var client = new WebSiteManagementClient(cred);
var parameters = new WebSiteCreateParameters
{
Name = SiteName,
SiteMode = WebSiteMode.Limited,
ComputeMode = WebSiteComputeMode.Shared,
WebSpaceName = WebSpaceName
};
parameters.HostNames.Add(
string.Format("{0}.azurewebsites.net", SiteName)
);
var result = client.WebSites.Create(WebSpaceName, parameters);
var viewModel = GetHomePageViewModel(client);
return View("Index", viewModel);
}
private async static Task<WebSiteCreateResponse> CreateWebSite(SubscriptionCloudCredentials credentials)
{
Console.WriteLine("Creating new Azure Web Site . . .");
WebSiteCreateResponse response = null;
using (var client = new WebSiteManagementClient(credentials))
{
var webspaces = await client.WebSpaces.ListAsync();
var myWebSpace = webspaces.First(x => x.GeoRegion == LocationNames.EastUS);
var whp = new WebHostingPlanCreateParameters
{
Name = string.Format("{0}_whp", ResourceName.ToLower()),
NumberOfWorkers = 1,
SKU = SkuOptions.Free,
WorkerSize = WorkerSizeOptions.Small
};
var whpCreateResponse = await client.WebHostingPlans.CreateAsync(myWebSpace.Name,whp);
WebSiteCreateParameters siteCreateParameters = new WebSiteCreateParameters
{
Name = string.Format("{0}{1}", ResourceName, new Random().Next(1, 200)),
ServerFarm = whp.Name,
WebSpace = new WebSiteCreateParameters.WebSpaceDetails
{
GeoRegion = LocationNames.EastUS,
Name = myWebSpace.Name,
Plan = "VirtualDedicatedPlan"
}
};
response = await client.WebSites.CreateAsync(myWebSpace.Name, siteCreateParameters);
WebSiteGetPublishProfileResponse publishProfileResult =
await client.WebSites.GetPublishProfileAsync(myWebSpace.Name, siteCreateParameters.Name);
WebSiteGetPublishProfileResponse.PublishProfile profile =
publishProfileResult.PublishProfiles.First(x => x.MSDeploySite != null);
new WebDeployPublishingHelper(
profile.PublishUrl,
profile.MSDeploySite,
profile.UserName,
profile.UserPassword,
WebSitePath).PublishFolder();
}
return response;
}
static List<string> GetWebSiteResourceIds(SubscriptionCloudCredentials cred,
WebSiteManagementClient webSitesMgmtClient)
{
var ret = new List<string>();
var webSpaceListResult = webSitesMgmtClient.WebSpaces.List();
foreach (var webSpace in webSpaceListResult.WebSpaces)
{
var webSiteListResult = webSitesMgmtClient.WebSpaces.ListWebSites(webSpace.Name, new WebSiteListParameters { });
foreach (var webSite in webSiteListResult.WebSites)
{
var webSiteResourceId =
ResourceIdBuilder.BuildWebSiteResourceId(webSpace.Name, webSite.Name);
ret.Add(webSiteResourceId);
}
}
return ret;
}
private async static Task<OperationResponse> RemoveWebSite(SubscriptionCloudCredentials credentials, WebSite webSite)
{
OperationResponse response = null;
using (var client = new WebSiteManagementClient(credentials))
{
response = await client.WebSites.DeleteAsync(webSite.WebSpace, webSite.Name,
new WebSiteDeleteParameters
{
DeleteAllSlots = true,
DeleteEmptyServerFarm = true,
DeleteMetrics = true
});
}
if (response.StatusCode != HttpStatusCode.OK)
{
Console.WriteLine("Failed to delete website.");
}
else
{
Console.WriteLine("Deleted web site '{0}'.", webSite.Name);
}
return response;
}
public async Task<bool> CreateSite(string SiteName,
string WebSpaceName,
string BlogName,
string Description,
string Copywright)
{
try
{
Trace("Getting Credentials");
var cred = ManagementLibraryUtilities.GetCredentials();
var client = new WebSiteManagementClient(cred);
var parameters = new WebSiteCreateParameters
{
Name = SiteName,
SiteMode = WebSiteMode.Limited,
ComputeMode = WebSiteComputeMode.Shared,
WebSpaceName = WebSpaceName
};
parameters.HostNames.Add(
string.Format("{0}.azurewebsites.net", SiteName)
);
Trace("Creating Site {0}", SiteName);
var result = client.WebSites.Create(WebSpaceName, parameters);
Trace("Created {0}. Getting publish profiles.", SiteName);
var profiles = await client.WebSites.GetPublishProfileAsync(WebSpaceName, SiteName);
var webDeployProfile = profiles.First(x => x.MSDeploySite != null);
var webSitePath = HttpContext.Current.Server.MapPath(@"~/App_Data/MiniBlog");
Trace("Deploying site {0}", SiteName);
new WebDeployPublishingHelper(
webDeployProfile.PublishUrl,
webDeployProfile.MSDeploySite,
webDeployProfile.UserName,
webDeployProfile.UserPassword,
webSitePath
)
.PublishFolder();
Trace("Deployed site {0}", SiteName);
Trace("Getting configuration for {0}", SiteName);
// get the site's configuration
var settingsResult = await client.WebSites.GetConfigurationAsync(WebSpaceName, SiteName);
settingsResult.AppSettings.Add("blog:name", BlogName);
settingsResult.AppSettings.Add("blog:description", Description);
settingsResult.AppSettings.Add("blog:copyrightOwner", Copywright);
Trace("Saving site configuration for {0}", SiteName);
// update the site's configuration
await client.WebSites.UpdateConfigurationAsync(WebSpaceName, SiteName,
new WebSiteUpdateConfigurationParameters
{
AppSettings = settingsResult.AppSettings
});
Trace("Site {0} is ready.", SiteName);
return true;
}
catch(Exception ex)
{
Trace("Exception: {0}", ex.ToString());
return false;
}
}
private static void ShowWebSiteMetrics(SubscriptionCloudCredentials cred)
{
using (var webSitesMgmtClient = new WebSiteManagementClient(cred))
{
using (var metricsClient = new MetricsClient(cred))
{
var webSiteResourceIds = GetWebSiteResourceIds(cred, webSitesMgmtClient);
webSiteResourceIds.ForEach(webSiteResourceId =>
{
Console.WriteLine(webSiteResourceId);
var metricDefinitions = ListResourceMetrics(cred, metricsClient, webSiteResourceId);
metricDefinitions.OrderBy(x => x.DisplayName).ToList().ForEach(metric =>
{
var metricValue = GetMetricValue(
cred,
metricsClient,
webSiteResourceId,
metric.Name);
Console.WriteLine("{0} ({1}): {2} ({3})",
metric.DisplayName,
metric.Name,
((metric.Unit == "Bytes")
? metricValue.BytesToString()
: (metric.Unit == "Milliseconds")
? metricValue.MillisecondsToHours()
: metricValue.ToString()),
metric.Unit);
});
});
}
}
}
// Enumerating services, from http://www.scip.be/index.php?Page=ArticlesNET39&Lang=EN
public List<AzureInfo> GetForSubscription(Subscription Subscription)
{
List<AzureInfo> results = new List<AzureInfo>();
CertificateCloudCredentials creds = this.GetCredentials(Subscription);
string subscriptionName;
string subscriptionStatus;
using (ManagementClient mgmtClient = new ManagementClient(creds)) {
SubscriptionGetResponse subscription = mgmtClient.Subscriptions.Get();
subscriptionName = subscription.SubscriptionName;
subscriptionStatus = subscription.SubscriptionStatus.ToString();
}
using (ComputeManagementClient vmClient = new ComputeManagementClient(creds)) {
List<HostedServiceListResponse.HostedService> vms = vmClient.HostedServices.List().ToList();
results.AddRange(
from vm in vms
let vmDetails = vmClient.Deployments.GetByName(vm.ServiceName, vm.ServiceName)
select new AzureInfo {
SubscriptionId = Subscription.SubscriptionId,
SubscriptionName = subscriptionName,
SubscriptionStatus = subscriptionStatus,
AzureType = AzureType.VirtualMachine,
Name = vm.ServiceName, Uri = vm.Uri,
Urls = new List<string> { vmDetails.Uri.OriginalString }.Union((from i in vmDetails.VirtualIPAddresses select i.Address)).ToList(),
CreationStatus = vm.Properties.Status.ToString(),
Status = vmDetails.Status.ToString(),
Location = vm.Properties.Location,
AffinityGroup = vm.Properties.AffinityGroup,
Label = vm.Properties.Label,
Online = vmDetails.Status == DeploymentStatus.Running
}
);
}
using (ComputeManagementClient vmClient = new ComputeManagementClient(creds)) {
List<VirtualMachineDiskListResponse.VirtualMachineDisk> disks = vmClient.VirtualMachineDisks.ListDisks().ToList();
results.AddRange(
from disk in disks
select new AzureInfo {
SubscriptionId = Subscription.SubscriptionId,
SubscriptionName = subscriptionName,
SubscriptionStatus = subscriptionStatus,
AzureType = AzureType.VirtualDisk,
Name = disk.Name,
Location = disk.Location,
AffinityGroup = disk.AffinityGroup,
Label = disk.Label,
MaxSizeGb = disk.LogicalSizeInGB,
TypeDescription = disk.OperatingSystemType,
HostedServiceName = disk.UsageDetails.HostedServiceName,
DeploymentName = disk.UsageDetails.DeploymentName,
VirtualMachineName = disk.UsageDetails.RoleName,
Urls = new List<string>{disk.MediaLinkUri.OriginalString},
Status = "Running",
Online = !(disk.IsCorrupted ?? false)
}
);
}
using (WebSiteManagementClient siteClient = new WebSiteManagementClient(creds)) {
WebSpacesListResponse spaces = siteClient.WebSpaces.List();
results.AddRange(
from space in spaces
let sites = siteClient.WebSpaces.ListWebSites(space.Name, new WebSiteListParameters { PropertiesToInclude = {}})
from site in sites
let ws = siteClient.WebSites.Get(space.Name, site.Name, new WebSiteGetParameters()).WebSite
select new AzureInfo {
SubscriptionId = Subscription.SubscriptionId,
SubscriptionName = subscriptionName,
SubscriptionStatus = subscriptionStatus,
AzureType = AzureType.WebApp,
Name = site.Name,
Uri = ws.Uri,
Urls = site.HostNames.ToList(),
Status = (site.RuntimeAvailabilityState != WebSiteRuntimeAvailabilityState.Normal) ? (site.RuntimeAvailabilityState ?? WebSiteRuntimeAvailabilityState.NotAvailable).ToString() : site.State,
CreationStatus = "Created",
Location = space.Name,
TypeDescription = site.ServerFarm, // == ws.ServerFarm
Online = (site.Enabled ?? false) && (site.RuntimeAvailabilityState == WebSiteRuntimeAvailabilityState.Normal) && (site.State == "Running")
}
);
}
using (StorageManagementClient storageClient = CloudContext.Clients.CreateStorageManagementClient(creds)) {
List<StorageAccount> storages = storageClient.StorageAccounts.List().ToList();
results.AddRange(
from storage in storages
select new AzureInfo {
SubscriptionId = Subscription.SubscriptionId,
SubscriptionName = subscriptionName,
SubscriptionStatus = subscriptionStatus,
AzureType = AzureType.Storage,
Name = storage.Name,
Uri = storage.Uri,
Location = storage.Properties.Location,
AffinityGroup = storage.Properties.AffinityGroup,
Label = storage.Properties.Label,
TypeDescription = storage.Properties.Description,
Status = "Running",
Online = storage.Properties.Status == StorageAccountStatus.Created,
CreationStatus = storage.Properties.Status.ToString(),
Redundancy = storage.Properties.AccountType,
Urls = (
from i in storage.Properties.Endpoints
select i.OriginalString
).ToList()
}
);
}
using (SqlManagementClient sqlClient = CloudContext.Clients.CreateSqlManagementClient(creds)) {
List<Server> servers = sqlClient.Servers.List().ToList();
results.AddRange(
from server in servers
let dbs = sqlClient.Databases.List(server.Name).ToList()
from db in dbs
select new AzureInfo {
SubscriptionId = Subscription.SubscriptionId,
SubscriptionName = subscriptionName,
SubscriptionStatus = subscriptionStatus,
AzureType = AzureType.SqlDatabase,
Name = db.Name,
Status = server.State,
CreationStatus = server.State,
Online = server.State == "Ready",
Location = server.Location,
TypeDescription = db.Edition,
MaxSizeGb = db.MaximumDatabaseSizeInGB,
ServerName = server.Name,
HostedServiceName = server.FullyQualifiedDomainName,
}
);
};
return results;
}
public string SetWebApp(Subscription Subscription, string SpaceName, string SiteName, bool SetToRunning)
{
CertificateCloudCredentials creds = this.GetCredentials(Subscription);
using (WebSiteManagementClient siteClient = new WebSiteManagementClient(creds)) {
WebSiteGetResponse s = siteClient.WebSites.Get(SpaceName, SiteName, new WebSiteGetParameters());
WebSite ws = s.WebSite;
if (ws.State != "Running" && SetToRunning) {
// Start it
siteClient.WebSites.Update(SpaceName, SiteName, new WebSiteUpdateParameters {
State = "Running",
HostNames = ws.HostNames
});
}
if (ws.State != "Stopped" && !SetToRunning) {
// Stop it
siteClient.WebSites.Update(SpaceName, SiteName, new WebSiteUpdateParameters {
State = "Stopped",
HostNames = ws.HostNames
});
}
// What is it now?
s = siteClient.WebSites.Get(SpaceName, SiteName, new WebSiteGetParameters());
return s.WebSite.State;
}
}
public void TestClientInitialization()
{
var tokenCredentials = new TokenCloudCredentials("123", "abc");
var fakeClient = new WebSiteManagementClient(tokenCredentials);
Assert.IsNotNull(fakeClient);
}
/// <summary>
/// Provisions all the web sites in the <see cref="IEnumerable{T}"/> of <see cref="AzureWebSite"/>.
/// </summary>
/// <param name="sites">The list of <see cref="AzureWebSite"/> to provision.</param>
/// <param name="client">The <see cref="WebSiteManagementClient"/> that is performing the operation.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task ProvisionAllAsync(this IEnumerable<AzureWebSite> sites, WebSiteManagementClient client)
{
Contract.Requires(sites != null);
Contract.Requires(client != null);
var tasks = sites.Select(
async s =>
{
await client.CreateWebSiteIfNotExistsAsync(s);
});
await Task.WhenAll(tasks);
}
/// <summary>
/// Provisions all the components in the <see cref="DevOpsFlexDbContext"/>.
/// </summary>
/// <param name="context">The database context that we want to provision components from.</param>
/// <param name="subscriptionId">The subscription Id where we want to provision in.</param>
/// <param name="settingsPath">The path to the settings file with the management certificate.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task ProvisionAllAsync(this DevOpsFlexDbContext context, string subscriptionId, string settingsPath)
{
Contract.Requires(context != null);
Contract.Requires(string.IsNullOrEmpty(subscriptionId));
Contract.Requires(string.IsNullOrEmpty(settingsPath));
var azureSubscription = new AzureSubscription(settingsPath, subscriptionId);
var azureCert = new X509Certificate2(Convert.FromBase64String(azureSubscription.ManagementCertificate));
using (var computeClient = new ComputeManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)))
using (var networkClient = new NetworkManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)))
using (var sbClient = new ServiceBusManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)))
using (var sqlClient = new SqlManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)))
using (var storageClient = new StorageManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)))
using (var webSiteClient = new WebSiteManagementClient(new CertificateCloudCredentials(subscriptionId, azureCert)))
{
var tasks = new[]
{
context.Components.OfType<AzureCloudService>().ToList().ProvisionAllAsync(computeClient),
context.Components.OfType<AzureCloudService>().ToList().ReserveAllIpsAsync(networkClient),
context.Components.OfType<AzureServiceBusNamespace>().ToList().ProvisionAllAsync(sbClient),
context.Components.OfType<SqlAzureDb>().ToList().ProvisionAllAsync(sqlClient),
context.Components.OfType<AzureStorageContainer>().ToList().ProvisionAllAsync(storageClient),
context.Components.OfType<AzureWebSite>().ToList().ProvisionAllAsync(webSiteClient)
};
await Task.WhenAll(tasks);
}
}
