/// <summary>
/// Checks for the existence of a specific Azure Web Site, if it doesn't exist it will create it.
/// </summary>
/// <param name="client">The <see cref="WebSiteManagementClient"/> that is performing the operation.</param>
/// <param name="webSpace">The name of the Web Space where the site should be.</param>
/// <param name="parameters">The <see cref="WebSiteCreateParameters"/> that define the site we want to create.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task CreateWebSiteIfNotExistsAsync(this WebSiteManagementClient client, string webSpace, WebSiteCreateParameters parameters)
{
Contract.Requires(client != null);
Contract.Requires(!string.IsNullOrWhiteSpace(webSpace));
Contract.Requires(parameters != null);
WebSiteGetResponse service = null;
FlexStreams.BuildEventsObserver.OnNext(new CheckIfExistsEvent(AzureResource.WebSite, parameters.Name));
try
{
service = await client.WebSites.GetAsync(webSpace, parameters.Name, null);
}
catch (CloudException cex)
{
if (cex.Error.Code != "NotFound") throw;
}
if (service != null)
{
FlexStreams.BuildEventsObserver.OnNext(new FoundExistingEvent(AzureResource.WebSite, parameters.Name));
return;
}
await client.WebSites.CreateAsync(webSpace, parameters);
FlexStreams.BuildEventsObserver.OnNext(new ProvisionEvent(AzureResource.WebSite, parameters.Name));
}
public async Task Test_CheckCreateWebSite_WithExistingSite()
{
using (var client = ManagementClient.CreateWebSiteClient())
{
const string webspace = WebSpaceNames.NorthEuropeWebSpace;
var parameters =
new WebSiteCreateParameters
{
Name = "fct-" + Guid.NewGuid().ToString().Split('-').Last(),
ServerFarm = await FlexConfiguration.WebPlanChooser.Choose(client, webspace)
};
try
{
await client.WebSites.CreateAsync(webspace, parameters);
await client.CreateWebSiteIfNotExistsAsync(webspace, parameters);
}
finally
{
client.WebSites.Delete(
webspace,
parameters.Name,
new WebSiteDeleteParameters
{
DeleteAllSlots = true,
DeleteEmptyServerFarm = false,
DeleteMetrics = true
});
}
}
}
/// <summary>
/// You can create a web site by using a POST request that includes the
/// name of the web site and other information in the request body.
/// (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/dn166986.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.WebSites.IWebSiteOperations.
/// </param>
/// <param name='webSpaceName'>
/// The name of the web space.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Create Web Site operation.
/// </param>
/// <returns>
/// The Create Web Space operation response.
/// </returns>
public static WebSiteCreateResponse Create(this IWebSiteOperations operations, string webSpaceName, WebSiteCreateParameters parameters)
{
try
{
return operations.CreateAsync(webSpaceName, parameters).Result;
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Count > 1)
{
throw;
}
else
{
throw ex.InnerException;
}
}
}
/// <summary>
/// Create a website
/// </summary>
/// <param name="webSpaceName"></param>
/// <param name="siteSettings"></param>
/// <param name="connectionStringInfo"></param>
/// <returns></returns>
public WebSite CreateWebSite(string webSpaceName, WebSiteCreateParameters siteSettings,
WebSiteUpdateConfigurationParameters.ConnectionStringInfo connectionStringInfo = null)
{
if (siteSettings == null)
{
throw new ArgumentNullException("siteSettings");
}
siteSettings.Name = string.IsNullOrEmpty(siteSettings.Name)
? Dependencies.TestResourcesCollector.GetUniqueWebSiteName()
: siteSettings.Name.ToLowerInvariant();
if (siteSettings.HostNames == null || siteSettings.HostNames.Count == 0)
{
siteSettings.HostNames = new [] {siteSettings.Name + Dependencies.Subscription.DefaultWebSitesDomainName };
}
if (string.IsNullOrEmpty(siteSettings.WebSpaceName))
{
siteSettings.WebSpaceName = webSpaceName;
}
TestEasyLog.Instance.Info(string.Format("Creating web site '{0}'", siteSettings.Name));
var createWebsiteResult = WebSiteManagementClient.WebSites.CreateAsync(webSpaceName,
siteSettings,
new CancellationToken()).Result;
var newSite = createWebsiteResult.WebSite;
Dependencies.TestResourcesCollector.Remember(AzureResourceType.WebSite, newSite.Name, newSite);
if(connectionStringInfo != null)
{
var existingConfig = CreateWebSiteUpdateParameters(newSite.Name);
var existingConnectionStrings = existingConfig.ConnectionStrings;
if(existingConnectionStrings.All(cs => cs.Name != connectionStringInfo.Name))
{
existingConnectionStrings.Add(connectionStringInfo);
UpdateWebSiteConfig(webSpaceName, newSite.Name, existingConfig);
}
}
return newSite;
}
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);
}
/// <summary>
/// You can create a web site by using a POST request that includes the
/// name of the web site and other information in the request body.
/// (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/dn166986.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.WebSites.IWebSiteOperations.
/// </param>
/// <param name='webSpaceName'>
/// Required. The name of the web space.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Create Web Site operation.
/// </param>
/// <returns>
/// The Create Web Site operation response.
/// </returns>
public static Task<WebSiteCreateResponse> CreateAsync(this IWebSiteOperations operations, string webSpaceName, WebSiteCreateParameters parameters)
{
return operations.CreateAsync(webSpaceName, parameters, CancellationToken.None);
}
/// <summary>
/// You can create a web site by using a POST request that includes the
/// name of the web site and other information in the request body.
/// (see
/// http://msdn.microsoft.com/en-us/library/windowsazure/dn166986.aspx
/// for more information)
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.WebSites.IWebSiteOperations.
/// </param>
/// <param name='webSpaceName'>
/// Required. The name of the web space.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Create Web Site operation.
/// </param>
/// <returns>
/// The Create Web Site operation response.
/// </returns>
public static WebSiteCreateResponse Create(this IWebSiteOperations operations, string webSpaceName, WebSiteCreateParameters parameters)
{
return Task.Factory.StartNew((object s) =>
{
return ((IWebSiteOperations)s).CreateAsync(webSpaceName, parameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
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;
}
/// <summary>
/// Create a new website in production.
/// </summary>
/// <param name="webspaceName">Web space to create site in.</param>
/// <param name="siteToCreate">Details about the site to create.</param>
/// <returns>The created site object</returns>
private Utilities.Site CreateWebsite(string webspaceName, Utilities.SiteWithWebSpace siteToCreate)
{
var options = new WebSiteCreateParameters
{
Name = siteToCreate.Name,
WebSpace = new WebSiteCreateParameters.WebSpaceDetails
{
GeoRegion = siteToCreate.WebSpaceToCreate.GeoRegion,
Name = siteToCreate.WebSpaceToCreate.Name,
Plan = siteToCreate.WebSpaceToCreate.Plan
},
ServerFarm = string.Empty
};
var response = WebsiteManagementClient.WebSites.Create(webspaceName, options);
return response.WebSite.ToSite();
}
private string CreateWebsite()
{
bool validWebsiteNameFound = false;
string websiteName;
do
{
websiteName = GenerateRandomName(TestArtifactType.Website);
WebSiteIsHostnameAvailableResponse nameCheckResponse = WebsiteManagementClient.WebSites.IsHostnameAvailable(websiteName);
validWebsiteNameFound = nameCheckResponse.IsAvailable;
}
while (!validWebsiteNameFound);
WebSiteCreateParameters parameter = new WebSiteCreateParameters();
parameter.Name = websiteName;
parameter.ServerFarm = WebsiteServerFarmName;
parameter.WebSpace = new WebSiteCreateParameters.WebSpaceDetails()
{
GeoRegion = WebsiteGeoRegion,
Name = WebSpaceName,
Plan = WebsitePlanName
};
this.WebsiteManagementClient.WebSites.Create(WebSpaceName, parameter);
RegisterToCleanup(websiteName, _websitesToCleanup);
return websiteName;
}
/// <summary>
/// Create a new website in production.
/// </summary>
/// <param name="webspaceName">Web space to create site in.</param>
/// <param name="siteToCreate">Details about the site to create.</param>
/// <returns>The created site object</returns>
private Utilities.Site CreateWebsite(string webspaceName, Utilities.SiteWithWebSpace siteToCreate)
{
var options = new WebSiteCreateParameters
{
Name = siteToCreate.Name,
WebSpaceName = siteToCreate.WebSpaceToCreate.Name,
WebSpace = new WebSiteCreateParameters.WebSpaceDetails
{
GeoRegion = siteToCreate.WebSpaceToCreate.GeoRegion,
Name = siteToCreate.WebSpaceToCreate.Name,
Plan = siteToCreate.WebSpaceToCreate.Plan
}
};
siteToCreate.HostNames.ForEach(s => options.HostNames.Add(s));
var response = WebsiteManagementClient.WebSites.Create(webspaceName, options);
return response.WebSite.ToSite();
}
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;
}
}
