client Request Id for Runbook cmdlets

Author: safeermohammed

src/Common/Commands.ScenarioTest/Resources/Automation/AutomationTests.ps1

@@ -17,7 +17,7 @@
 Checks whether the first string contains the second one
 #>
 
-$accountName='safeer'
+$accountName='account'
 $location = "East US"
 
 function AssertContains

src/ServiceManagement/Automation/Commands.Automation/Commands.Automation.csproj

@@ -195,6 +195,7 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
+    <Compile Include="RequestSettings.cs" />
   </ItemGroup>
   <ItemGroup>
     <Content Include="Microsoft.Azure.Commands.Automation.dll-help.xml">

src/ServiceManagement/Automation/Commands.Automation/Common/AutomationClient.cs

@@ -181,26 +181,35 @@ public IEnumerable<Runbook> ListRunbooks(string automationAccountName)
         public Runbook CreateRunbookByName(string automationAccountName, string runbookName, string description,
             string[] tags)
         {
-            var runbookModel = this.TryGetRunbookModel(automationAccountName, runbookName);
-            if (runbookModel != null)
+            using (var request = new RequestSettings(this.automationManagementClient))
             {
-                throw new ResourceCommonException(typeof(Runbook),
-                    string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyExists, runbookName));
-            }
+                var runbookModel = this.TryGetRunbookModel(automationAccountName, runbookName);
+                if (runbookModel != null)
+                {
+                    throw new ResourceCommonException(typeof (Runbook),
+                        string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyExists, runbookName));
+                }
 
-            var rdcprop = new RunbookCreateDraftProperties()
-            {
-                Description = description,
-                RunbookType = RunbookTypeEnum.Script,
-                Draft = new RunbookDraft(),
-                ServiceManagementTags = (tags != null) ? string.Join(Constants.RunbookTagsSeparatorString, tags) : null
-            };
+                var rdcprop = new RunbookCreateDraftProperties()
+                {
+                    Description = description,
+                    RunbookType = RunbookTypeEnum.Script,
+                    Draft = new RunbookDraft(),
+                    ServiceManagementTags =
+                        (tags != null) ? string.Join(Constants.RunbookTagsSeparatorString, tags) : null
+                };
 
-            var rdcparam = new RunbookCreateDraftParameters() { Name = runbookName, Properties = rdcprop, Tags = null };
+                var rdcparam = new RunbookCreateDraftParameters()
+                {
+                    Name = runbookName,
+                    Properties = rdcprop,
+                    Tags = null
+                };
 
-            this.automationManagementClient.Runbooks.CreateWithDraft(automationAccountName, rdcparam);
+                this.automationManagementClient.Runbooks.CreateWithDraft(automationAccountName, rdcparam);
 
-            return this.GetRunbook(automationAccountName, runbookName);
+                return this.GetRunbook(automationAccountName, runbookName);
+           }
         }
 
         public Runbook CreateRunbookByPath(string automationAccountName, string runbookPath, string description,
@@ -209,31 +218,37 @@ public Runbook CreateRunbookByPath(string automationAccountName, string runbookP
 
             var runbookName = Path.GetFileNameWithoutExtension(runbookPath);
 
-            var runbookModel = this.TryGetRunbookModel(automationAccountName, runbookName);
-            if (runbookModel != null)
+            using (var request = new RequestSettings(this.automationManagementClient))
             {
-                throw new ResourceCommonException(typeof(Runbook),
-                    string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyExists, runbookName));
-            }
+                var runbookModel = this.TryGetRunbookModel(automationAccountName, runbookName);
+                if (runbookModel != null)
+                {
+                    throw new ResourceCommonException(typeof (Runbook),
+                        string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyExists, runbookName));
+                }
 
-            var runbook = this.CreateRunbookByName(automationAccountName, runbookName, description, tags);
+                var runbook = this.CreateRunbookByName(automationAccountName, runbookName, description, tags);
 
-            var rduprop = new RunbookDraftUpdateParameters()
-            {
-                Name = runbookName,
-                Stream = File.ReadAllText(runbookPath)
-            };
+                var rduprop = new RunbookDraftUpdateParameters()
+                {
+                    Name = runbookName,
+                    Stream = File.ReadAllText(runbookPath)
+                };
 
-            this.automationManagementClient.RunbookDraft.Update(automationAccountName, rduprop);
+                this.automationManagementClient.RunbookDraft.Update(automationAccountName, rduprop);
 
-            return runbook;
+                return runbook;
+            }
         }
 
         public void DeleteRunbook(string automationAccountName, string runbookName)
         {
             try
             {
-                this.automationManagementClient.Runbooks.Delete(automationAccountName, runbookName);
+                using (var request = new RequestSettings(this.automationManagementClient))
+                {
+                    this.automationManagementClient.Runbooks.Delete(automationAccountName, runbookName);
+                }
             }
             catch (CloudException cloudException)
             {
@@ -250,119 +265,153 @@ public void DeleteRunbook(string automationAccountName, string runbookName)
         public Runbook UpdateRunbook(string automationAccountName, string runbookName, string description,
             string[] tags, bool? logProgress, bool? logVerbose)
         {
-            var runbookModel = this.TryGetRunbookModel(automationAccountName, runbookName);
-            if (runbookModel == null)
+            using (var request = new RequestSettings(this.automationManagementClient))
             {
-                throw new ResourceCommonException(typeof(Runbook),
-                    string.Format(CultureInfo.CurrentCulture, Resources.RunbookNotFound, runbookName));
-            }
+                var runbookModel = this.TryGetRunbookModel(automationAccountName, runbookName);
+                if (runbookModel == null)
+                {
+                    throw new ResourceCommonException(typeof (Runbook),
+                        string.Format(CultureInfo.CurrentCulture, Resources.RunbookNotFound, runbookName));
+                }
 
-            var runbookUpdateParameters = new RunbookUpdateParameters();
-            runbookUpdateParameters.Name = runbookName;
-            runbookUpdateParameters.Tags = null;
+                var runbookUpdateParameters = new RunbookUpdateParameters();
+                runbookUpdateParameters.Name = runbookName;
+                runbookUpdateParameters.Tags = null;
 
-            runbookUpdateParameters.Properties =  new RunbookUpdateProperties();
-            runbookUpdateParameters.Properties.Description = description ?? runbookModel.Properties.Description;
-            runbookUpdateParameters.Properties.LogProgress = (logProgress.HasValue) ?  logProgress.Value : runbookModel.Properties.LogProgress;
-            runbookUpdateParameters.Properties.LogVerbose = (logVerbose.HasValue) ? logVerbose.Value : runbookModel.Properties.LogVerbose;
-            runbookUpdateParameters.Properties.ServiceManagementTags = (tags != null)
-                ? string.Join(Constants.RunbookTagsSeparatorString, tags)
-                : runbookModel.Properties.ServiceManagementTags;
+                runbookUpdateParameters.Properties = new RunbookUpdateProperties();
+                runbookUpdateParameters.Properties.Description = description ?? runbookModel.Properties.Description;
+                runbookUpdateParameters.Properties.LogProgress = (logProgress.HasValue)
+                    ? logProgress.Value
+                    : runbookModel.Properties.LogProgress;
+                runbookUpdateParameters.Properties.LogVerbose = (logVerbose.HasValue)
+                    ? logVerbose.Value
+                    : runbookModel.Properties.LogVerbose;
+                runbookUpdateParameters.Properties.ServiceManagementTags = (tags != null)
+                    ? string.Join(Constants.RunbookTagsSeparatorString, tags)
+                    : runbookModel.Properties.ServiceManagementTags;
 
-            var runbook = this.automationManagementClient.Runbooks.Update(automationAccountName, runbookUpdateParameters).Runbook;
+                var runbook =
+                    this.automationManagementClient.Runbooks.Update(automationAccountName, runbookUpdateParameters)
+                        .Runbook;
 
-            return new Runbook(automationAccountName, runbook);
+                return new Runbook(automationAccountName, runbook);
+            }
         }
 
         public RunbookDefinition UpdateRunbookDefinition(string automationAccountName, string runbookName,
             string runbookPath, bool overwrite)
         {
-            var runbook = this.TryGetRunbookModel(automationAccountName, runbookName);
-            if (runbook == null)
+            using (var request = new RequestSettings(this.automationManagementClient))
             {
-                throw new ResourceNotFoundException(typeof(Runbook),
-                    string.Format(CultureInfo.CurrentCulture, Resources.RunbookNotFound, runbookName));
-            }
+                var runbook = this.TryGetRunbookModel(automationAccountName, runbookName);
+                if (runbook == null)
+                {
+                    throw new ResourceNotFoundException(typeof (Runbook),
+                        string.Format(CultureInfo.CurrentCulture, Resources.RunbookNotFound, runbookName));
+                }
 
-            if ((0 !=
-                 String.Compare(runbook.Properties.State, RunbookState.Published, CultureInfo.InvariantCulture,
-                     CompareOptions.IgnoreCase) && overwrite == false))
-            {
-                throw new ResourceCommonException(typeof(Runbook),
-                    string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyHasDraft, runbookName));
-            }
+                if ((0 !=
+                     String.Compare(runbook.Properties.State, RunbookState.Published, CultureInfo.InvariantCulture,
+                         CompareOptions.IgnoreCase) && overwrite == false))
+                {
+                    throw new ResourceCommonException(typeof (Runbook),
+                        string.Format(CultureInfo.CurrentCulture, Resources.RunbookAlreadyHasDraft, runbookName));
+                }
 
-            this.automationManagementClient.RunbookDraft.Update(automationAccountName,
-                new RunbookDraftUpdateParameters { Name = runbookName, Stream = File.ReadAllText(runbookPath) });
+                this.automationManagementClient.RunbookDraft.Update(automationAccountName,
+                    new RunbookDraftUpdateParameters {Name = runbookName, Stream = File.ReadAllText(runbookPath)});
 
-            var content =
-                this.automationManagementClient.RunbookDraft.Content(automationAccountName, runbookName).Stream;
+                var content =
+                    this.automationManagementClient.RunbookDraft.Content(automationAccountName, runbookName).Stream;
 
-            return new RunbookDefinition(automationAccountName, runbook, content, Constants.Draft);
+                return new RunbookDefinition(automationAccountName, runbook, content, Constants.Draft);
+            }
         }
 
         public IEnumerable<RunbookDefinition> ListRunbookDefinitionsByRunbookName(string automationAccountName,
             string runbookName, bool? isDraft)
         {
             var ret = new List<RunbookDefinition>();
-
-            var runbook = this.TryGetRunbookModel(automationAccountName, runbookName);
-            if (runbook == null)
+            using (var request = new RequestSettings(this.automationManagementClient))
             {
-                throw new ResourceNotFoundException(typeof(Runbook),
-                    string.Format(CultureInfo.CurrentCulture, Resources.RunbookNotFound, runbookName));
-            }
-
-            var draftContent = String.Empty;
-            var publishedContent = String.Empty;
+                var runbook = this.TryGetRunbookModel(automationAccountName, runbookName);
+                if (runbook == null)
+                {
+                    throw new ResourceNotFoundException(typeof (Runbook),
+                        string.Format(CultureInfo.CurrentCulture, Resources.RunbookNotFound, runbookName));
+                }
 
-            if (0 != String.Compare(runbook.Properties.State, RunbookState.Published, CultureInfo.InvariantCulture, CompareOptions.IgnoreCase) && (!isDraft.HasValue || isDraft.Value))
-            {
-                draftContent = this.automationManagementClient.RunbookDraft.Content(automationAccountName, runbookName).Stream;
-            }
-            if (0 != String.Compare(runbook.Properties.State, RunbookState.New, CultureInfo.InvariantCulture, CompareOptions.IgnoreCase) && (!isDraft.HasValue || !isDraft.Value))
-            {
-                publishedContent = this.automationManagementClient.Runbooks.Content(automationAccountName, runbookName).Stream;
-            }
+                var draftContent = String.Empty;
+                var publishedContent = String.Empty;
 
-            // if no slot specified return both draft and publish content
-            if (false == isDraft.HasValue)
-            {
-                if (false == String.IsNullOrEmpty(draftContent)) ret.Add(new RunbookDefinition(automationAccountName, runbook, draftContent, Constants.Draft));
-                if (false == String.IsNullOrEmpty(publishedContent)) ret.Add(new RunbookDefinition(automationAccountName, runbook, publishedContent, Constants.Published));
-            }
-            else 
-            {
-                if (true == isDraft.Value)
+                if (0 !=
+                    String.Compare(runbook.Properties.State, RunbookState.Published, CultureInfo.InvariantCulture,
+                        CompareOptions.IgnoreCase) && (!isDraft.HasValue || isDraft.Value))
                 {
+                    draftContent =
+                        this.automationManagementClient.RunbookDraft.Content(automationAccountName, runbookName).Stream;
+                }
+                if (0 !=
+                    String.Compare(runbook.Properties.State, RunbookState.New, CultureInfo.InvariantCulture,
+                        CompareOptions.IgnoreCase) && (!isDraft.HasValue || !isDraft.Value))
+                {
+                    publishedContent =
+                        this.automationManagementClient.Runbooks.Content(automationAccountName, runbookName).Stream;
+                }
 
-                    if (String.IsNullOrEmpty(draftContent)) throw new ResourceCommonException(typeof(Runbook),
-                            string.Format(CultureInfo.CurrentCulture, Resources.RunbookHasNoDraftVersion, runbookName));
-                    if (false == String.IsNullOrEmpty(draftContent)) ret.Add(new RunbookDefinition(automationAccountName, runbook, draftContent, Constants.Draft));
+                // if no slot specified return both draft and publish content
+                if (false == isDraft.HasValue)
+                {
+                    if (false == String.IsNullOrEmpty(draftContent))
+                        ret.Add(new RunbookDefinition(automationAccountName, runbook, draftContent, Constants.Draft));
+                    if (false == String.IsNullOrEmpty(publishedContent))
+                        ret.Add(new RunbookDefinition(automationAccountName, runbook, publishedContent,
+                            Constants.Published));
                 }
                 else
                 {
-                    if (String.IsNullOrEmpty(publishedContent)) throw new ResourceCommonException(typeof(Runbook),
-                            string.Format(CultureInfo.CurrentCulture, Resources.RunbookHasNoPublishedVersion, runbookName));
+                    if (true == isDraft.Value)
+                    {
 
-                    if (false == String.IsNullOrEmpty(publishedContent)) ret.Add(new RunbookDefinition(automationAccountName, runbook, publishedContent, Constants.Published));
+                        if (String.IsNullOrEmpty(draftContent))
+                            throw new ResourceCommonException(typeof (Runbook),
+                                string.Format(CultureInfo.CurrentCulture, Resources.RunbookHasNoDraftVersion,
+                                    runbookName));
+                        if (false == String.IsNullOrEmpty(draftContent))
+                            ret.Add(new RunbookDefinition(automationAccountName, runbook, draftContent, Constants.Draft));
+                    }
+                    else
+                    {
+                        if (String.IsNullOrEmpty(publishedContent))
+                            throw new ResourceCommonException(typeof (Runbook),
+                                string.Format(CultureInfo.CurrentCulture, Resources.RunbookHasNoPublishedVersion,
+                                    runbookName));
+
+                        if (false == String.IsNullOrEmpty(publishedContent))
+                            ret.Add(new RunbookDefinition(automationAccountName, runbook, publishedContent,
+                                Constants.Published));
+                    }
                 }
-            }
 
-            return ret;
+                return ret;
+            }
         }
 
         public Runbook PublishRunbook(string automationAccountName, string runbookName)
         {
-            this.automationManagementClient.RunbookDraft.Publish(
+            using (var request = new RequestSettings(this.automationManagementClient))
+            {
+                this.automationManagementClient.RunbookDraft.Publish(
                 automationAccountName,
                 new RunbookDraftPublishParameters
                 {
                     Name = runbookName,
                     PublishedBy = Constants.ClientIdentity
                 });
 
-            return this.GetRunbook(automationAccountName, runbookName);
+                return this.GetRunbook(automationAccountName, runbookName);
+            }
+
         }
 
         public Job StartRunbook(string automationAccountName, string runbookName, IDictionary parameters)

src/ServiceManagement/Automation/Commands.Automation/Common/Constants.cs

@@ -53,5 +53,7 @@ public class AutomationAccountState
 
         public const int PsCommandValueDepth = 10;
 
+        public const string ClientRequestIdHeaderName = "x-ms-client-request-id";
+
     }
 }

src/ServiceManagement/Automation/Commands.Automation/RequestSettings.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Azure.Commands.Automation.Common;
+using Microsoft.WindowsAzure.Management.Automation;
+
+namespace Microsoft.Azure.Commands.Automation
+{
+    public class RequestSettings : IDisposable
+    {
+        private readonly AutomationManagementClient client;
+
+        public RequestSettings(IAutomationManagementClient automationClient)
+        {
+            client = ((AutomationManagementClient)automationClient);
+            client.HttpClient.DefaultRequestHeaders.Remove(Constants.ClientRequestIdHeaderName);
+            client.HttpClient.DefaultRequestHeaders.Add(Constants.ClientRequestIdHeaderName, Guid.NewGuid().ToString());
+        }
+        
+        public void Dispose()
+        {
+            client.HttpClient.DefaultRequestHeaders.Remove(Constants.ClientRequestIdHeaderName);
+        }
+    }
+}