ReFormatting RecoveryServices.SiteRecovery project

Author: avneeshraiusit

src/ResourceManager/RecoveryServices.SiteRecovery/Commands.RecoveryServices.SiteRecovery/Common/AsrCmdletBase.cs

@@ -1,5 +1,5 @@
 // ----------------------------------------------------------------------------------
-//
+// 
 // Copyright Microsoft Corporation
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,60 +13,63 @@
 // ----------------------------------------------------------------------------------
 
 using System;
+using System.Management.Automation;
 using System.Runtime.Serialization;
 using System.Text;
 using System.Threading;
 using System.Xml;
-using Microsoft.Azure.Commands.Common.Authentication;
+using Microsoft.Azure.Commands.RecoveryServices.SiteRecovery.Properties;
 using Microsoft.Azure.Commands.ResourceManager.Common;
-using Microsoft.Azure.Management.RecoveryServices.SiteRecovery.Models;
 using Microsoft.Rest.Azure;
+using Microsoft.Rest.Serialization;
 using Newtonsoft.Json;
+using Job = Microsoft.Azure.Management.RecoveryServices.SiteRecovery.Models.Job;
 
 namespace Microsoft.Azure.Commands.RecoveryServices.SiteRecovery
 {
     /// <summary>
-    /// The base class for all Windows Azure Recovery Services commands
+    ///     The base class for all Windows Azure Recovery Services commands
     /// </summary>
     public abstract class SiteRecoveryCmdletBase : AzureRMCmdlet
     {
         /// <summary>
-        /// Recovery Services client.
-        /// </summary>
-        private PSRecoveryServicesClient recoveryServicesClient;
-
-        /// <summary>
-        /// Gets or sets a value indicating whether stop processing has been triggered.
+        ///     Gets or sets a value indicating whether stop processing has been triggered.
         /// </summary>
         internal bool StopProcessingFlag { get; set; }
 
         /// <summary>
-        /// Gets Recovery Services client.
+        ///     Gets Recovery Services client.
         /// </summary>
         internal PSRecoveryServicesClient RecoveryServicesClient
         {
             get
             {
-                if (this.recoveryServicesClient == null)
+                if (recoveryServicesClient == null)
                 {
-                    this.recoveryServicesClient = new PSRecoveryServicesClient(DefaultProfile);
+                    recoveryServicesClient = new PSRecoveryServicesClient(DefaultProfile);
                 }
 
-                return this.recoveryServicesClient;
+                return recoveryServicesClient;
             }
         }
 
         /// <summary>
-        /// Virtual method to be implemented by Site Recovery cmdlets.
+        ///     Recovery Services client.
+        /// </summary>
+        private PSRecoveryServicesClient recoveryServicesClient;
+
+        /// <summary>
+        ///     Virtual method to be implemented by Site Recovery cmdlets.
         /// </summary>
         public virtual void ExecuteSiteRecoveryCmdlet()
         {
             SiteRecoveryAutoMapperProfile.Initialize();
+
             // Do Nothing
         }
 
         /// <summary>
-        /// Overriding base implementation go execute cmdlet.
+        ///     Overriding base implementation go execute cmdlet.
         /// </summary>
         public override void ExecuteCmdlet()
         {
@@ -77,47 +80,57 @@ public override void ExecuteCmdlet()
             }
             catch (Exception ex)
             {
-                this.HandleException(ex);
+                HandleException(ex);
             }
         }
 
         /// <summary>
-        /// Exception handler.
+        ///     Exception handler.
         /// </summary>
         /// <param name="ex">Exception to handle.</param>
         public void HandleException(Exception ex)
         {
-            string clientRequestIdMsg = string.Empty;
-            if (this.recoveryServicesClient != null)
+            var clientRequestIdMsg = string.Empty;
+            if (recoveryServicesClient != null)
             {
-                clientRequestIdMsg = "ClientRequestId: " + this.recoveryServicesClient.ClientRequestId + "\n";
+                clientRequestIdMsg = "ClientRequestId: " +
+                                     recoveryServicesClient.ClientRequestId +
+                                     "\n";
             }
 
-            CloudException cloudException = ex as CloudException;
-            if (cloudException != null && cloudException.Body != null && cloudException.Response != null)
-            {               
+            var cloudException = ex as CloudException;
+            if (cloudException != null &&
+                cloudException.Body != null &&
+                cloudException.Response != null)
+            {
                 try
                 {
                     if (cloudException.Message != null)
                     {
-                        ARMError error = Rest.Serialization.SafeJsonConvert.DeserializeObject<ARMError>(cloudException.Response.Content); ;
-                        StringBuilder exceptionMessage = new StringBuilder();
-                        exceptionMessage.Append(Properties.Resources.CloudExceptionDetails);
+                        var error =
+                            SafeJsonConvert.DeserializeObject<ARMError>(cloudException.Response
+                                .Content);
+                        ;
+                        var exceptionMessage = new StringBuilder();
+                        exceptionMessage.Append(Resources.CloudExceptionDetails);
 
                         if (error.Error.Details != null)
                         {
-                            foreach (ARMExceptionDetails detail in error.Error.Details)
+                            foreach (var detail in error.Error.Details)
                             {
                                 if (!string.IsNullOrEmpty(detail.ErrorCode))
                                     exceptionMessage.AppendLine("ErrorCode: " + detail.ErrorCode);
                                 if (!string.IsNullOrEmpty(detail.Message))
                                     exceptionMessage.AppendLine("Message: " + detail.Message);
                                 if (!string.IsNullOrEmpty(detail.PossibleCauses))
-                                    exceptionMessage.AppendLine("Possible Causes: " + detail.PossibleCauses);
+                                    exceptionMessage.AppendLine(
+                                        "Possible Causes: " + detail.PossibleCauses);
                                 if (!string.IsNullOrEmpty(detail.RecommendedAction))
-                                    exceptionMessage.AppendLine("Recommended Action: " + detail.RecommendedAction);
+                                    exceptionMessage.AppendLine(
+                                        "Recommended Action: " + detail.RecommendedAction);
                                 if (!string.IsNullOrEmpty(detail.ClientRequestId))
-                                    exceptionMessage.AppendLine("ClientRequestId: " + detail.ClientRequestId);
+                                    exceptionMessage.AppendLine(
+                                        "ClientRequestId: " + detail.ClientRequestId);
                                 if (!string.IsNullOrEmpty(detail.ActivityId))
                                     exceptionMessage.AppendLine("ActivityId: " + detail.ActivityId);
 
@@ -134,52 +147,44 @@ public void HandleException(Exception ex)
 
                         throw new InvalidOperationException(exceptionMessage.ToString());
                     }
-                    else
-                    {
-                        throw new Exception(
-                            string.Format(
-                            Properties.Resources.InvalidCloudExceptionErrorMessage,
+
+                    throw new Exception(string.Format(Resources.InvalidCloudExceptionErrorMessage,
                             clientRequestIdMsg + ex.Message),
-                            ex);
-                    }
+                        ex);
                 }
                 catch (XmlException)
                 {
                     throw new XmlException(
-                        string.Format(
-                        Properties.Resources.InvalidCloudExceptionErrorMessage,
-                        cloudException.Message),
+                        string.Format(Resources.InvalidCloudExceptionErrorMessage,
+                            cloudException.Message),
                         cloudException);
                 }
                 catch (SerializationException)
                 {
-                    throw new SerializationException(
-                        string.Format(
-                        Properties.Resources.InvalidCloudExceptionErrorMessage,
-                        clientRequestIdMsg + cloudException.Message),
+                    throw new SerializationException(string.Format(
+                            Resources.InvalidCloudExceptionErrorMessage,
+                            clientRequestIdMsg + cloudException.Message),
                         cloudException);
                 }
                 catch (JsonReaderException)
                 {
                     throw new JsonReaderException(
-                        string.Format(
-                        Properties.Resources.InvalidCloudExceptionErrorMessage,
-                        clientRequestIdMsg + cloudException.Message),
+                        string.Format(Resources.InvalidCloudExceptionErrorMessage,
+                            clientRequestIdMsg + cloudException.Message),
                         cloudException);
                 }
             }
-            else if (ex.Message != null)
+
+            if (ex.Message != null)
             {
-                throw new Exception(
-                    string.Format(
-                    Properties.Resources.InvalidCloudExceptionErrorMessage,
-                    clientRequestIdMsg + ex.Message),
+                throw new Exception(string.Format(Resources.InvalidCloudExceptionErrorMessage,
+                        clientRequestIdMsg + ex.Message),
                     ex);
             }
         }
 
         /// <summary>
-        /// Waits for the job to complete.
+        ///     Waits for the job to complete.
         /// </summary>
         /// <param name="jobId">Id of the job to wait for.</param>
         /// <returns>Final job response</returns>
@@ -189,53 +194,47 @@ public Job WaitForJobCompletion(string jobId)
             do
             {
                 Thread.Sleep(PSRecoveryServicesClient.TimeToSleepBeforeFetchingJobDetailsAgain);
-                job = this.RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(jobId);
-                this.WriteProgress(
-                    new System.Management.Automation.ProgressRecord(
-                        0,
-                        Properties.Resources.WaitingForCompletion,
-                        job.Properties.State));
-            }
-            while (!(job.Properties.State == JobStatus.Cancelled ||
-                            job.Properties.State == JobStatus.Failed ||
-                            job.Properties.State == JobStatus.Suspended ||
-                            job.Properties.State == JobStatus.Succeeded ||
-                        this.StopProcessingFlag));
+                job = RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(jobId);
+                WriteProgress(new ProgressRecord(0,
+                    Resources.WaitingForCompletion,
+                    job.Properties.State));
+            } while (!(job.Properties.State == TaskStatus.Cancelled ||
+                       job.Properties.State == TaskStatus.Failed ||
+                       job.Properties.State == TaskStatus.Suspended ||
+                       job.Properties.State == TaskStatus.Succeeded ||
+                       StopProcessingFlag));
+
             return job;
         }
 
-
         /// <summary>
-        /// Handles interrupts.
+        ///     Handles interrupts.
         /// </summary>
         protected override void StopProcessing()
         {
             // Ctrl + C and etc
             base.StopProcessing();
-            this.StopProcessingFlag = true;
+            StopProcessingFlag = true;
         }
 
         /// <summary>
-        /// Validates if the usage by ID is allowed or not.
+        ///     Validates if the usage by ID is allowed or not.
         /// </summary>
         /// <param name="replicationProvider">Replication provider.</param>
         /// <param name="paramName">Parameter name.</param>
-        protected void ValidateUsageById(string replicationProvider, string paramName)
+        protected void ValidateUsageById(string replicationProvider,
+            string paramName)
         {
             if (replicationProvider != Constants.HyperVReplica2012)
             {
-                throw new Exception(
-                    string.Format(
+                throw new Exception(string.Format(
                     "Call using ID based parameter {0} is not supported for this provider. Please use its corresponding full object parameter instead",
                     paramName));
             }
-            else
-            {
-                this.WriteWarningWithTimestamp(
-                    string.Format(
-                    Properties.Resources.IDBasedParamUsageNotSupportedFromNextRelease,
+
+            WriteWarningWithTimestamp(
+                string.Format(Resources.IDBasedParamUsageNotSupportedFromNextRelease,
                     paramName));
-            }
         }
     }
-}
+}