public static void UpdateSubscriptions(this PSCmdlet cmdlet, IDictionary <string, SubscriptionData> subscriptionsData, string subscriptionDataFile)
{
GlobalComponents globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, subscriptionDataFile);
globalComponents.SubscriptionManager.Subscriptions = subscriptionsData;
globalComponents.SaveSubscriptions();
}
public static void SetDefaultSubscription(this PSCmdlet cmdlet, string subscriptionName, string subscriptionDataFile)
{
GlobalComponents globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, subscriptionDataFile);
if (globalComponents.Subscriptions.Count > 1)
{
var defaultSubscription = globalComponents.Subscriptions.Values.FirstOrDefault(subscription => subscription.IsDefault);
if (defaultSubscription != null)
{
defaultSubscription.IsDefault = false;
}
if (subscriptionName != null)
{
defaultSubscription = globalComponents.Subscriptions.Values.First(subscription => subscription.SubscriptionName == subscriptionName);
defaultSubscription.IsDefault = true;
}
else
{
defaultSubscription = globalComponents.Subscriptions.Values.First();
defaultSubscription.IsDefault = true;
}
globalComponents.SaveSubscriptions();
}
}
public static SubscriptionData GetCurrentSubscription(this PSCmdlet cmdlet)
{
// Check if there is a current subscription already set
var currentSubscription = SessionManager.GetVariable(cmdlet, Constants.CurrentSubscriptionEnvironmentVariable) as SubscriptionData;
if (currentSubscription == null)
{
try
{
// Check if there is a default subscription available
GlobalComponents globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory);
currentSubscription =
globalComponents.Subscriptions.Values.FirstOrDefault(subscription => subscription.IsDefault);
if (currentSubscription != null)
{
// Set the default subscription to be the new current subscription
SessionManager.SetVariable(cmdlet, Constants.CurrentSubscriptionEnvironmentVariable,
currentSubscription);
}
}
catch (FileNotFoundException)
{
return(null);
}
}
return(currentSubscription);
}
internal void RemoveSubscriptionProcess(string subscriptionName, string subscriptionsDataFile)
{
// Import subscriptions from subscriptions file
var globalComponents = GlobalComponents.Load(
GlobalPathInfo.GlobalSettingsDirectory,
this.ResolvePath(subscriptionsDataFile));
if (globalComponents.Subscriptions.ContainsKey(subscriptionName))
{
var subscription = globalComponents.Subscriptions[subscriptionName];
// Warn the user if the removed subscription is the default one.
if (subscription.IsDefault)
{
this.SafeWriteWarning(Resources.RemoveDefaultSubscription);
}
// Warn the user if the removed subscription is the current one.
if (this.GetCurrentSubscription() == subscription)
{
this.SafeWriteWarning(Resources.RemoveCurrentSubscription);
}
globalComponents.Subscriptions.Remove(subscriptionName);
globalComponents.SaveSubscriptions();
}
else
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidSubscription, subscriptionName));
}
}
public PublishContext(
ServiceSettings settings,
string packagePath,
string configPath,
string serviceName,
string deploymentName,
string rootPath)
{
Validate.ValidateNullArgument(settings, Resources.InvalidServiceSettingMessage);
Validate.ValidateStringIsNullOrEmpty(packagePath, "packagePath");
Validate.ValidateFileFull(configPath, Resources.ServiceConfiguration);
Validate.ValidateStringIsNullOrEmpty(serviceName, "serviceName");
this.ServiceSettings = settings;
this.PackagePath = packagePath;
this.ConfigPath = configPath;
this.RootPath = rootPath;
this.ServiceName = serviceName;
this.DeploymentName = string.IsNullOrEmpty(deploymentName) ?
char.ToLower(ServiceSettings.Slot[0]) + DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-ffff")
: deploymentName;
if (!string.IsNullOrEmpty(settings.Subscription))
{
GlobalComponents globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory);
SubscriptionId = globalComponents.GetSubscriptionId(settings.Subscription);
}
else
{
throw new ArgumentNullException("settings.Subscription", Resources.InvalidSubscriptionNameMessage);
}
}
public DeploymentSettings(ServiceSettings settings, string packagePath, string configPath, string label, string deploymentName)
{
Validate.ValidateNullArgument(settings, Resources.InvalidServiceSettingMessage);
Validate.ValidateFileFull(packagePath, Resources.Package);
Validate.ValidateFileFull(configPath, Resources.ServiceConfiguration);
Validate.ValidateStringIsNullOrEmpty(label, "Label");
Validate.ValidateStringIsNullOrEmpty(deploymentName, "Deployment name");
this.ServiceSettings = settings;
this.PackagePath = packagePath;
this.ConfigPath = configPath;
this.Label = label;
this.DeploymentName = deploymentName;
if (!string.IsNullOrEmpty(settings.Subscription))
{
GlobalComponents globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory);
SubscriptionId = globalComponents.GetSubscriptionId(settings.Subscription);
}
else
{
throw new ArgumentNullException("settings.Subscription", Resources.InvalidSubscriptionNameMessage);
}
}
public bool RemoveAzureServiceProcess(string rootName, string inSubscription, string inServiceName)
{
string serviceName;
ServiceSettings settings = GetDefaultSettings(rootName, inServiceName, null, null, null, inSubscription,
out serviceName);
if (string.IsNullOrEmpty(serviceName))
{
throw new Exception(Resources.InvalidServiceName);
}
if (!Force.IsPresent &&
!ShouldProcess("", string.Format(Resources.RemoveServiceWarning, serviceName),
Resources.ShouldProcessCaption))
{
return(false);
}
if (!string.IsNullOrEmpty(settings.Subscription))
{
var globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory);
CurrentSubscription = globalComponents.Subscriptions.Values.First(
sub => sub.SubscriptionName == settings.Subscription);
}
SafeWriteObjectWithTimestamp(Resources.RemoveServiceStartMessage, serviceName);
SafeWriteObjectWithTimestamp(Resources.RemoveDeploymentMessage);
StopAndRemove(rootName, serviceName, CurrentSubscription.SubscriptionName, ArgumentConstants.Slots[Slot.Production]);
StopAndRemove(rootName, serviceName, CurrentSubscription.SubscriptionName, ArgumentConstants.Slots[Slot.Staging]);
SafeWriteObjectWithTimestamp(Resources.RemoveServiceMessage);
RemoveService(serviceName);
return(true);
}
public void GlobalComponentsLoadInvalidPublishSettingsSchemaFail()
{
Testing.AssertThrows <FileNotFoundException>(
() => GlobalComponents.Load("DoesNotExistDirectory"),
ex =>
{
Assert.AreEqual <string>(ex.Message, Resources.GlobalComponents_Load_PublishSettingsNotFound);
Assert.IsFalse(Directory.Exists(Data.AzureAppDir));
});
}
public void GlobalComponentsCreateNewNullAzureDirectoryFail()
{
foreach (string fileName in Data.ValidSubscriptionsData)
{
try
{
GlobalComponents.Load(null, fileName);
Assert.Fail("No exception thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ArgumentException);
Assert.IsFalse(Directory.Exists(Data.AzureAppDir));
}
}
}
public void GlobalComponentsLoadExistingEmptyAzureDirectoryFail()
{
foreach (string fileName in Data.ValidPublishSettings)
{
try
{
GlobalComponents.Load("fake");
Assert.Fail("No exception thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is FileNotFoundException);
Assert.AreEqual <string>(ex.Message, Resources.GlobalComponents_Load_PublishSettingsNotFound);
Assert.IsFalse(Directory.Exists(Data.AzureAppDir));
}
}
}
public void GlobalComponentsCreateNewEmptyAzureDirectoryFail()
{
foreach (string fileName in Data.ValidSubscriptionsData)
{
try
{
GlobalComponents.Load(string.Empty, fileName);
Assert.Fail("No exception thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ArgumentException);
Assert.AreEqual <string>(ex.Message, string.Format(Resources.InvalidOrEmptyArgumentMessage, Resources.AzureDirectoryName));
Assert.IsFalse(Directory.Exists(Data.AzureAppDir));
}
}
}
public void RemoveSubscriptionProcess(string subscriptionName, string subscriptionsDataFile)
{
// Import subscriptions from subscriptions file
var globalComponents = GlobalComponents.Load(
GlobalPathInfo.GlobalSettingsDirectory,
this.ResolvePath(subscriptionsDataFile));
if (globalComponents.Subscriptions.ContainsKey(subscriptionName))
{
var subscription = globalComponents.Subscriptions[subscriptionName];
// Warn the user if the removed subscription is the default one.
if (subscription.IsDefault)
{
WriteWarning(Resources.RemoveDefaultSubscription);
// Change default to another one
var newSubscriptionDefault = globalComponents.Subscriptions.Values.FirstOrDefault(s => !s.SubscriptionId.Equals(subscription.SubscriptionId));
if (newSubscriptionDefault != null)
{
newSubscriptionDefault.IsDefault = true;
}
}
// Warn the user if the removed subscription is the current one.
SubscriptionData currentSubscription = this.GetCurrentSubscription();
if (currentSubscription != null && currentSubscription.SubscriptionId.Equals(subscription.SubscriptionId))
{
WriteWarning(Resources.RemoveCurrentSubscription);
// Clear current subscription to another one
this.ClearCurrentSubscription();
}
globalComponents.Subscriptions.Remove(subscriptionName);
globalComponents.SaveSubscriptions();
if (PassThru.IsPresent)
{
WriteObject(true);
}
}
else
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidSubscription, subscriptionName));
}
}
public void GlobalComponentsLoadExistingNullAzureDirectoryFail()
{
foreach (string fileName in Data.ValidPublishSettings)
{
try
{
GlobalComponents.Load(null);
Assert.Fail("No exception thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ArgumentException);
Assert.AreEqual <string>("Value cannot be null. Parameter name: 'azurePath'", ex.Message);
Assert.IsFalse(Directory.Exists(Data.AzureAppDir));
}
}
}
public void GlobalComponentsLoadExisting()
{
for (var i = 0; i < Data.ValidPublishSettings.Count; i++)
{
var publishSettingsFile = Data.ValidPublishSettings[i];
// Prepare
new ImportAzurePublishSettingsCommand().ImportSubscriptionProcess(publishSettingsFile, null);
GlobalComponents globalComponents = GlobalComponents.Load(Data.AzureAppDir);
PublishData actualPublishSettings = General.DeserializeXmlFile <PublishData>(Path.Combine(Data.AzureAppDir, Resources.PublishSettingsFileName));
PublishData expectedPublishSettings = General.DeserializeXmlFile <PublishData>(publishSettingsFile);
// Assert
AzureAssert.AreEqualGlobalComponents(new GlobalPathInfo(Data.AzureAppDir), expectedPublishSettings, globalComponents);
// Clean
globalComponents.DeleteGlobalComponents();
}
}
public void TestRemoveNonDefaultSubscriptionProcess()
{
for (var i = 0; i < Data.ValidPublishSettings.Count; i++)
{
var targetFile = Path.Combine(Directory.GetParent(Data.ValidSubscriptionsData[i]).FullName, "removeagain" + Path.GetFileName(Data.ValidSubscriptionsData[i]));
File.Copy(Data.ValidSubscriptionsData[i], targetFile, true);
var globalComponents = GlobalComponents.CreateFromPublishSettings(GlobalPathInfo.GlobalSettingsDirectory, targetFile, Data.ValidPublishSettings[i]);
var removeSubscriptionCommand = new RemoveAzureSubscriptionCommand();
removeSubscriptionCommand.RemoveSubscriptionProcess("mysub2", targetFile);
var subscriptionsManager = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, targetFile);
Assert.IsFalse(subscriptionsManager.Subscriptions.Values.Any(subscription => subscription.SubscriptionName == "mysub2"));
Assert.IsTrue(subscriptionsManager.Subscriptions.Values.Any(subscription => subscription.IsDefault));
// Clean
globalComponents.DeleteGlobalComponents();
}
}
public void GlobalComponentsLoadExistingInvalidDirectoryNameAzureDirectoryFail()
{
foreach (string fileName in Data.ValidPublishSettings)
{
foreach (string invalidDirectoryName in Data.InvalidServiceRootName)
{
try
{
GlobalComponents.Load(invalidDirectoryName);
Assert.Fail("No exception thrown");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ArgumentException);
Assert.AreEqual <string>(ex.Message, "Illegal characters in path.");
Assert.IsFalse(Directory.Exists(Data.AzureAppDir));
}
}
}
}
public static void SetCurrentSubscription(this PSCmdlet cmdlet, string subscriptionName, string subscriptionDataFile)
{
if (subscriptionName == null)
{
throw new ArgumentNullException("subscriptionName", Resources.InvalidSubscriptionName);
}
var globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, subscriptionDataFile);
SubscriptionData subscriptionData;
if (!globalComponents.Subscriptions.TryGetValue(subscriptionName, out subscriptionData))
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
Resources.InvalidSubscription,
subscriptionName));
}
SetCurrentSubscription(cmdlet, subscriptionData);
}
public void TestCreateSubscriptionNoImport()
{
var setSubscriptionCommand = new SetSubscriptionCommandStub();
// Check that we cant get a current subscription as there is no working directory
Assert.IsNull(setSubscriptionCommand.GetCurrentSubscription());
// Create a new subscription and a new working directory implicitly.
var publishSettings = General.DeserializeXmlFile <PublishData>(Data.ValidPublishSettings.First(), string.Empty);
var certificate = new X509Certificate2(Convert.FromBase64String(publishSettings.Items[0].ManagementCertificate), string.Empty);
setSubscriptionCommand.SetSubscriptionProcess("CommonSettings", "newSubscription", "newSubscriptionId", certificate, "newEndpoint", null, null, null);
var updatedSubscription = setSubscriptionCommand.GetSubscriptions(null).Values.First(subscription => subscription.SubscriptionName == "newSubscription");
Assert.AreEqual("newSubscriptionId", updatedSubscription.SubscriptionId);
Assert.AreEqual("newEndpoint", updatedSubscription.ServiceEndpoint);
// Clean
var globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory);
globalComponents.DeleteGlobalComponents();
}
public virtual string SetDeploymentStatusProcess(string rootPath, string newStatus, string slot, string subscription, string serviceName)
{
if (!string.IsNullOrEmpty(subscription))
{
var globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory);
CurrentSubscription = globalComponents.Subscriptions.Values.First(
sub => sub.SubscriptionName == subscription);
}
string result = CheckDeployment(newStatus, serviceName, slot);
if (string.IsNullOrEmpty(result))
{
SetDeployment(newStatus, serviceName, slot);
var deploymentStatusCommand = new GetDeploymentStatus(Channel)
{
ShareChannel = ShareChannel, CurrentSubscription = CurrentSubscription
};
deploymentStatusCommand.WaitForState(newStatus, rootPath, serviceName, slot, CurrentSubscription.SubscriptionName);
}
return(result);
}
public void TestSetDefaultSubscription()
{
var globalComponents = GlobalComponents.CreateFromPublishSettings(GlobalPathInfo.GlobalSettingsDirectory, null, Data.ValidPublishSettings.First());
var newPath = Path.Combine(GlobalPathInfo.GlobalSettingsDirectory, "test.xml");
File.Copy(Data.ValidSubscriptionsData[0], newPath, true);
var cmdletStub = new CmdletStub();
var subscriptions = cmdletStub.GetSubscriptions(Data.ValidSubscriptionsData[0]);
var newDefaultSubscription = subscriptions.Values.First(subscription => !subscription.IsDefault);
cmdletStub.SetDefaultSubscription(newDefaultSubscription.SubscriptionName, newPath);
// Test - reimport and make sure the current subscription after import is the correct one
var subscriptionsManager = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, newPath).SubscriptionManager;
var defaultSubscription = subscriptionsManager.Subscriptions.Values.First(subscription => subscription.IsDefault);
Assert.AreEqual(newDefaultSubscription.SubscriptionName, defaultSubscription.SubscriptionName);
globalComponents.DeleteGlobalComponents();
}
public void GlobalComponentsLoadIgnoresPublishExisting()
{
var publishSettingsFile = Data.ValidPublishSettings.First();
var subscriptionDataFile = Data.ValidSubscriptionsData.First();
var outputSubscriptionDataFile = Path.Combine(Directory.GetParent(subscriptionDataFile).FullName, "outputNoPublish.xml");
File.Copy(subscriptionDataFile, outputSubscriptionDataFile);
// Create with both an existing ouput subscription data file and the publish settings file
GlobalComponents globalComponents = GlobalComponents.CreateFromPublishSettings(Data.AzureAppDir, outputSubscriptionDataFile, publishSettingsFile);
Assert.AreEqual(5, globalComponents.Subscriptions.Count);
// Remove one of the subscriptions from the publish settings file
globalComponents.Subscriptions.Remove("TestSubscription1");
globalComponents.SaveSubscriptions();
// Load and make sure the subscription is still gone although it still is in the publish settings file
globalComponents = GlobalComponents.Load(Data.AzureAppDir, outputSubscriptionDataFile);
Assert.AreEqual(4, globalComponents.Subscriptions.Count);
// Clean
globalComponents.DeleteGlobalComponents();
}
/// <summary>
/// Executes the set subscription cmdlet operation.
/// </summary>
/// <param name="parameterSetName">The type of set operation to perform.</param>
/// <param name="subscriptionName">The existing or new subscription name.</param>
/// <param name="subscriptionId">The subscription identifier for the existing or new subscription.</param>
/// <param name="certificate">The certificate for the existing or new subscription.</param>
/// <param name="serviceEndpoint">The service endpoint for the existing or new subscription.</param>
/// <param name="defaultSubscription">The subscription name for the new subscription.</param>
/// <param name="currentStorageAccount">The current storage account.</param>
/// <param name="subscriptionDataFile">The input/output subscription data file to use.</param>
internal void SetSubscriptionProcess(string parameterSetName, string subscriptionName, string subscriptionId, X509Certificate2 certificate, string serviceEndpoint, string defaultSubscription, string currentStorageAccount, string subscriptionDataFile)
{
SubscriptionData currentSubscription = this.GetCurrentSubscription();
if (currentSubscription != null &&
!String.IsNullOrEmpty(currentSubscription.ServiceEndpoint) &&
String.IsNullOrEmpty(serviceEndpoint))
{
// If the current subscription already has a service endpoint do not overwrite if not specified
serviceEndpoint = currentSubscription.ServiceEndpoint;
}
else if (String.IsNullOrEmpty(serviceEndpoint))
{
// No current subscription and nothing specified initialize with the default
serviceEndpoint = ConfigurationConstants.ServiceManagementEndpoint;
}
if (parameterSetName == "DefaultSubscription")
{
// Set a new default subscription
this.SetDefaultSubscription(defaultSubscription, subscriptionDataFile);
this.SetCurrentSubscription(defaultSubscription, subscriptionDataFile);
}
else if (parameterSetName == "ResetDefaultSubscription")
{
// Reset default subscription
this.SetDefaultSubscription(null, subscriptionDataFile);
}
else
{
// Update or create a new subscription
GlobalComponents globalComponents;
try
{
globalComponents = GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, subscriptionDataFile);
}
catch (FileNotFoundException)
{
// assume that import has never been ran and just create it.
globalComponents = GlobalComponents.Create(GlobalPathInfo.GlobalSettingsDirectory,
subscriptionDataFile,
certificate,
serviceEndpoint);
}
SubscriptionData subscription = globalComponents.Subscriptions.ContainsKey(subscriptionName)
? globalComponents.Subscriptions[subscriptionName]
: new SubscriptionData {
SubscriptionName = subscriptionName, IsDefault = (globalComponents.Subscriptions.Count == 0)
};
if (parameterSetName == "CommonSettings")
{
SetCommonSettingsProcess(subscription, subscriptionId, certificate, serviceEndpoint, currentStorageAccount);
}
// Create or update
globalComponents.Subscriptions[subscription.SubscriptionName] = subscription;
globalComponents.SaveSubscriptions(subscriptionDataFile);
currentSubscription = this.GetCurrentSubscription();
if (currentSubscription == null || string.Compare(currentSubscription.SubscriptionName, subscription.SubscriptionName, StringComparison.OrdinalIgnoreCase) == 0)
{
// If the user modifies a subscription using Set-AzureSubscription, but doesn't call Select-AzureSubscription
// it is not immediately reflected in the code. This takes into account if they modify the current subscription
// that they shouldn't have to call Select-AzureSubscription once again to have the values updated in session.
this.SetCurrentSubscription(subscription.SubscriptionName, subscriptionDataFile);
if (currentSubscription != null)
{
WriteMessage(string.Format(
Resources.UpdatedSettings,
subscriptionName,
currentSubscription.SubscriptionName));
}
}
}
}
public void RemovePublishSettingsProcess(string azureSdkDirPath)
{
GlobalComponents.Load(azureSdkDirPath).DeleteGlobalComponents();
}
public static IDictionary <string, SubscriptionData> GetSubscriptions(this PSCmdlet cmdlet, string subscriptionDataFile)
{
return(GlobalComponents.Load(GlobalPathInfo.GlobalSettingsDirectory, subscriptionDataFile).Subscriptions);
}