public List<AzureSubscription> GetSubscriptions(AzureProfile profile)
{
string subscriptions = string.Empty;
List<AzureSubscription> subscriptionsList = new List<AzureSubscription>();
if (Properties.ContainsKey(Property.Subscriptions))
{
subscriptions = Properties[Property.Subscriptions];
}
foreach (var subscription in subscriptions.Split(new [] {','}, StringSplitOptions.RemoveEmptyEntries))
{
try
{
Guid subscriptionId = new Guid(subscription);
Debug.Assert(profile.Subscriptions.ContainsKey(subscriptionId));
subscriptionsList.Add(profile.Subscriptions[subscriptionId]);
}
catch
{
// Skip
}
}
return subscriptionsList;
}
public List <AzureSubscription> GetSubscriptions(AzureProfile profile)
{
string subscriptions = string.Empty;
List <AzureSubscription> subscriptionsList = new List <AzureSubscription>();
if (Properties.ContainsKey(Property.Subscriptions))
{
subscriptions = Properties[Property.Subscriptions];
}
foreach (var subscription in subscriptions.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
try
{
Guid subscriptionId = new Guid(subscription);
Debug.Assert(profile.Subscriptions.ContainsKey(subscriptionId));
subscriptionsList.Add(profile.Subscriptions[subscriptionId]);
}
catch
{
// Skip
}
}
return(subscriptionsList);
}
public bool Deserialize(string contents, AzureProfile profile)
{
ProfileData data = null;
Debug.Assert(profile != null);
DeserializeErrors = new List<string>();
DataContractSerializer serializer = new DataContractSerializer(typeof(ProfileData));
using (MemoryStream s = new MemoryStream(Encoding.UTF8.GetBytes(contents ?? "")))
{
data = (ProfileData)serializer.ReadObject(s);
}
if (data != null)
{
foreach (AzureEnvironmentData oldEnv in data.Environments)
{
profile.Environments[oldEnv.Name] = oldEnv.ToAzureEnvironment();
}
List<AzureEnvironment> envs = profile.Environments.Values.ToList();
foreach (AzureSubscriptionData oldSubscription in data.Subscriptions)
{
try
{
var newSubscription = oldSubscription.ToAzureSubscription(envs);
if (newSubscription.Account == null)
{
continue;
}
var newAccounts = oldSubscription.ToAzureAccounts();
foreach (var account in newAccounts)
{
if (profile.Accounts.ContainsKey(account.Id))
{
profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Tenants,
account.GetPropertyAsArray(AzureAccount.Property.Tenants));
profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Subscriptions,
account.GetPropertyAsArray(AzureAccount.Property.Subscriptions));
}
else
{
profile.Accounts[account.Id] = account;
}
}
profile.Subscriptions[newSubscription.Id] = newSubscription;
}
catch (Exception ex)
{
// Skip subscription if failed to load
DeserializeErrors.Add(ex.Message);
}
}
}
return DeserializeErrors.Count == 0;
}
public string Serialize(AzureProfile profile)
{
return(JsonConvert.SerializeObject(new
{
Environments = profile.Environments.Values.ToList(),
Subscriptions = profile.Subscriptions.Values.ToList(),
Accounts = profile.Accounts.Values.ToList()
}, Formatting.Indented));
}
public string Serialize(AzureProfile profile)
{
return JsonConvert.SerializeObject(new
{
Environments = profile.Environments.Values.ToList(),
Subscriptions = profile.Subscriptions.Values.ToList(),
Accounts = profile.Accounts.Values.ToList()
}, Formatting.Indented);
}
public bool Deserialize(string contents, AzureProfile profile)
{
DeserializeErrors = new List <string>();
try
{
var jsonProfile = JObject.Parse(contents);
foreach (var env in jsonProfile["Environments"])
{
try
{
profile.Environments[(string)env["Name"]] =
JsonConvert.DeserializeObject <AzureEnvironment>(env.ToString());
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
}
foreach (var subscription in jsonProfile["Subscriptions"])
{
try
{
profile.Subscriptions[new Guid((string)subscription["Id"])] =
JsonConvert.DeserializeObject <AzureSubscription>(subscription.ToString());
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
}
foreach (var account in jsonProfile["Accounts"])
{
try
{
profile.Accounts[(string)account["Id"]] =
JsonConvert.DeserializeObject <AzureAccount>(account.ToString());
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
}
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
return(DeserializeErrors.Count == 0);
}
public bool Deserialize(string contents, AzureProfile profile)
{
DeserializeErrors = new List<string>();
try
{
var jsonProfile = JObject.Parse(contents);
foreach (var env in jsonProfile["Environments"])
{
try
{
profile.Environments[(string) env["Name"]] =
JsonConvert.DeserializeObject<AzureEnvironment>(env.ToString());
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
}
foreach (var subscription in jsonProfile["Subscriptions"])
{
try
{
profile.Subscriptions[new Guid((string) subscription["Id"])] =
JsonConvert.DeserializeObject<AzureSubscription>(subscription.ToString());
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
}
foreach (var account in jsonProfile["Accounts"])
{
try
{
profile.Accounts[(string) account["Id"]] =
JsonConvert.DeserializeObject<AzureAccount>(account.ToString());
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
}
}
catch (Exception ex)
{
DeserializeErrors.Add(ex.Message);
}
return DeserializeErrors.Count == 0;
}
public static IHDInsightSubscriptionCredentials GetSubscriptionCredentials(
this IAzureHDInsightCommonCommandBase command,
AzureSubscription currentSubscription,
AzureEnvironment environment,
AzureProfile profile)
{
var accountId = currentSubscription.Account;
Debug.Assert(profile.Accounts.ContainsKey(accountId));
if (profile.Accounts[accountId].Type == AzureAccount.AccountType.Certificate)
{
return GetSubscriptionCertificateCredentials(command, currentSubscription, profile.Accounts[accountId], environment);
}
else if (profile.Accounts[accountId].Type == AzureAccount.AccountType.User)
{
return GetAccessTokenCredentials(command, currentSubscription, profile.Accounts[accountId], environment);
}
else if (profile.Accounts[accountId].Type == AzureAccount.AccountType.ServicePrincipal)
{
return GetAccessTokenCredentials(command, currentSubscription, profile.Accounts[accountId], environment);
}
throw new NotSupportedException();
}
public void CanGetBasicAuthCredentialFromCredentials()
{
var getClustersCommand = new GetAzureHDInsightJobCommand();
getClustersCommand.Credential = GetPSCredential(TestCredentials.AzureUserName, TestCredentials.AzurePassword);
var waSubscription = new AzureSubscription()
{
Id = IntegrationTestBase.TestCredentials.SubscriptionId,
};
waSubscription.Account = "test";
var profile = new AzureProfile();
var accessTokenCreds = getClustersCommand.GetJobSubmissionClientCredentials(
waSubscription,
AzureSession.CurrentContext.Environment,
IntegrationTestBase.TestCredentials.WellKnownCluster.DnsName, profile);
Assert.IsInstanceOfType(accessTokenCreds, typeof(BasicAuthCredential));
var asBasicAuthCredentials = accessTokenCreds as BasicAuthCredential;
Assert.IsNotNull(asBasicAuthCredentials);
Assert.AreEqual(IntegrationTestBase.TestCredentials.AzureUserName, asBasicAuthCredentials.UserName);
Assert.AreEqual(IntegrationTestBase.TestCredentials.AzurePassword, asBasicAuthCredentials.Password);
}
private static void UpgradeProfile()
{
string oldProfileFilePath = System.IO.Path.Combine(AzureSession.ProfileDirectory, AzureSession.OldProfileFile);
string oldProfileFilePathBackup = System.IO.Path.Combine(AzureSession.ProfileDirectory, AzureSession.OldProfileFileBackup);
string newProfileFilePath = System.IO.Path.Combine(AzureSession.ProfileDirectory, AzureSession.ProfileFile);
if (DataStore.FileExists(oldProfileFilePath))
{
string oldProfilePath = System.IO.Path.Combine(AzureSession.ProfileDirectory,
AzureSession.OldProfileFile);
try
{
// Try to backup old profile
try
{
DataStore.CopyFile(oldProfilePath, oldProfileFilePathBackup);
}
catch
{
// Ignore any errors here
}
AzureProfile oldProfile = new AzureProfile(DataStore, oldProfilePath);
if (DataStore.FileExists(newProfileFilePath))
{
// Merge profile files
AzureProfile newProfile = new AzureProfile(DataStore, newProfileFilePath);
foreach (var environment in newProfile.Environments.Values)
{
oldProfile.Environments[environment.Name] = environment;
}
foreach (var subscription in newProfile.Subscriptions.Values)
{
oldProfile.Subscriptions[subscription.Id] = subscription;
}
DataStore.DeleteFile(newProfileFilePath);
}
// If there were no load errors - delete backup file
if (oldProfile.ProfileLoadErrors.Count == 0)
{
try
{
DataStore.DeleteFile(oldProfileFilePathBackup);
}
catch
{
// Give up
}
}
// Save the profile to the disk
oldProfile.Save();
// Rename WindowsAzureProfile.xml to WindowsAzureProfile.json
DataStore.RenameFile(oldProfilePath, newProfileFilePath);
}
catch
{
// Something really bad happened - try to delete the old profile
try
{
DataStore.DeleteFile(oldProfilePath);
}
catch
{
// Ignore any errors
}
}
}
}
public ProfileClient(string profilePath)
{
try
{
ProfileClient.UpgradeProfile();
Profile = new AzureProfile(DataStore, profilePath);
}
catch
{
// Should never fail in constructor
}
WarningLog = (s) => Debug.WriteLine(s);
}
public AzureHDInsightSubscriptionResolver(AzureProfile profile)
{
this.profile = profile;
}
public string Serialize(AzureProfile obj)
{
// We do not use the serialize for xml serializer anymore and rely solely on the JSON serializer.
throw new NotImplementedException();
}
public IAzureHDInsightSubscriptionResolver Create(AzureProfile profile)
{
return new AzureHDInsightSubscriptionResolver(profile);
}
public bool Deserialize(string contents, AzureProfile profile)
{
ProfileData data = null;
Debug.Assert(profile != null);
DeserializeErrors = new List <string>();
DataContractSerializer serializer = new DataContractSerializer(typeof(ProfileData));
using (MemoryStream s = new MemoryStream(Encoding.UTF8.GetBytes(contents ?? "")))
{
data = (ProfileData)serializer.ReadObject(s);
}
if (data != null)
{
foreach (AzureEnvironmentData oldEnv in data.Environments)
{
profile.Environments[oldEnv.Name] = oldEnv.ToAzureEnvironment();
}
List <AzureEnvironment> envs = profile.Environments.Values.ToList();
foreach (AzureSubscriptionData oldSubscription in data.Subscriptions)
{
try
{
var newSubscription = oldSubscription.ToAzureSubscription(envs);
if (newSubscription.Account == null)
{
continue;
}
var newAccounts = oldSubscription.ToAzureAccounts();
foreach (var account in newAccounts)
{
if (profile.Accounts.ContainsKey(account.Id))
{
profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Tenants,
account.GetPropertyAsArray(AzureAccount.Property.Tenants));
profile.Accounts[account.Id].SetOrAppendProperty(AzureAccount.Property.Subscriptions,
account.GetPropertyAsArray(AzureAccount.Property.Subscriptions));
}
else
{
profile.Accounts[account.Id] = account;
}
}
profile.Subscriptions[newSubscription.Id] = newSubscription;
}
catch (Exception ex)
{
// Skip subscription if failed to load
DeserializeErrors.Add(ex.Message);
}
}
}
return(DeserializeErrors.Count == 0);
}
public static IJobSubmissionClientCredential GetJobSubmissionClientCredentials(
this IAzureHDInsightJobCommandCredentialsBase command,
AzureSubscription currentSubscription,
AzureEnvironment environment, string cluster,
AzureProfile profile)
{
IJobSubmissionClientCredential clientCredential = null;
if (command.Credential != null)
{
clientCredential = new BasicAuthCredential
{
Server = GatewayUriResolver.GetGatewayUri(cluster),
UserName = command.Credential.UserName,
Password = command.Credential.GetCleartextPassword()
};
}
else if (currentSubscription.IsNotNull())
{
var subscriptionCredentials = GetSubscriptionCredentials(command, currentSubscription, environment, profile);
var asCertificateCredentials = subscriptionCredentials as HDInsightCertificateCredential;
var asTokenCredentials = subscriptionCredentials as HDInsightAccessTokenCredential;
if (asCertificateCredentials.IsNotNull())
{
clientCredential = new JobSubmissionCertificateCredential(asCertificateCredentials, cluster);
}
else if (asTokenCredentials.IsNotNull())
{
clientCredential = new JobSubmissionAccessTokenCredential(asTokenCredentials, cluster);
}
}
return clientCredential;
}
public string Serialize(AzureProfile obj)
{
// We do not use the serialize for xml serializer anymore and rely solely on the JSON serializer.
throw new NotImplementedException();
}
