private static AssetJson FindMatchingLocalAsset(LocalAssets localAssets, AutomationAsset asset)
{
List<AssetJson> assetJsonList = new List<AssetJson>();
if (asset is AutomationVariable)
{
assetJsonList.AddRange(localAssets.Variables);
}
else if (asset is AutomationCredential)
{
assetJsonList.AddRange(localAssets.PSCredentials);
}
else if (asset is AutomationConnection)
{
assetJsonList.AddRange(localAssets.Connections);
}
foreach (var currentLocalAsset in assetJsonList)
{
if (asset.Name == currentLocalAsset.Name)
{
return currentLocalAsset;
}
}
return null;
}
public static void Set(string workspacePath, LocalAssets localAssets, String encryptionCertThumbprint)
{
var localAssetsSecure = new SecureLocalAssetsContainerJson();
foreach (var localVariableAsset in localAssets.Variables)
{
if (localVariableAsset.Encrypted)
{
localAssetsSecure.Variable.Add(localVariableAsset);
}
}
localAssetsSecure.PSCredential.AddRange(localAssets.PSCredentials);
localAssetsSecure.Connection.AddRange(localAssets.Connections);
if (encryptionCertThumbprint != null)
{
foreach (var localVariableAsset in localAssetsSecure.Variable)
{
localVariableAsset.Value = Encrypt(localVariableAsset.Value, encryptionCertThumbprint);
}
foreach (var localCredAsset in localAssetsSecure.PSCredential)
{
localCredAsset.Password = Encrypt(localCredAsset.Password, encryptionCertThumbprint);
}
}
WriteJson(System.IO.Path.Combine(workspacePath, AutomationISE.Model.Constants.secureLocalAssetsFileName), localAssetsSecure);
}
public static LocalAssets Get(String workspacePath, String encryptionCertThumbprint, ICollection<ConnectionType> connectionTypes)
{
LocalAssets localAssetsContainer = new LocalAssets();
UnsecureLocalAssetsContainerJson localAssetsJson = UnsecureLocalAssetsContainerJson.Get(workspacePath);
SecureLocalAssetsContainerJson secureLocalAssetsJson = SecureLocalAssetsContainerJson.Get(workspacePath, encryptionCertThumbprint, connectionTypes);
// add JSON variables to the container
localAssetsJson.Variable.ForEach(variable => variable.Encrypted = false);
localAssetsContainer.Variables.AddRange(localAssetsJson.Variable);
secureLocalAssetsJson.Variable.ForEach(variable => variable.Encrypted = true);
localAssetsContainer.Variables.AddRange(secureLocalAssetsJson.Variable);
// add JSON credentials to the container
localAssetsContainer.PSCredentials.AddRange(secureLocalAssetsJson.PSCredential);
// add JSON certificates to the container
localAssetsJson.Certificate.ForEach(Certificate => Certificate.Encrypted = false);
localAssetsContainer.Certificate.AddRange(localAssetsJson.Certificate);
secureLocalAssetsJson.Certificate.ForEach(Certificate => Certificate.Encrypted = true);
localAssetsContainer.Certificate.AddRange(secureLocalAssetsJson.Certificate);
// add JSON connections to the container
localAssetsContainer.Connections.AddRange(secureLocalAssetsJson.Connection);
return localAssetsContainer;
}
public static LocalAssets Get(String workspacePath, String encryptionCertThumbprint, ICollection <ConnectionType> connectionTypes)
{
LocalAssets localAssetsContainer = new LocalAssets();
UnsecureLocalAssetsContainerJson localAssetsJson = UnsecureLocalAssetsContainerJson.Get(workspacePath);
SecureLocalAssetsContainerJson secureLocalAssetsJson = SecureLocalAssetsContainerJson.Get(workspacePath, encryptionCertThumbprint, connectionTypes);
// add JSON variables to the container
localAssetsJson.Variable.ForEach(variable => variable.Encrypted = false);
localAssetsContainer.Variables.AddRange(localAssetsJson.Variable);
secureLocalAssetsJson.Variable.ForEach(variable => variable.Encrypted = true);
localAssetsContainer.Variables.AddRange(secureLocalAssetsJson.Variable);
// add JSON credentials to the container
localAssetsContainer.PSCredentials.AddRange(secureLocalAssetsJson.PSCredential);
// add JSON certificates to the container
localAssetsJson.Certificate.ForEach(Certificate => Certificate.Encrypted = false);
localAssetsContainer.Certificate.AddRange(localAssetsJson.Certificate);
secureLocalAssetsJson.Certificate.ForEach(Certificate => Certificate.Encrypted = true);
localAssetsContainer.Certificate.AddRange(secureLocalAssetsJson.Certificate);
// add JSON connections to the container
localAssetsContainer.Connections.AddRange(secureLocalAssetsJson.Connection);
return(localAssetsContainer);
}
private static AssetJson FindMatchingLocalAsset(LocalAssets localAssets, AutomationAsset asset)
{
List <AssetJson> assetJsonList = new List <AssetJson>();
if (asset is AutomationVariable)
{
assetJsonList.AddRange(localAssets.Variables);
}
else if (asset is AutomationCredential)
{
assetJsonList.AddRange(localAssets.PSCredentials);
}
else if (asset is AutomationConnection)
{
assetJsonList.AddRange(localAssets.Connections);
}
foreach (var currentLocalAsset in assetJsonList)
{
if (asset.Name == currentLocalAsset.Name)
{
return(currentLocalAsset);
}
}
return(null);
}
public static void Set(string workspacePath, LocalAssets localAssets, String encryptionCertThumbprint, ICollection <ConnectionType> connectionTypes)
{
var localAssetsSecure = new SecureLocalAssetsContainerJson();
foreach (var localVariableAsset in localAssets.Variables)
{
if (localVariableAsset.Encrypted)
{
localAssetsSecure.Variable.Add(localVariableAsset);
}
}
localAssetsSecure.PSCredential.AddRange(localAssets.PSCredentials);
localAssetsSecure.Connection.AddRange(localAssets.Connections);
if (encryptionCertThumbprint != null)
{
foreach (var localVariableAsset in localAssetsSecure.Variable)
{
localVariableAsset.Value = Encrypt(localVariableAsset.Value, encryptionCertThumbprint);
}
foreach (var localCredAsset in localAssetsSecure.PSCredential)
{
localCredAsset.Password = Encrypt(localCredAsset.Password, encryptionCertThumbprint);
}
foreach (var localConnectionAsset in localAssetsSecure.Connection)
{
IDictionary <string, FieldDefinition> connectionFieldDefinitions = new Dictionary <string, FieldDefinition>();
foreach (var connectionType in connectionTypes)
{
if (connectionType.Name.Equals(localConnectionAsset.ConnectionType))
{
connectionFieldDefinitions = connectionType.Properties.FieldDefinitions;
break;
}
}
foreach (var fieldDefinition in connectionFieldDefinitions)
{
if (localConnectionAsset.ValueFields[fieldDefinition.Key] != null && fieldDefinition.Value.IsEncrypted)
{
localConnectionAsset.ValueFields[fieldDefinition.Key] = Encrypt(localConnectionAsset.ValueFields[fieldDefinition.Key], encryptionCertThumbprint);
}
}
}
}
WriteJson(System.IO.Path.Combine(workspacePath, AutomationISE.Model.Constants.secureLocalAssetsFileName), localAssetsSecure);
}
public static void Set(string workspacePath, LocalAssets localAssets)
{
var localAssetsUnsecure = new UnsecureLocalAssetsContainerJson();
foreach (var localVariableAsset in localAssets.Variables)
{
if (!localVariableAsset.Encrypted)
{
localAssetsUnsecure.Variable.Add(localVariableAsset);
}
}
WriteJson(System.IO.Path.Combine(workspacePath, AutomationISE.Model.Constants.localAssetsFileName), localAssetsUnsecure);
}
public static void Set(string workspacePath, LocalAssets localAssets, String encryptionCertThumbprint, ICollection<ConnectionType> connectionTypes)
{
var localAssetsSecure = new SecureLocalAssetsContainerJson();
foreach (var localVariableAsset in localAssets.Variables)
{
if (localVariableAsset.Encrypted)
{
localAssetsSecure.Variable.Add(localVariableAsset);
}
}
localAssetsSecure.PSCredential.AddRange(localAssets.PSCredentials);
localAssetsSecure.Connection.AddRange(localAssets.Connections);
if (encryptionCertThumbprint != null)
{
foreach (var localVariableAsset in localAssetsSecure.Variable)
{
localVariableAsset.Value = Encrypt(localVariableAsset.Value, encryptionCertThumbprint);
}
foreach (var localCredAsset in localAssetsSecure.PSCredential)
{
localCredAsset.Password = Encrypt(localCredAsset.Password, encryptionCertThumbprint);
}
foreach (var localConnectionAsset in localAssetsSecure.Connection)
{
IDictionary<string, FieldDefinition> connectionFieldDefinitions = new Dictionary<string, FieldDefinition>();
foreach (var connectionType in connectionTypes)
{
if (connectionType.Name.Equals(localConnectionAsset.ConnectionType))
{
connectionFieldDefinitions = connectionType.Properties.FieldDefinitions;
break;
}
}
foreach (var fieldDefinition in connectionFieldDefinitions)
{
if (localConnectionAsset.ValueFields[fieldDefinition.Key] != null && fieldDefinition.Value.IsEncrypted)
{
localConnectionAsset.ValueFields[fieldDefinition.Key] = Encrypt(localConnectionAsset.ValueFields[fieldDefinition.Key], encryptionCertThumbprint);
}
}
}
}
WriteJson(System.IO.Path.Combine(workspacePath, AutomationISE.Model.Constants.secureLocalAssetsFileName), localAssetsSecure);
}
private static void Write(String workspacePath, LocalAssets assets, String encryptionCertThumbprint)
{
SecureLocalAssetsContainerJson.Set(workspacePath, assets, encryptionCertThumbprint, null);
}
// updates the local assets, either removing (if replace = false) or adding/replacing (if replace = true) the specified assets
private static void Set(String workspacePath, ICollection <AutomationAsset> assetsToAffect, bool replace, String encryptionCertThumbprint, ICollection <ConnectionType> connectionTypes)
{
LocalAssets localAssets = LocalAssetsStore.Get(workspacePath, encryptionCertThumbprint, connectionTypes);
foreach (var assetToAffect in assetsToAffect)
{
AssetJson assetToDelete = LocalAssetsStore.FindMatchingLocalAsset(localAssets, assetToAffect);
if (assetToAffect is AutomationVariable)
{
var variableToAffect = (AutomationVariable)assetToAffect;
if (assetToDelete != null)
{
var variableToDelete = (VariableJson)assetToDelete;
// Encrypted variable assets returned from the cloud have their values removed,
// so keep the old local asset value instead of overwriting the local asset value with null
if (variableToAffect.Encrypted && variableToAffect.getValue() == null)
{
variableToAffect.setValue(variableToDelete.Value);
}
localAssets.Variables.Remove(variableToDelete);
}
if (replace)
{
localAssets.Variables.Add(new VariableJson(variableToAffect));
}
}
else if (assetToAffect is AutomationCredential)
{
var credToAffect = (AutomationCredential)assetToAffect;
if (assetToDelete != null)
{
var credToDelete = (CredentialJson)assetToDelete;
// PSCredential assets returned from the cloud have their passwords removed,
// so keep the old local asset password instead of overwriting the local asset password with null
if (credToAffect.getPassword() == null)
{
credToAffect.setPassword(credToDelete.Password);
}
localAssets.PSCredentials.Remove(credToDelete);
}
if (replace)
{
localAssets.PSCredentials.Add(new CredentialJson(credToAffect));
}
}
else if (assetToAffect is AutomationConnection)
{
var connectionToAffect = (AutomationConnection)assetToAffect;
if (assetToDelete != null)
{
var connectionToDelete = (ConnectionJson)assetToDelete;
IDictionary <string, FieldDefinition> connectionFieldDefinitions = new Dictionary <string, FieldDefinition>();
if (connectionTypes != null)
{
foreach (var connectionType in connectionTypes)
{
if (connectionType.Name.Equals(connectionToAffect.ConnectionType))
{
connectionFieldDefinitions = connectionType.Properties.FieldDefinitions;
break;
}
}
}
// Connection assets returned from the cloud have null values for their encrypted fields,
// so keep the old local asset encrypted field values instead of overwriting the local asset encrypted field values with null
foreach (var valueField in connectionToDelete.ValueFields)
{
if (connectionToAffect.getFields()[valueField.Key] == null && connectionFieldDefinitions[valueField.Key].IsEncrypted)
{
connectionToAffect.getFields()[valueField.Key] = valueField.Value;
}
}
localAssets.Connections.Remove(connectionToDelete);
}
if (replace)
{
localAssets.Connections.Add(new ConnectionJson(connectionToAffect));
}
}
else if (assetToAffect is AutomationCertificate)
{
var certToAffect = (AutomationCertificate)assetToAffect;
if (assetToDelete != null)
{
var certToDelete = (CertificateJson)assetToDelete;
// Certificate assets returned from the cloud have their passwords removed,
// so keep the old local asset password instead of overwriting the local asset password with null
if (certToAffect.getCertPath() == null)
{
certToAffect.setPassword(certToDelete.Password);
certToAffect.setCertPath(certToDelete.CertPath);
}
localAssets.Certificate.Remove(certToDelete);
}
if (replace)
{
localAssets.Certificate.Add(new CertificateJson(certToAffect));
}
}
}
DirectoryInfo dir = Directory.CreateDirectory(workspacePath);
UnsecureLocalAssetsContainerJson.Set(workspacePath, localAssets);
SecureLocalAssetsContainerJson.Set(workspacePath, localAssets, encryptionCertThumbprint, connectionTypes);
}
public static void WriteSecureAssets(String workspacePath, LocalAssets assets, String encryptionCertThumbprint)
{
LocalAssetsStore.Write(workspacePath, assets, encryptionCertThumbprint);
}
public static void SetLocalEncryptedAssets(String localWorkspacePath, LocalAssets locaAssets, string encryptionCertThumbprint)
{
LocalAssetsStore.WriteSecureAssets(localWorkspacePath, locaAssets, encryptionCertThumbprint);
}
/// <summary>
/// Returns if the asset exists locally or in the cloud
/// </summary>
/// <param name="assetName"></param>
/// <param name="assetType"></param>
/// <param name="localWorkspacePath"></param>
/// <param name="automationApi"></param>
/// <param name="resourceGroupName"></param>
/// <param name="automationAccountName"></param>
/// <param name="encryptionCertThumbprint"></param>
/// <returns>null if the asset does not exist or else returns the asset</returns>
public static async Task <AutomationAsset> GetAsset(String assetName, String assetType, String localWorkspacePath, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName, string encryptionCertThumbprint, ICollection <ConnectionType> connectionTypes)
{
AutomationAsset automationAsset = null;
// Get local assets
LocalAssets localAssets = LocalAssetsStore.Get(localWorkspacePath, encryptionCertThumbprint, connectionTypes);
// Search for variables
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
if (assetType == Constants.AssetType.Variable)
{
// Check local asset store first
var localVariable = localAssets.Variables.Find(asset => asset.Name == assetName);
if (localVariable != null)
{
automationAsset = new AutomationVariable(localVariable);
}
else
{
try
{
// Check cloud. Catch exception if it doesn't exist
VariableGetResponse cloudVariable = await automationApi.Variables.GetAsync(resourceGroupName, automationAccountName, assetName, cts.Token);
automationAsset = new AutomationVariable(cloudVariable.Variable);
}
catch (Exception e)
{
// If the exception is not found, don't throw new exception as this is expected
if (e.HResult != -2146233088)
{
throw e;
}
}
}
}
// Search for credentials
else if (assetType == Constants.AssetType.Credential)
{
// Check local asset store first
var localCredential = localAssets.PSCredentials.Find(asset => asset.Name == assetName);
if (localCredential != null)
{
automationAsset = new AutomationCredential(localCredential);
}
else
{
try
{
// Check cloud. Catch execption if it doesn't exist
CredentialGetResponse cloudVariable = await automationApi.PsCredentials.GetAsync(resourceGroupName, automationAccountName, assetName, cts.Token);
automationAsset = new AutomationCredential(cloudVariable.Credential);
}
catch (Exception e)
{
// If the exception is not found, don't throw new exception as this is expected
if (e.HResult != -2146233088)
{
throw e;
}
}
}
}
// Search for connections
else if (assetType == Constants.AssetType.Connection)
{
// Check local asset store first
var localConnection = localAssets.Connections.Find(asset => asset.Name == assetName);
if (localConnection != null)
{
automationAsset = new AutomationConnection(localConnection);
}
else
{
try
{
// Check cloud. Catch exception if it doesn't exist
ConnectionGetResponse cloudConnection = await automationApi.Connections.GetAsync(resourceGroupName, automationAccountName, assetName, cts.Token);
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
ConnectionTypeGetResponse connectionType = await automationApi.ConnectionTypes.GetAsync(resourceGroupName, automationAccountName,
cloudConnection.Connection.Properties.ConnectionType.Name, cts.Token);
automationAsset = new AutomationConnection(cloudConnection.Connection, connectionType.ConnectionType);
}
catch (Exception e)
{
// If the exception is not found, don't throw new exception as this is expected
if (e.HResult != -2146233088)
{
throw e;
}
}
}
}
// Search for certificates
else if (assetType == Constants.AssetType.Certificate)
{
// Check local asset store first
var localCertificate = localAssets.Certificate.Find(asset => asset.Name == assetName);
if (localCertificate != null)
{
automationAsset = new AutomationCertificate(localCertificate);
}
else
{
try
{
// Check cloud. Catch execption if it doesn't exist
CertificateGetResponse cloudCertificate = await automationApi.Certificates.GetAsync(resourceGroupName, automationAccountName, assetName, cts.Token);
automationAsset = new AutomationCertificate(cloudCertificate.Certificate);
}
catch (Exception e)
{
// If the exception is not found, don't throw new exception as this is expected
if (e.HResult != -2146233088)
{
throw e;
}
}
}
}
return(automationAsset);
}
public static LocalAssets GetLocalEncryptedAssets(String localWorkspacePath, string encryptionCertThumbprint)
{
LocalAssets localAssets = LocalAssetsStore.Get(localWorkspacePath, encryptionCertThumbprint, null);
return(localAssets);
}
public static async Task <ISet <AutomationAsset> > GetAll(String localWorkspacePath, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName, string encryptionCertThumbprint)
{
VariableListResponse cloudVariables = await automationApi.Variables.ListAsync(resourceGroupName, automationAccountName);
CredentialListResponse cloudCredentials = await automationApi.PsCredentials.ListAsync(resourceGroupName, automationAccountName);
// TODO: need to get one at a time to get values. values currently comes back as empty
//ConnectionListResponse cloudConnections = await automationApi.Connections.ListAsync(resourceGroupName, automationAccountName);
LocalAssets localAssets = LocalAssetsStore.Get(localWorkspacePath, encryptionCertThumbprint);
var automationAssets = new SortedSet <AutomationAsset>();
// Compare cloud variables to local
foreach (var cloudAsset in cloudVariables.Variables)
{
var localAsset = localAssets.Variables.Find(asset => asset.Name == cloudAsset.Name);
var automationAsset = (localAsset != null) ?
new AutomationVariable(localAsset, cloudAsset) :
new AutomationVariable(cloudAsset);
automationAssets.Add(automationAsset);
}
// Add remaining locally created variables
foreach (var localAsset in localAssets.Variables)
{
var automationAsset = new AutomationVariable(localAsset);
automationAssets.Add(automationAsset);
}
// Compare cloud credentials to local
foreach (var cloudAsset in cloudCredentials.Credentials)
{
var localAsset = localAssets.PSCredentials.Find(asset => asset.Name == cloudAsset.Name);
var automationAsset = (localAsset != null) ?
new AutomationCredential(localAsset, cloudAsset) :
new AutomationCredential(cloudAsset);
automationAssets.Add(automationAsset);
}
// Add remaining locally created credentials
foreach (var localAsset in localAssets.PSCredentials)
{
var automationAsset = new AutomationCredential(localAsset);
automationAssets.Add(automationAsset);
}
// Compare cloud connections to local
/*foreach (var cloudAsset in cloudConnections.Connection)
* {
* var localAsset = localAssets.Connections.Find(asset => asset.Name == cloudAsset.Name);
*
* var automationAsset = (localAsset != null) ?
* new AutomationConnection(localAsset, cloudAsset) :
* new AutomationConnection(cloudAsset);
*
* automationAssets.Add(automationAsset);
* }
*
* // Add remaining locally created connections
* foreach (var localAsset in localAssets.Connections)
* {
* var automationAsset = new AutomationConnection(localAsset);
* automationAssets.Add(automationAsset);
* }*/
return(automationAssets);
}
public static void Set(string workspacePath, LocalAssets localAssets, String encryptionCertThumbprint)
{
var localAssetsSecure = new SecureLocalAssetsContainerJson();
foreach (var localVariableAsset in localAssets.Variables)
{
if (localVariableAsset.Encrypted)
{
localAssetsSecure.Variable.Add(localVariableAsset);
}
}
localAssetsSecure.PSCredential.AddRange(localAssets.PSCredentials);
localAssetsSecure.Connection.AddRange(localAssets.Connections);
if (encryptionCertThumbprint != null)
{
foreach (var localVariableAsset in localAssetsSecure.Variable)
{
localVariableAsset.Value = Encrypt(localVariableAsset.Value, encryptionCertThumbprint);
}
foreach (var localCredAsset in localAssetsSecure.PSCredential)
{
localCredAsset.Password = Encrypt(localCredAsset.Password, encryptionCertThumbprint);
}
}
WriteJson(System.IO.Path.Combine(workspacePath, AutomationISE.Model.Constants.secureLocalAssetsFileName), localAssetsSecure);
}
public static void Set(string workspacePath, LocalAssets localAssets)
{
var localAssetsUnsecure = new UnsecureLocalAssetsContainerJson();
foreach (var localVariableAsset in localAssets.Variables)
{
if (!localVariableAsset.Encrypted)
{
localAssetsUnsecure.Variable.Add(localVariableAsset);
}
}
WriteJson(System.IO.Path.Combine(workspacePath, AutomationISE.Model.Constants.localAssetsFileName), localAssetsUnsecure);
}
// updates the local assets, either removing (if replace = false) or adding/replacing (if replace = true) the specified assets
private static void Set(String workspacePath, ICollection <AutomationAsset> assetsToAffect, bool replace, String encryptionCertThumbprint)
{
LocalAssets localAssets = LocalAssetsStore.Get(workspacePath, encryptionCertThumbprint);
foreach (var assetToAffect in assetsToAffect)
{
AssetJson assetToDelete = LocalAssetsStore.FindMatchingLocalAsset(localAssets, assetToAffect);
if (assetToAffect is AutomationVariable)
{
var variableToAffect = (AutomationVariable)assetToAffect;
if (assetToDelete != null)
{
var variableToDelete = (VariableJson)assetToDelete;
// Encrypted variable assets returned from the cloud have their values removed,
// so keep the old local asset value instead of overwriting the local asset value with null
if (variableToAffect.Encrypted && variableToAffect.getValue() == null)
{
variableToAffect.setValue(variableToDelete.Value);
}
localAssets.Variables.Remove(variableToDelete);
}
if (replace)
{
localAssets.Variables.Add(new VariableJson(variableToAffect));
}
}
else if (assetToAffect is AutomationCredential)
{
var credToAffect = (AutomationCredential)assetToAffect;
if (assetToDelete != null)
{
var credToDelete = (CredentialJson)assetToDelete;
// PSCredential assets returned from the cloud have their passwords removed,
// so keep the old local asset password instead of overwriting the local asset password with null
if (credToAffect.getPassword() == null)
{
credToAffect.setPassword(credToDelete.Password);
}
localAssets.PSCredentials.Remove(credToDelete);
}
if (replace)
{
localAssets.PSCredentials.Add(new CredentialJson(credToAffect));
}
}
else if (assetToAffect is AutomationConnection)
{
// TODO: support carry over of null fields from previous local asset
if (assetToDelete != null)
{
localAssets.Connections.Remove((ConnectionJson)assetToDelete);
}
if (replace)
{
localAssets.Connections.Add(new ConnectionJson((AutomationConnection)assetToAffect));
}
}
}
DirectoryInfo dir = Directory.CreateDirectory(workspacePath);
UnsecureLocalAssetsContainerJson.Set(workspacePath, localAssets);
SecureLocalAssetsContainerJson.Set(workspacePath, localAssets, encryptionCertThumbprint);
}
public static async Task <ISet <AutomationAsset> > GetAll(String localWorkspacePath, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName, string encryptionCertThumbprint, ICollection <ConnectionType> connectionTypes)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
VariableListResponse cloudVariables = await automationApi.Variables.ListAsync(resourceGroupName, automationAccountName, cts.Token);
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
CredentialListResponse cloudCredentials = await automationApi.PsCredentials.ListAsync(resourceGroupName, automationAccountName, cts.Token);
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
ConnectionListResponse cloudConnections = await automationApi.Connections.ListAsync(resourceGroupName, automationAccountName, cts.Token);
CertificateListResponse cloudCertificates = await automationApi.Certificates.ListAsync(resourceGroupName, automationAccountName, cts.Token);
// need to get connections one at a time to get each connection's values. Values currently come back as empty in list call
var connectionAssetsWithValues = new HashSet <Connection>();
foreach (var connection in cloudConnections.Connection)
{
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
var connectionResponse = await automationApi.Connections.GetAsync(resourceGroupName, automationAccountName, connection.Name, cts.Token);
connectionAssetsWithValues.Add(connectionResponse.Connection);
}
LocalAssets localAssets = LocalAssetsStore.Get(localWorkspacePath, encryptionCertThumbprint, connectionTypes);
var automationAssets = new SortedSet <AutomationAsset>();
// Compare cloud variables to local
foreach (var cloudAsset in cloudVariables.Variables)
{
var localAsset = localAssets.Variables.Find(asset => asset.Name == cloudAsset.Name);
var automationAsset = (localAsset != null) ?
new AutomationVariable(localAsset, cloudAsset) :
new AutomationVariable(cloudAsset);
automationAssets.Add(automationAsset);
}
// Add remaining locally created variables
foreach (var localAsset in localAssets.Variables)
{
var automationAsset = new AutomationVariable(localAsset);
automationAssets.Add(automationAsset);
}
// Compare cloud credentials to local
foreach (var cloudAsset in cloudCredentials.Credentials)
{
var localAsset = localAssets.PSCredentials.Find(asset => asset.Name == cloudAsset.Name);
var automationAsset = (localAsset != null) ?
new AutomationCredential(localAsset, cloudAsset) :
new AutomationCredential(cloudAsset);
automationAssets.Add(automationAsset);
}
// Add remaining locally created credentials
foreach (var localAsset in localAssets.PSCredentials)
{
var automationAsset = new AutomationCredential(localAsset);
automationAssets.Add(automationAsset);
}
// Compare cloud connections to local
foreach (var cloudAsset in connectionAssetsWithValues)
{
ConnectionTypeGetResponse connectionType = await automationApi.ConnectionTypes.GetAsync(resourceGroupName, automationAccountName, cloudAsset.Properties.ConnectionType.Name);
var localAsset = localAssets.Connections.Find(asset => asset.Name == cloudAsset.Name);
var automationAsset = (localAsset != null) ?
new AutomationConnection(localAsset, cloudAsset) :
new AutomationConnection(cloudAsset, connectionType.ConnectionType);
automationAssets.Add(automationAsset);
}
// Add remaining locally created connections
foreach (var localAsset in localAssets.Connections)
{
var automationAsset = new AutomationConnection(localAsset);
automationAssets.Add(automationAsset);
}
// Compare cloud certificates to local
foreach (var cloudAsset in cloudCertificates.Certificates)
{
var localAsset = localAssets.Certificate.Find(asset => asset.Name == cloudAsset.Name);
var automationAsset = (localAsset != null) ?
new AutomationCertificate(localAsset, cloudAsset) :
new AutomationCertificate(cloudAsset);
automationAssets.Add(automationAsset);
}
// Add remaining locally created certificates
foreach (var localAsset in localAssets.Certificate)
{
var automationAsset = new AutomationCertificate(localAsset);
automationAssets.Add(automationAsset);
}
return(automationAssets);
}
