public static async Task DownloadRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string workspace, string resourceGroupName, AutomationAccount account)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookGetResponse response = await automationManagementClient.Runbooks.GetAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
RunbookDraftGetResponse draftResponse = null;
RunbookContentResponse runbookContentResponse = null;
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
if (response.Runbook.Properties.State == "Published")
{
runbookContentResponse = await automationManagementClient.Runbooks.ContentAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
}
else
{
runbookContentResponse = await automationManagementClient.RunbookDraft.ContentAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
draftResponse = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
}
String runbookFilePath = System.IO.Path.Combine(workspace, runbook.Name + ".ps1");
try
{
File.WriteAllText(runbookFilePath, runbookContentResponse.Stream.ToString(), Encoding.UTF8);
}
catch (Exception Ex)
{
// Atempting to write the file while it is being read. Wait a second and retry.
if (Ex.HResult == -2147024864)
{
Thread.Sleep(1000);
File.WriteAllText(runbookFilePath, runbookContentResponse.Stream.ToString(), Encoding.UTF8);
}
}
runbook.AuthoringState = AutomationRunbook.AuthoringStates.InEdit;
runbook.localFileInfo = new FileInfo(runbookFilePath);
/* This is the only way I can see to "check out" the runbook using the SDK.
* Hopefully there's a better way but for now this works */
if (response.Runbook.Properties.State == "Published")
{
await UploadRunbookAsDraft(runbook, automationManagementClient, resourceGroupName, account);
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
draftResponse = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
}
/* Ensures the correct sync status is detected */
if (draftResponse != null)
{
runbook.localFileInfo.LastWriteTime = draftResponse.RunbookDraft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draftResponse.RunbookDraft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draftResponse.RunbookDraft.LastModifiedTime.LocalDateTime;
}
}
public static async Task UploadToCloud(ICollection<AutomationAsset> assetsToUpload, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName)
{
var jss = new JavaScriptSerializer();
foreach (var assetToUpload in assetsToUpload)
{
if (assetToUpload is AutomationVariable)
{
var asset = (AutomationVariable)assetToUpload;
var properties = new VariableCreateOrUpdateProperties();
properties.IsEncrypted = asset.Encrypted;
var stringBuilder = new StringBuilder();
jss.Serialize(asset.getValue(), stringBuilder);
properties.Value = stringBuilder.ToString();
await automationApi.Variables.CreateOrUpdateAsync(resourceGroupName, automationAccountName, new VariableCreateOrUpdateParameters(asset.Name, properties));
}
else if(assetToUpload is AutomationCredential)
{
var asset = (AutomationCredential)assetToUpload;
var properties = new CredentialCreateOrUpdateProperties();
properties.UserName = asset.getUsername();
properties.Password = asset.getPassword();
await automationApi.PsCredentials.CreateOrUpdateAsync(resourceGroupName, automationAccountName, new CredentialCreateOrUpdateParameters(asset.Name, properties));
}
else if (assetToUpload is AutomationConnection)
{
// TODO: implement this and certificates
}
}
}
public static async Task DeleteCloudRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.Runbooks.DeleteAsync(resourceGroupName, accountName, runbook.Name, cts.Token);
}
public static async void DownloadFromCloud(ICollection<AutomationAsset> assetsToDownload, String localWorkspacePath, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName, String encryptionCertThumbprint, ICollection<ConnectionType> connectionTypes)
{
try
{
var cloudAssets = await AutomationAssetManager.GetAll(null, automationApi, resourceGroupName, automationAccountName, encryptionCertThumbprint, connectionTypes);
var assetsToSaveLocally = new SortedSet<AutomationAsset>();
foreach (var cloudAsset in cloudAssets)
{
foreach (var assetToDownload in assetsToDownload)
{
if (cloudAsset.Equals(assetToDownload))
{
assetsToSaveLocally.Add(cloudAsset);
break;
}
}
}
AutomationAssetManager.SaveLocally(localWorkspacePath, assetsToSaveLocally, encryptionCertThumbprint, connectionTypes);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
private static async Task <IList <Module> > DownloadModuleMetadata(AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
IList <Module> modules = new List <Module>();
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
ModuleListResponse cloudModules = await automationManagementClient.Modules.ListAsync(resourceGroupName, accountName, cts.Token);
foreach (var module in cloudModules.Modules)
{
// Skip automation internal modules
if (!(Constants.excludeModules.Contains(module.Name)))
{
modules.Add(module);
}
}
while (cloudModules.NextLink != null)
{
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
cloudModules = await automationManagementClient.Modules.ListNextAsync(cloudModules.NextLink, cts.Token);
foreach (var module in cloudModules.Modules)
{
// Skip automation internal modules
if (!(Constants.excludeModules.Contains(module.Name)))
{
modules.Add(module);
}
}
}
return(modules);
}
private async Task <IEnumerable <RunbookParameter> > ListAutomationRunbookParameters(
string accessToken,
string subscriptionId,
string resourceGroupName,
string automationAccountName,
string runbookName)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationRunbookResult = await automationClient.Runbooks.GetAsync(resourceGroupName, automationAccountName, runbookName);
var automationRunbookPrameters = automationRunbookResult.Runbook.Properties.Parameters.Select(
parameter => new RunbookParameter
{
ParameterName = parameter.Key,
DefaultValue = parameter.Value.DefaultValue,
IsMandatory = parameter.Value.IsMandatory,
Position = parameter.Value.Position,
Type = parameter.Value.Type
}).ToList();
return(automationRunbookPrameters);
}
}
public static async Task DeleteCloudModule(AutomationModule module, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.Modules.DeleteAsync(resourceGroupName, accountName, module.Name, cts.Token);
}
public static async Task DownloadRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string workspace, string resourceGroupName, AutomationAccount account)
{
RunbookGetResponse response = await automationManagementClient.Runbooks.GetAsync(resourceGroupName, account.Name, runbook.Name);
RunbookDraftGetResponse draftResponse = null;
RunbookContentResponse runbookContentResponse = null;
if (response.Runbook.Properties.State == "Published")
{
runbookContentResponse = await automationManagementClient.Runbooks.ContentAsync(resourceGroupName, account.Name, runbook.Name);
}
else
{
runbookContentResponse = await automationManagementClient.RunbookDraft.ContentAsync(resourceGroupName, account.Name, runbook.Name);
draftResponse = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, account.Name, runbook.Name);
}
String runbookFilePath = System.IO.Path.Combine(workspace, runbook.Name + ".ps1");
File.WriteAllText(runbookFilePath, runbookContentResponse.Stream.ToString());
runbook.localFileInfo = new FileInfo(runbookFilePath);
/* This is the only way I can see to "check out" the runbook using the SDK.
* Hopefully there's a better way but for now this works */
if (response.Runbook.Properties.State == "Published")
{
await UploadRunbookAsDraft(runbook, automationManagementClient, resourceGroupName, account);
draftResponse = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, account.Name, runbook.Name);
}
/* Ensures the correct sync status is detected */
if (draftResponse != null)
{
runbook.localFileInfo.LastWriteTime = draftResponse.RunbookDraft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draftResponse.RunbookDraft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draftResponse.RunbookDraft.LastModifiedTime.LocalDateTime;
}
}
public IEnumerable <Variable> ListVariables(string automationAccountName)
{
IList <AutomationManagement.Models.Variable> variables = AutomationManagementClient.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.Variables.List(
automationAccountName, skipToken);
return(new ResponseWithSkipToken <AutomationManagement.Models.Variable>(
response, response.Variables));
});
var result =
variables.Select(
(variable, autoamtionAccountName) =>
this.CreateVariableFromVariableModel(variable, automationAccountName)).ToList();
IList <AutomationManagement.Models.EncryptedVariable> encryptedVariables = AutomationManagementClient
.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.EncryptedVariables.List(
automationAccountName, skipToken);
return(new ResponseWithSkipToken <AutomationManagement.Models.EncryptedVariable>(
response, response.EncryptedVariables));
});
result.AddRange(
encryptedVariables.Select(
(variable, autoamtionAccountName) =>
this.CreateVariableFromVariableModel(variable, automationAccountName)).ToList());
return(result);
}
public static async Task <Boolean> CheckModuleExists(string moduleName, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName, string version)
{
try
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
ModuleGetResponse response = await automationManagementClient.Modules.GetAsync(resourceGroupName, accountName, moduleName, cts.Token);
// If the cloud module is greater or equal to local module then return false so that it gets imported.
if ((response.Module.Properties.Version != null && response.Module.Properties.Version.CompareTo(version) < 0) || !(String.IsNullOrEmpty(response.Module.Properties.Error.Message)))
{
return(false);
}
}
catch (Exception ex)
{
// Module not found.
if (ex.HResult == -2146233088)
{
return(false);
}
else
{
throw ex;
}
}
// Module exists and is the same or newer version
return(true);
}
public static async Task UploadRunbookAsDraft(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, AutomationAccount account)
{
RunbookCreateOrUpdateDraftProperties draftProperties = new RunbookCreateOrUpdateDraftProperties("Script", new RunbookDraft());
draftProperties.Description = runbook.Description;
RunbookCreateOrUpdateDraftParameters draftParams = new RunbookCreateOrUpdateDraftParameters(draftProperties);
draftParams.Name = runbook.Name;
draftParams.Location = account.Location;
await automationManagementClient.Runbooks.CreateOrUpdateWithDraftAsync(resourceGroupName, account.Name, draftParams);
/* Update the runbook content from .ps1 file */
RunbookDraftUpdateParameters draftUpdateParams = new RunbookDraftUpdateParameters()
{
Name = runbook.Name,
Stream = File.ReadAllText(runbook.localFileInfo.FullName)
};
await automationManagementClient.RunbookDraft.UpdateAsync(resourceGroupName, account.Name, draftUpdateParams);
/* Ensure the correct sync status is detected */
RunbookDraft draft = await GetRunbookDraft(runbook.Name, automationManagementClient, resourceGroupName, account.Name);
runbook.localFileInfo.LastWriteTime = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draft.LastModifiedTime.LocalDateTime;
}
private static async Task <IList <Runbook> > DownloadRunbookMetadata(AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
IList <Runbook> runbooks = new List <Runbook>();
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookListResponse cloudRunbooks = await automationManagementClient.Runbooks.ListAsync(resourceGroupName, accountName, cts.Token);
foreach (var runbook in cloudRunbooks.Runbooks)
{
runbooks.Add(runbook);
}
while (cloudRunbooks.NextLink != null)
{
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
cloudRunbooks = await automationManagementClient.Runbooks.ListNextAsync(cloudRunbooks.NextLink, cts.Token);
foreach (var runbook in cloudRunbooks.Runbooks)
{
runbooks.Add(runbook);
}
}
return(runbooks);
}
public static async Task UploadRunbookAsDraft(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, AutomationAccount account)
{
RunbookCreateOrUpdateDraftProperties draftProperties;
// Parse the script to determine if it is a PS workflow or native script
String PSScriptText = File.ReadAllText(runbook.localFileInfo.FullName);
System.Management.Automation.Language.Token[] AST;
System.Management.Automation.Language.ParseError[] ASTError = null;
var ASTScript = System.Management.Automation.Language.Parser.ParseInput(PSScriptText, out AST, out ASTError);
// If the script starts with workflow, then create a PS Workflow script runbook or else create a native PS script runbook
if (ASTScript.EndBlock.Extent.Text.ToLower().StartsWith("workflow"))
{
draftProperties = new RunbookCreateOrUpdateDraftProperties(Constants.RunbookType.Workflow, new RunbookDraft());
}
else
draftProperties = new RunbookCreateOrUpdateDraftProperties(Constants.RunbookType.PowerShellScript, new RunbookDraft());
// Get current properties if is not a new runbook and set these on the draft also so they are preserved.
RunbookGetResponse response = null;
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
if (runbook.SyncStatus != AutomationAuthoringItem.Constants.SyncStatus.LocalOnly)
{
response = await automationManagementClient.Runbooks.GetAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
draftProperties.Description = response.Runbook.Properties.Description;
}
// Create draft properties
RunbookCreateOrUpdateDraftParameters draftParams = new RunbookCreateOrUpdateDraftParameters(draftProperties);
draftParams.Name = runbook.Name;
draftParams.Location = account.Location;
// If this is not a new runbook, set the existing properties of the runbook
if (response != null)
{
draftParams.Tags = response.Runbook.Tags;
draftParams.Properties.LogProgress = response.Runbook.Properties.LogProgress;
draftParams.Properties.LogVerbose = response.Runbook.Properties.LogVerbose;
}
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.Runbooks.CreateOrUpdateWithDraftAsync(resourceGroupName, account.Name, draftParams, cts.Token);
/* Update the runbook content from .ps1 file */
RunbookDraftUpdateParameters draftUpdateParams = new RunbookDraftUpdateParameters()
{
Name = runbook.Name,
Stream = PSScriptText
};
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.RunbookDraft.UpdateAsync(resourceGroupName, account.Name, draftUpdateParams, cts.Token);
/* Ensure the correct sync status is detected */
RunbookDraft draft = await GetRunbookDraft(runbook.Name, automationManagementClient, resourceGroupName, account.Name);
runbook.localFileInfo.LastWriteTime = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draft.LastModifiedTime.LocalDateTime;
}
protected AzureAutomationClient(Guid tenantId, Guid subscriptionId, string resourceGroupName, string automationAccountName)
{
_authCtx = new AuthenticationContext(Parameters.AZURE_LOGIN_AUTHORITY + tenantId);
_subscriptionId = subscriptionId;
_resourceGroupName = resourceGroupName;
_automationAccountName = automationAccountName;
_client = new AutomationManagementClient();
}
public static async Task <Module> GetModule(string moduleName, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
ModuleGetResponse response = await automationManagementClient.Modules.GetAsync(resourceGroupName, accountName, moduleName, cts.Token);
return(response.Module);
}
public static async Task <ISet <AutomationRunbook> > GetAllRunbookMetadata(AutomationManagementClient automationManagementClient, string workspace, string resourceGroupName, string accountName, Dictionary <string, string> localScriptsParsed)
{
ISet <AutomationRunbook> result = new SortedSet <AutomationRunbook>();
IList <Runbook> cloudRunbooks = await DownloadRunbookMetadata(automationManagementClient, resourceGroupName, accountName);
/* Create a Dictionary of (filename, filepath) tuples found on disk. This will come in handy */
Dictionary <string, string> filePathForRunbook = new Dictionary <string, string>();
if (localScriptsParsed != null)
{
foreach (string path in localScriptsParsed.Keys)
{
if (localScriptsParsed[path] == ("script"))
{
filePathForRunbook.Add(System.IO.Path.GetFileNameWithoutExtension(path), path);
}
}
}
/* Start by checking the downloaded runbooks */
foreach (Runbook cloudRunbook in cloudRunbooks)
{
/* Don't bother with graphical runbooks, since the ISE can't do anything with them */
if (cloudRunbook.Properties.RunbookType != Constants.RunbookType.Graphical && cloudRunbook.Properties.RunbookType != Constants.RunbookType.GraphPowerShell)
{
RunbookDraftGetResponse draftResponse;
try
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
draftResponse = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, accountName, cloudRunbook.Name, cts.Token);
}
catch
{
draftResponse = null;
continue;
}
if (filePathForRunbook.ContainsKey(cloudRunbook.Name))
{
result.Add(new AutomationRunbook(new FileInfo(filePathForRunbook[cloudRunbook.Name]), cloudRunbook, draftResponse.RunbookDraft));
}
else
{
result.Add(new AutomationRunbook(cloudRunbook, draftResponse.RunbookDraft));
}
}
}
/* Now find runbooks on disk that aren't yet accounted for */
foreach (string localRunbookName in filePathForRunbook.Keys)
{
//Not great, but works for now
if (result.FirstOrDefault(x => x.Name == localRunbookName) == null)
{
result.Add(new AutomationRunbook(new FileInfo(filePathForRunbook[localRunbookName])));
}
}
return(result);
}
public static async Task <RunbookDraft> GetRunbookDraft(string runbookName, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookDraftGetResponse response = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, accountName, runbookName, cts.Token);
return(response.RunbookDraft);
}
private async Task AssureLogin()
{
var token = await((ClientType == ClientType.Workflow) ? GetAppToken() : GetUserToken());
if (token != _token)
{
_token = token;
_client = new AutomationManagementClient(new TokenCloudCredentials(_subscriptionId.ToString(), _token));
}
}
public static async Task<bool> isSourceControlEnabled(AutomationManagementClient automationClient, String resourceGroup, String automationAccount)
{
JobListParameters listParams = new JobListParameters();
listParams.RunbookName = Constants.sourceControlRunbook;
var response = await automationClient.Jobs.ListAsync(resourceGroup,
automationAccount, listParams, new System.Threading.CancellationToken());
if (response.Jobs.Count > 0) return true;
else return false;
}
private async Task InitializeAsync()
{
await RefreshTokenAsync();
_client = new AutomationManagementClient(_accessToken);
// We need the location of the azure automation account for later use
var account = _client.AutomationAccounts.Get(_connectionData.AzureRMGroupName, _connectionData.AzureAutomationAccount);
_connectionData.AzureRMLocation = account.AutomationAccount.Location;
}
public static async Task<LongRunningOperationResultResponse> PublishRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
RunbookDraftPublishParameters publishParams = new RunbookDraftPublishParameters
{
Name = runbook.Name,
PublishedBy = "ISE User: " + System.Security.Principal.WindowsIdentity.GetCurrent().Name
};
LongRunningOperationResultResponse resultResponse = await automationManagementClient.RunbookDraft.PublishAsync(resourceGroupName, accountName, publishParams);
return resultResponse;
}
public async Task <string> GetAutomationJobOutputAsync(string accessToken, string subscriptionId, string resourceGroupName, string automationAccountName, string jobId)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var jobOutputResponse = await automationClient.Jobs.GetOutputAsync(resourceGroupName, automationAccountName, new Guid(jobId));
return(jobOutputResponse.Output);
}
}
public RequestSettings(IAutomationManagementClient automationClient)
{
client = ((AutomationManagementClient)automationClient);
client.HttpClient.DefaultRequestHeaders.Remove(Constants.ClientRequestIdHeaderName);
client.HttpClient.DefaultRequestHeaders.Add(Constants.ClientRequestIdHeaderName, Guid.NewGuid().ToString());
client.HttpClient.DefaultRequestHeaders.Remove(Constants.ActivityIdHeaderName);
var activityId = Guid.NewGuid();
EventProvider.SetActivityId(ref activityId);
client.HttpClient.DefaultRequestHeaders.Add(Constants.ActivityIdHeaderName, activityId.ToString());
}
public static async Task DownloadConfiguration(AutomationDSC configuration, AutomationManagementClient automationManagementClient, string workspace, string resourceGroupName, AutomationAccount account)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
DscConfigurationGetResponse response = await automationManagementClient.Configurations.GetAsync(resourceGroupName, account.Name, configuration.Name, cts.Token);
DscConfigurationGetResponse draftResponse = null;
DscConfigurationGetContentResponse configurationContentResponse = null;
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
if (response.Configuration.Properties.State == "Published")
{
configurationContentResponse = await automationManagementClient.Configurations.GetContentAsync(resourceGroupName, account.Name, configuration.Name, cts.Token);
}
else
{
// Draft not supported yet
}
String configFilePath = System.IO.Path.Combine(workspace, configuration.Name + ".ps1");
try
{
File.WriteAllText(configFilePath, configurationContentResponse.Content.ToString(), Encoding.UTF8);
}
catch (Exception Ex)
{
// Atempting to write the file while it is being read. Wait a second and retry.
if (Ex.HResult == -2147024864)
{
Thread.Sleep(1000);
File.WriteAllText(configFilePath, configurationContentResponse.Content.ToString(), Encoding.UTF8);
}
}
configuration.localFileInfo = new FileInfo(configFilePath);
if (response.Configuration.Properties.State == "Published")
{
await UploadConfigurationAsDraft(configuration, automationManagementClient, resourceGroupName, account);
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
draftResponse = await automationManagementClient.Configurations.GetAsync(resourceGroupName, account.Name, configuration.Name, cts.Token);
}
/* Ensures the correct sync status is detected */
if (draftResponse != null)
{
configuration.localFileInfo.LastWriteTime = draftResponse.Configuration.Properties.LastModifiedTime.LocalDateTime;
configuration.LastModifiedLocal = draftResponse.Configuration.Properties.LastModifiedTime.LocalDateTime;
configuration.LastModifiedCloud = draftResponse.Configuration.Properties.LastModifiedTime.LocalDateTime;
}
}
public IEnumerable <Runbook> ListRunbooks(string automationAccountName)
{
return(AutomationManagementClient
.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.Runbooks.List(
automationAccountName, skipToken);
return new ResponseWithSkipToken <AutomationManagement.Models.Runbook>(
response, response.Runbooks);
}).Select(c => new Runbook(automationAccountName, c)));
}
public RequestSettings(IAutomationManagementClient automationClient)
{
client = ((AutomationManagementClient)automationClient);
client.HttpClient.DefaultRequestHeaders.Remove(Constants.ClientRequestIdHeaderName);
client.HttpClient.DefaultRequestHeaders.Add(Constants.ClientRequestIdHeaderName, Guid.NewGuid().ToString());
client.HttpClient.DefaultRequestHeaders.Remove(Constants.ActivityIdHeaderName);
var activityId = Guid.NewGuid();
EventProvider.SetActivityId(ref activityId);
client.HttpClient.DefaultRequestHeaders.Add(Constants.ActivityIdHeaderName, activityId.ToString());
}
public async Task <IList <AutomationAccount> > GetAutomationAccounts()
{
if (currSubscription.Name == null)
{
throw new Exception(Properties.Resources.SubscriptionNotSet);
}
// Get the token for the tenant on this subscription.
azureARMAuthResult = AuthenticateHelper.RefreshTokenByAuthority(currSubscription.Authority, Properties.Settings.Default.appIdURI);
subscriptionCreds = new TokenCloudCredentials(currSubscription.SubscriptionId, azureARMAuthResult.AccessToken);
automationManagementClient = new AutomationManagementClient(subscriptionCreds, new Uri(Properties.Settings.Default.appIdURI));
// Add user agent string to indicate this is coming from the ISE automation client.
ProductInfoHeaderValue ISEClientAgent = new ProductInfoHeaderValue(Constants.ISEUserAgent, Constants.ISEVersion);
automationManagementClient.UserAgent.Add(ISEClientAgent);
//TODO: does this belong here?
if (accountResourceGroups == null)
{
accountResourceGroups = new Dictionary <AutomationAccount, ResourceGroupExtended>();
}
else
{
accountResourceGroups.Clear();
}
IList <AutomationAccount> result = new List <AutomationAccount>();
// Get ARM automation account resources
var automationResources = await GetAutomationResources();
// Retrieve all of the automation accounts found
foreach (var resource in automationResources.Resources)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
// Find the resource group name from the resource id.
var startPosition = resource.Id.IndexOf("/resourceGroups/");
var endPosition = resource.Id.IndexOf("/", startPosition + 16);
var resourceGroup = resource.Id.Substring(startPosition + 16, endPosition - startPosition - 16);
AutomationAccountGetResponse account = await automationManagementClient.AutomationAccounts.GetAsync(resourceGroup, resource.Name, cts.Token);
result.Add(account.AutomationAccount);
var accountResourceGroup = new ResourceGroupExtended();
accountResourceGroup.Name = resourceGroup;
accountResourceGroups.Add(account.AutomationAccount, accountResourceGroup);
}
return(result);
}
public static async Task UploadToCloud(ICollection<AutomationAsset> assetsToUpload, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName)
{
var jss = new JavaScriptSerializer();
foreach (var assetToUpload in assetsToUpload)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
if (assetToUpload is AutomationVariable)
{
var asset = (AutomationVariable)assetToUpload;
var properties = new VariableCreateOrUpdateProperties();
properties.IsEncrypted = asset.Encrypted;
var stringBuilder = new StringBuilder();
jss.Serialize(asset.getValue(), stringBuilder);
properties.Value = stringBuilder.ToString();
await automationApi.Variables.CreateOrUpdateAsync(resourceGroupName, automationAccountName, new VariableCreateOrUpdateParameters(asset.Name, properties), cts.Token);
}
else if(assetToUpload is AutomationCredential)
{
var asset = (AutomationCredential)assetToUpload;
var properties = new CredentialCreateOrUpdateProperties();
properties.UserName = asset.getUsername();
properties.Password = asset.getPassword();
await automationApi.PsCredentials.CreateOrUpdateAsync(resourceGroupName, automationAccountName, new CredentialCreateOrUpdateParameters(asset.Name, properties), cts.Token);
}
else if (assetToUpload is AutomationConnection)
{
var asset = (AutomationConnection)assetToUpload;
var properties = new ConnectionCreateOrUpdateProperties();
var connectionFieldsAsJson = new Dictionary<string, string>();
foreach(KeyValuePair<string, object> field in asset.getFields())
{
connectionFieldsAsJson.Add(field.Key, field.Value.ToString());
}
properties.FieldDefinitionValues = connectionFieldsAsJson;
properties.ConnectionType = new ConnectionTypeAssociationProperty();
properties.ConnectionType.Name = asset.ConnectionType;
await automationApi.Connections.CreateOrUpdateAsync(resourceGroupName, automationAccountName, new ConnectionCreateOrUpdateParameters(asset.Name, properties), cts.Token);
}
// TODO: implement certificates
}
}
/* This is the only way I can see to "check out" a runbook (get it from Published to Edit state) using the SDK. */
public static async Task CheckOutRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, AutomationAccount account)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookGetResponse response = await automationManagementClient.Runbooks.GetAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
if (response.Runbook.Properties.State != "Published")
{
return;
}
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookContentResponse runbookContentResponse = await automationManagementClient.Runbooks.ContentAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
// Create draft properties
RunbookCreateOrUpdateDraftParameters draftParams = new RunbookCreateOrUpdateDraftParameters();
draftParams.Properties = new RunbookCreateOrUpdateDraftProperties();
draftParams.Properties.Description = response.Runbook.Properties.Description;
draftParams.Properties.LogProgress = response.Runbook.Properties.LogProgress;
draftParams.Properties.LogVerbose = response.Runbook.Properties.LogVerbose;
draftParams.Properties.RunbookType = response.Runbook.Properties.RunbookType;
draftParams.Properties.Draft = new RunbookDraft();
draftParams.Tags = response.Runbook.Tags;
draftParams.Name = runbook.Name;
draftParams.Location = account.Location;
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.Runbooks.CreateOrUpdateWithDraftAsync(resourceGroupName, account.Name, draftParams, cts.Token);
RunbookDraftUpdateParameters draftUpdateParams = new RunbookDraftUpdateParameters()
{
Name = runbook.Name,
Stream = runbookContentResponse.Stream.ToString()
};
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.RunbookDraft.UpdateAsync(resourceGroupName, account.Name, draftUpdateParams, cts.Token);
/* Ensure the correct sync status is detected */
if (runbook.localFileInfo != null)
{
RunbookDraft draft = await GetRunbookDraft(runbook.Name, automationManagementClient, resourceGroupName, account.Name);
runbook.localFileInfo.LastWriteTime = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draft.LastModifiedTime.LocalDateTime;
}
}
public IEnumerable <Module> ListModules(string resourceGroupName, string automationAccountName)
{
IList <AutomationManagement.Models.Module> modulesModels = AutomationManagementClient
.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.Modules.List(resourceGroupName, automationAccountName);
return(new ResponseWithSkipToken <AutomationManagement.Models.Module>(
response, response.Modules));
});
return(modulesModels.Select(c => new Module(resourceGroupName, automationAccountName, c)));
}
public IEnumerable <Schedule> ListSchedules(string automationAccountName)
{
IList <AutomationManagement.Models.Schedule> scheduleModels = AutomationManagementClient.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.Schedules.List(
automationAccountName, skipToken);
return(new ResponseWithSkipToken <AutomationManagement.Models.Schedule>(
response, response.Schedules));
});
return(scheduleModels.Select(this.CreateScheduleFromScheduleModel));
}
/// <summary>
/// This function checks is source control is enabled on the automation account
/// </summary>
/// <param name="automationClient"></param>
/// <param name="resourceGroup"></param>
/// <param name="automationAccount"></param>
/// <returns>boolean value indicating if source control is enabled. True means it is and false means it is not</returns>
public static async Task<bool> isSourceControlEnabled(AutomationManagementClient automationClient, String resourceGroup, String automationAccount)
{
// TODO This is a current way to determine if source control is enabled.
// Will update this once the API becomes available.
try {
var response = await automationClient.Variables.GetAsync(resourceGroup, automationAccount, Constants.sourceControlConnectionVariable);
return true;
}
catch
{
return false;
}
}
public static async Task<ISet<AutomationRunbook>> GetAllRunbookMetadata(AutomationManagementClient automationManagementClient, string workspace, string resourceGroupName, string accountName)
{
ISet<AutomationRunbook> result = new SortedSet<AutomationRunbook>();
IList<Runbook> cloudRunbooks = await DownloadRunbookMetadata(automationManagementClient, resourceGroupName, accountName);
/* Create a Dictionary of (filename, filepath) tuples found on disk. This will come in handy */
Dictionary<string, string> filePathForRunbook = new Dictionary<string, string>();
if (Directory.Exists(workspace))
{
string[] localRunbookFilePaths = Directory.GetFiles(workspace, "*.ps1");
foreach (string path in localRunbookFilePaths)
{
filePathForRunbook.Add(System.IO.Path.GetFileNameWithoutExtension(path), path);
}
}
/* Start by checking the downloaded runbooks */
foreach (Runbook cloudRunbook in cloudRunbooks)
{
/* Don't bother with graphical runbooks, since the ISE can't do anything with them */
if (cloudRunbook.Properties.RunbookType != Constants.RunbookType.Graphical)
{
RunbookDraftGetResponse draftResponse;
try
{
draftResponse = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, accountName, cloudRunbook.Name);
}
catch
{
draftResponse = null;
}
if (filePathForRunbook.ContainsKey(cloudRunbook.Name))
{
result.Add(new AutomationRunbook(new FileInfo(filePathForRunbook[cloudRunbook.Name]), cloudRunbook, draftResponse.RunbookDraft));
}
else
{
result.Add(new AutomationRunbook(cloudRunbook, draftResponse.RunbookDraft));
}
}
}
/* Now find runbooks on disk that aren't yet accounted for */
foreach (string localRunbookName in filePathForRunbook.Keys)
{
//Not great, but works for now
if (result.FirstOrDefault(x => x.Name == localRunbookName) == null)
{
result.Add(new AutomationRunbook(new FileInfo(filePathForRunbook[localRunbookName])));
}
}
return result;
}
public IEnumerable <Runbook> ListRunbooks(string automationAccountName)
{
IList <AutomationManagement.Models.Runbook> runbookModels = AutomationManagementClient.ContinuationTokenHandler(
skipToken =>
{
var listRunbookResponse =
this.automationManagementClient.Runbooks.ListWithSchedules(
automationAccountName, skipToken);
return(new ResponseWithSkipToken <AutomationManagement.Models.Runbook>(
listRunbookResponse, listRunbookResponse.Runbooks));
});
return(runbookModels.Select(runbookModel => new Runbook(runbookModel)));
}
/// <summary>
/// This function checks is source control is enabled on the automation account
/// </summary>
/// <param name="automationClient"></param>
/// <param name="resourceGroup"></param>
/// <param name="automationAccount"></param>
/// <returns>boolean value indicating if source control is enabled. True means it is and false means it is not</returns>
public static async Task <bool> isSourceControlEnabled(AutomationManagementClient automationClient, String resourceGroup, String automationAccount)
{
// TODO This is a current way to determine if source control is enabled.
// Will update this once the API becomes available.
try {
var response = await automationClient.Variables.GetAsync(resourceGroup, automationAccount, Constants.sourceControlConnectionVariable);
return(true);
}
catch
{
return(false);
}
}
public IEnumerable <Model.AutomationAccount> ListAutomationAccounts(string resourceGroupName)
{
Requires.Argument("ResourceGroupName", resourceGroupName).NotNull();
return(AutomationManagementClient
.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.AutomationAccounts.List(
resourceGroupName);
return new ResponseWithSkipToken <AutomationManagement.Models.AutomationAccount>(
response, response.AutomationAccounts);
}).Select(c => new Model.AutomationAccount(resourceGroupName, c)));
}
public IEnumerable <Credential> ListCredentials(string automationAccountName)
{
IList <AutomationManagement.Models.Credential> credentialModels = AutomationManagementClient
.ContinuationTokenHandler(
skipToken =>
{
var response = this.automationManagementClient.PsCredentials.List(automationAccountName,
skipToken);
return(new ResponseWithSkipToken <AutomationManagement.Models.Credential>(
response, response.Credentials));
});
return(credentialModels.Select(c => new Credential(automationAccountName, c)));
}
public static async Task <ISet <ConnectionType> > GetConnectionTypes(AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
var connectionTypeListResponse = await automationApi.ConnectionTypes.ListAsync(resourceGroupName, automationAccountName, cts.Token);
var connectionTypes = new HashSet <ConnectionType>();
foreach (var connectionType in connectionTypeListResponse.ConnectionTypes)
{
connectionTypes.Add(connectionType);
}
return(connectionTypes);
}
public async Task <string> GetAutomationRunbookDescriptionAsync(
string accessToken,
string subscriptionId,
string resourceGroupName,
string automationAccountName,
string runbookName)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationRunbookResult = await automationClient.Runbooks.GetAsync(resourceGroupName, automationAccountName, runbookName);
return(automationRunbookResult.Runbook.Properties.Description);
}
}
public static async Task <ISet <AutomationModule> > GetAllModuleMetadata(AutomationManagementClient automationManagementClient, string workspace, string resourceGroupName, string accountName, Dictionary <string, PSObject> localModulesParsed)
{
ISet <AutomationModule> result = new SortedSet <AutomationModule>();
IList <Module> cloudModules = await DownloadModuleMetadata(automationManagementClient, resourceGroupName, accountName);
/* Start by checking the downloaded modules */
foreach (Module cloudModule in cloudModules)
{
ModuleGetResponse draftResponse;
try
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
draftResponse = await automationManagementClient.Modules.GetAsync(resourceGroupName, accountName, cloudModule.Name, cts.Token);
}
catch
{
draftResponse = null;
continue;
}
if (localModulesParsed != null && localModulesParsed.ContainsKey(cloudModule.Name))
{
var moduleFileInfo = new FileInfo(localModulesParsed[cloudModule.Name].Properties["Path"].Value.ToString());
result.Add(new AutomationModule(localModulesParsed[cloudModule.Name], cloudModule, draftResponse.Module, moduleFileInfo.LastWriteTime));
moduleFileInfo = null;
}
else
{
result.Add(new AutomationModule(cloudModule, draftResponse.Module));
}
}
/* Now find module on disk that aren't yet accounted for */
if (localModulesParsed != null)
{
foreach (string localModuleName in localModulesParsed.Keys)
{
if (result.FirstOrDefault(x => x.Name == localModuleName) == null)
{
var moduleFileInfo = new FileInfo(localModulesParsed[localModuleName].Properties["Path"].Value.ToString());
result.Add(new AutomationModule(localModulesParsed[localModuleName], moduleFileInfo.LastWriteTime));
moduleFileInfo = null;
}
}
}
return(result);
}
public async Task <IEnumerable <AutomationAccount> > ListAutomationAccountsAsync(string accessToken, string subscriptionId)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationAccountsResult = await automationClient.AutomationAccounts.ListAsync(null).ConfigureAwait(false);
return(automationAccountsResult.AutomationAccounts.Select(account => new AutomationAccount
{
SubscriptionId = subscriptionId,
ResourceGroup = GetResourceGroup(account.Id),
AutomationAccountId = account.Id,
AutomationAccountName = account.Name,
}).ToList());
}
}
public static async Task<JobCreateResponse> startSouceControlJob(AutomationManagementClient automationClient, String resourceGroup, String automationAccount)
{
var jobParams = new JobCreateParameters
{
Properties = new JobCreateProperties
{
Runbook = new RunbookAssociationProperty
{
Name = Constants.sourceControlRunbook
},
Parameters = null
}
};
var jobResponse = await automationClient.Jobs.CreateAsync(resourceGroup,
automationAccount, jobParams, new CancellationToken());
return jobResponse;
}
public static async void DownloadFromCloud(ICollection<AutomationAsset> assetsToDownload, String localWorkspacePath, AutomationManagementClient automationApi, string resourceGroupName, string automationAccountName, String encryptionCertThumbprint)
{
var cloudAssets = await AutomationAssetManager.GetAll(null, automationApi, resourceGroupName, automationAccountName, encryptionCertThumbprint);
var assetsToSaveLocally = new SortedSet<AutomationAsset>();
foreach (var cloudAsset in cloudAssets)
{
foreach (var assetToDownload in assetsToDownload)
{
if (cloudAsset.Equals(assetToDownload))
{
assetsToSaveLocally.Add(cloudAsset);
break;
}
}
}
AutomationAssetManager.SaveLocally(localWorkspacePath, assetsToSaveLocally, encryptionCertThumbprint);
}
/* This is the only way I can see to "check out" a runbook (get it from Published to Edit state) using the SDK. */
public static async Task CheckOutRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, AutomationAccount account)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookGetResponse response = await automationManagementClient.Runbooks.GetAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
if (response.Runbook.Properties.State != "Published")
return;
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookContentResponse runbookContentResponse = await automationManagementClient.Runbooks.ContentAsync(resourceGroupName, account.Name, runbook.Name, cts.Token);
// Create draft properties
RunbookCreateOrUpdateDraftParameters draftParams = new RunbookCreateOrUpdateDraftParameters();
draftParams.Properties = new RunbookCreateOrUpdateDraftProperties();
draftParams.Properties.Description = response.Runbook.Properties.Description;
draftParams.Properties.LogProgress = response.Runbook.Properties.LogProgress;
draftParams.Properties.LogVerbose = response.Runbook.Properties.LogVerbose;
draftParams.Properties.RunbookType = response.Runbook.Properties.RunbookType;
draftParams.Properties.Draft = new RunbookDraft();
draftParams.Tags = response.Runbook.Tags;
draftParams.Name = runbook.Name;
draftParams.Location = account.Location;
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.Runbooks.CreateOrUpdateWithDraftAsync(resourceGroupName, account.Name, draftParams, cts.Token);
RunbookDraftUpdateParameters draftUpdateParams = new RunbookDraftUpdateParameters()
{
Name = runbook.Name,
Stream = runbookContentResponse.Stream.ToString()
};
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.RunbookDraft.UpdateAsync(resourceGroupName, account.Name, draftUpdateParams, cts.Token);
/* Ensure the correct sync status is detected */
if (runbook.localFileInfo != null)
{
RunbookDraft draft = await GetRunbookDraft(runbook.Name, automationManagementClient, resourceGroupName, account.Name);
runbook.localFileInfo.LastWriteTime = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draft.LastModifiedTime.LocalDateTime;
}
}
public async Task<IEnumerable<AutomationAccount>> ListRunbooksAsync(string accessToken, string subscriptionId)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationAccountsResult = await automationClient.AutomationAccounts.ListAsync(null).ConfigureAwait(false);
var automationAccounts = await Task.WhenAll(
automationAccountsResult.AutomationAccounts.Select(
async account => new AutomationAccount
{
SubscriptionId = subscriptionId,
ResourceGroup = GetResourceGroup(account.Id),
AutomationAccountId = account.Id,
AutomationAccountName = account.Name,
Runbooks = await this.ListAutomationRunbooks(accessToken, subscriptionId, GetResourceGroup(account.Id), account.Name)
}).ToList());
return automationAccounts;
}
}
public static async Task UploadRunbookAsDraft(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, AutomationAccount account)
{
RunbookCreateOrUpdateDraftProperties draftProperties = new RunbookCreateOrUpdateDraftProperties("Script", new RunbookDraft());
draftProperties.Description = runbook.Description;
RunbookCreateOrUpdateDraftParameters draftParams = new RunbookCreateOrUpdateDraftParameters(draftProperties);
draftParams.Name = runbook.Name;
draftParams.Location = account.Location;
await automationManagementClient.Runbooks.CreateOrUpdateWithDraftAsync(resourceGroupName, account.Name, draftParams);
/* Update the runbook content from .ps1 file */
RunbookDraftUpdateParameters draftUpdateParams = new RunbookDraftUpdateParameters()
{
Name = runbook.Name,
Stream = File.ReadAllText(runbook.localFileInfo.FullName)
};
await automationManagementClient.RunbookDraft.UpdateAsync(resourceGroupName, account.Name, draftUpdateParams);
/* Ensure the correct sync status is detected */
RunbookDraft draft = await GetRunbookDraft(runbook.Name, automationManagementClient, resourceGroupName, account.Name);
runbook.localFileInfo.LastWriteTime = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draft.LastModifiedTime.LocalDateTime;
}
public static async Task UploadRunbookAsDraft(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, AutomationAccount account)
{
RunbookCreateOrUpdateDraftProperties draftProperties;
// Parse the script to determine if it is a PS workflow or native script
String PSScriptText = File.ReadAllText(runbook.localFileInfo.FullName);
System.Management.Automation.Language.Token[] AST;
System.Management.Automation.Language.ParseError[] ASTError = null;
var ASTScript = System.Management.Automation.Language.Parser.ParseInput(PSScriptText, out AST, out ASTError);
// If the script starts with workflow, then create a PS Workflow script runbook or else create a native PS script runbook
if (ASTScript.EndBlock.Extent.Text.ToLower().StartsWith("workflow"))
{
draftProperties = new RunbookCreateOrUpdateDraftProperties(Constants.RunbookType.Workflow, new RunbookDraft());
}
else
draftProperties = new RunbookCreateOrUpdateDraftProperties(Constants.RunbookType.PowerShellScript, new RunbookDraft());
draftProperties.Description = runbook.Description;
RunbookCreateOrUpdateDraftParameters draftParams = new RunbookCreateOrUpdateDraftParameters(draftProperties);
draftParams.Name = runbook.Name;
draftParams.Location = account.Location;
await automationManagementClient.Runbooks.CreateOrUpdateWithDraftAsync(resourceGroupName, account.Name, draftParams);
/* Update the runbook content from .ps1 file */
RunbookDraftUpdateParameters draftUpdateParams = new RunbookDraftUpdateParameters()
{
Name = runbook.Name,
Stream = PSScriptText
};
await automationManagementClient.RunbookDraft.UpdateAsync(resourceGroupName, account.Name, draftUpdateParams);
/* Ensure the correct sync status is detected */
RunbookDraft draft = await GetRunbookDraft(runbook.Name, automationManagementClient, resourceGroupName, account.Name);
runbook.localFileInfo.LastWriteTime = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = draft.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = draft.LastModifiedTime.LocalDateTime;
}
private static async Task<IList<Runbook>> DownloadRunbookMetadata(AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
RunbookListResponse cloudRunbooks = await automationManagementClient.Runbooks.ListAsync(resourceGroupName, accountName);
return cloudRunbooks.Runbooks;
}
public static async Task<RunbookDraft> GetRunbookDraft(string runbookName, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
RunbookDraftGetResponse response = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, accountName, runbookName);
return response.RunbookDraft;
}
private async Task<IEnumerable<RunbookParameter>> ListAutomationRunbookParameters(
string accessToken,
string subscriptionId,
string resourceGroupName,
string automationAccountName,
string runbookName)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationRunbookResult = await automationClient.Runbooks.GetAsync(resourceGroupName, automationAccountName, runbookName);
var automationRunbookPrameters = automationRunbookResult.Runbook.Properties.Parameters.Select(
parameter => new RunbookParameter
{
ParameterName = parameter.Key,
DefaultValue = parameter.Value.DefaultValue,
IsMandatory = parameter.Value.IsMandatory,
Position = parameter.Value.Position,
Type = parameter.Value.Type
}).ToList();
return automationRunbookPrameters;
}
}
/// <summary>
/// Refreshes the token used to access azure automation.
/// This is currently called from a timer that runs on the Constants.tokenRefreshInterval
/// If it is about to expire (2 minutes from the next refresh, it will renew)
/// </summary>
public void RefreshAutomationClientwithNewToken()
{
// Get the token for the tenant on this subscription and check if it is about to expire.
// If it is, refresh it if possible.
if (currSubscription == null) return;
if (azureARMAuthResult.ExpiresOn.ToLocalTime() < DateTime.Now.AddMinutes(Constants.tokenRefreshInterval + 2))
{
azureARMAuthResult = AuthenticateHelper.RefreshTokenByAuthority(currSubscription.ActiveDirectoryTenantId);
subscriptionCreds = new TokenCloudCredentials(currSubscription.SubscriptionId, azureARMAuthResult.AccessToken);
automationManagementClient = new AutomationManagementClient(subscriptionCreds);
// Add user agent string to indicate this is coming from the ISE automation client.
ProductInfoHeaderValue ISEClientAgent = new ProductInfoHeaderValue(Constants.ISEUserAgent, Constants.ISEVersion);
automationManagementClient.UserAgent.Add(ISEClientAgent);
}
}
public RequestSettings(IAutomationManagementClient automationClient)
{
client = ((AutomationManagementClient)automationClient);
client.HttpClient.DefaultRequestHeaders.Remove(Constants.ClientRequestIdHeaderName);
client.HttpClient.DefaultRequestHeaders.Add(Constants.ClientRequestIdHeaderName, Guid.NewGuid().ToString());
}
private async Task<IEnumerable<Runbook>> ListAutomationRunbooks(string accessToken, string subscriptionId, string resourceGroupName, string automationAccountName)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationRunbooksResult = await automationClient.Runbooks.ListAsync(resourceGroupName, automationAccountName);
var automationRunbooks = await Task.WhenAll(automationRunbooksResult.Runbooks.Select(
async runbook => new Runbook
{
RunbookId = runbook.Id,
RunbookName = runbook.Name,
RunbookParameters = await this.ListAutomationRunbookParameters(accessToken, subscriptionId, resourceGroupName, automationAccountName, runbook.Name)
}).ToList());
return automationRunbooks;
}
}
public static async Task DeleteCloudRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
await automationManagementClient.Runbooks.DeleteAsync(resourceGroupName, accountName, runbook.Name, cts.Token);
}
private static async Task<IList<Runbook>> DownloadRunbookMetadata(AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
IList<Runbook> runbooks = new List<Runbook>();
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookListResponse cloudRunbooks = await automationManagementClient.Runbooks.ListAsync(resourceGroupName, accountName, cts.Token);
foreach (var runbook in cloudRunbooks.Runbooks)
{
runbooks.Add(runbook);
}
while (cloudRunbooks.NextLink != null)
{
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
cloudRunbooks = await automationManagementClient.Runbooks.ListNextAsync(cloudRunbooks.NextLink, cts.Token);
foreach (var runbook in cloudRunbooks.Runbooks)
{
runbooks.Add(runbook);
}
}
return runbooks;
}
public static async Task<RunbookDraft> GetRunbookDraft(string runbookName, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookDraftGetResponse response = await automationManagementClient.RunbookDraft.GetAsync(resourceGroupName, accountName, runbookName, cts.Token);
return response.RunbookDraft;
}
private async Task<IEnumerable<RunbookJob>> ListAutomationJobs(string accessToken, string subscriptionId, string resourceGroupName, string automationAccountName)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationJobsResult = await automationClient.Jobs.ListAsync(resourceGroupName, automationAccountName, parameters: null);
var automationJobs = automationJobsResult.Jobs.Select(
job => new RunbookJob
{
JobId = job.Properties.JobId.ToString(),
Status = job.Properties.Status,
RunbookName = job.Properties.Runbook?.Name ?? "_(Unknown)_"
}).ToList();
return automationJobs;
}
}
public async Task<RunbookJob> GetAutomationJobAsync(string accessToken, string subscriptionId, string resourceGroupName, string automationAccountName, string jobId, bool configureAwait = false)
{
var credentials = new TokenCredentials(subscriptionId, accessToken);
using (var automationClient = new AutomationManagementClient(credentials))
{
var automationJobResult = configureAwait ? await automationClient.Jobs.GetAsync(resourceGroupName, automationAccountName, new Guid(jobId)).ConfigureAwait(false) :
await automationClient.Jobs.GetAsync(resourceGroupName, automationAccountName, new Guid(jobId));
var automationJob = new RunbookJob
{
JobId = automationJobResult.Job.Properties.JobId.ToString(),
Status = automationJobResult.Job.Properties.Status,
RunbookName = automationJobResult.Job.Properties.Runbook?.Name ?? "_(Unknown)_",
ResourceGroupName = resourceGroupName,
AutomationAccountName = automationAccountName,
StartDateTime = automationJobResult.Job.Properties.StartTime,
EndDateTime = automationJobResult.Job.Properties.EndTime
};
return automationJob;
}
}
public static async Task<LongRunningOperationResultResponse> PublishRunbook(AutomationRunbook runbook, AutomationManagementClient automationManagementClient, string resourceGroupName, string accountName)
{
RunbookDraftPublishParameters publishParams = new RunbookDraftPublishParameters
{
Name = runbook.Name,
PublishedBy = "ISE User: " + System.Security.Principal.WindowsIdentity.GetCurrent().Name
};
CancellationTokenSource cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
LongRunningOperationResultResponse resultResponse = await automationManagementClient.RunbookDraft.PublishAsync(resourceGroupName, accountName, publishParams, cts.Token);
/* Ensure the correct sync status is detected */
if (runbook.localFileInfo != null)
{
cts = new CancellationTokenSource();
cts.CancelAfter(TIMEOUT_MS);
RunbookGetResponse response = await automationManagementClient.Runbooks.GetAsync(resourceGroupName, accountName, runbook.Name, cts.Token);
runbook.localFileInfo.LastWriteTime = response.Runbook.Properties.LastModifiedTime.LocalDateTime;
runbook.LastModifiedLocal = response.Runbook.Properties.LastModifiedTime.LocalDateTime;
runbook.LastModifiedCloud = response.Runbook.Properties.LastModifiedTime.LocalDateTime;
}
/* Return the publish response */
return resultResponse;
}
public async Task<IList<AutomationAccount>> GetAutomationAccounts()
{
if(currSubscription == null)
throw new Exception(Properties.Resources.SubscriptionNotSet);
// Get the token for the tenant on this subscription.
azureARMAuthResult = AuthenticateHelper.RefreshTokenByAuthority(currSubscription.ActiveDirectoryTenantId);
subscriptionCreds = new TokenCloudCredentials(currSubscription.SubscriptionId, azureARMAuthResult.AccessToken);
automationManagementClient = new AutomationManagementClient(subscriptionCreds);
// Add user agent string to indicate this is coming from the ISE automation client.
ProductInfoHeaderValue ISEClientAgent = new ProductInfoHeaderValue(Constants.ISEUserAgent, Constants.ISEVersion);
automationManagementClient.UserAgent.Add(ISEClientAgent);
//TODO: does this belong here?
if (accountResourceGroups == null)
accountResourceGroups = new Dictionary<AutomationAccount, ResourceGroupExtended>();
else
accountResourceGroups.Clear();
IList<AutomationAccount> result = new List<AutomationAccount>();
IList<ResourceGroupExtended> resourceGroups = await this.GetResourceGroups();
foreach (ResourceGroupExtended resourceGroup in resourceGroups)
{
AutomationAccountListResponse accountListResponse = await automationManagementClient.AutomationAccounts.ListAsync(resourceGroup.Name);
foreach (AutomationAccount account in accountListResponse.AutomationAccounts)
{
result.Add(account);
accountResourceGroups.Add(account, resourceGroup);
}
}
return result;
}