Esempio n. 1
0
        private UpgradeDeploymentInput CreateUpgradeInput()
        {
            string deploymentName = this.DeploymentName.Get(this.ActivityContext);

            if (string.IsNullOrEmpty(deploymentName))
            {
                deploymentName = Guid.NewGuid().ToString();
            }

            string package = this.PackageUrl.Get(this.ActivityContext);
            Uri    packageUrl;

            if (package.StartsWith(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) ||
                package.StartsWith(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
            {
                packageUrl = new Uri(package);
            }
            else
            {
                throw new InvalidOperationException("You must upload the blob to Azure before creating a new deployment.");
            }

            return(new UpgradeDeploymentInput
            {
                PackageUrl = packageUrl,
                Configuration = Utility.GetConfiguration(this.ConfigurationFilePath.Get(this.ActivityContext)),
                Label = ServiceManagementHelper.EncodeToBase64String(this.DeploymentLabel.Get(this.ActivityContext)),
                RoleToUpgrade = this.RoleName.Get(this.ActivityContext),
                Mode = "Auto",
                TreatWarningsAsError = this.TreatWarningsAsErrors.Get(this.ActivityContext)
            });
        }
        protected override void PerformOperation(IServiceManagement channel)
        {
            CreateDeploymentInput input = new CreateDeploymentInput
            {
                Name          = DeploymentName,
                Configuration = Utility.GetSettings(ConfigFileLocation),
            };

            if (!string.IsNullOrEmpty(PackageLocation))
            {
                input.PackageUrl = new Uri(PackageLocation);
            }

            if (!string.IsNullOrEmpty(Label))
            {
                input.Label = ServiceManagementHelper.EncodeToBase64String(Label);
            }

            if (TreatWarningsAsError)
            {
                input.TreatWarningsAsError = TreatWarningsAsError;
            }

            Console.WriteLine("Creating Deployment... Name: {0}, Label: {1}", DeploymentName, Label);
            channel.CreateOrUpdateDeployment(SubscriptionId, HostedServiceName, DeploymentSlot, input);
        }
        protected override void PerformOperation(IServiceManagement channel)
        {
            UpgradeDeploymentInput input = new UpgradeDeploymentInput
            {
                Configuration = Utility.GetSettings(ConfigFileLocation),
                Mode          = Mode,
                RoleToUpgrade = RoleToUpgrade,
            };

            if (!string.IsNullOrEmpty(PackageLocation))
            {
                input.PackageUrl = new Uri(PackageLocation);
            }

            if (!string.IsNullOrEmpty(Label))
            {
                input.Label = ServiceManagementHelper.EncodeToBase64String(Label);
            }

            if (TreatWarningsAsError)
            {
                input.TreatWarningsAsError = TreatWarningsAsError;
            }

            Console.WriteLine("Upgrading Deployment");
            if (!string.IsNullOrEmpty(DeploymentName))
            {
                channel.UpgradeDeployment(SubscriptionId, HostedServiceName, DeploymentName, input);
            }
            else if (!string.IsNullOrEmpty(DeploymentSlot))
            {
                channel.UpgradeDeploymentBySlot(SubscriptionId, HostedServiceName, DeploymentSlot, input);
            }
        }
        /// <summary>
        /// Create a hosted Azure service.
        /// </summary>
        private void CreateHostedService()
        {
            Debug.Assert(
                !string.IsNullOrEmpty(_hostedServiceName),
                "_hostedServiceName cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.Label),
                "Label cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.ServiceSettings.Location),
                "Location cannot be null or empty.");

            SafeWriteObjectWithTimestamp(Resources.PublishCreatingServiceMessage);

            CreateHostedServiceInput hostedServiceInput = new CreateHostedServiceInput
            {
                ServiceName = _hostedServiceName,
                Label       = ServiceManagementHelper.EncodeToBase64String(_deploymentSettings.Label),
                Location    = _deploymentSettings.ServiceSettings.Location
            };

            InvokeInOperationContext(() =>
            {
                RetryCall(subscription =>
                          Channel.CreateHostedService(subscription, hostedServiceInput));
                SafeWriteObjectWithTimestamp(String.Format(Resources.PublishCreatedServiceMessage,
                                                           hostedServiceInput.ServiceName));
            });
        }
 public void NewAffinityGroupProcess()
 {
     using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
     {
         try
         {
             CreateAffinityGroupInput createAffinityGroupInput = new CreateAffinityGroupInput();
             createAffinityGroupInput.Description = this.Description;
             createAffinityGroupInput.Label       = ServiceManagementHelper.EncodeToBase64String(this.Label);
             createAffinityGroupInput.Location    = this.Location;
             createAffinityGroupInput.Name        = this.Name;
             CmdletExtensions.WriteVerboseOutputForObject(this, createAffinityGroupInput);
             base.RetryCall((string s) => base.Channel.CreateAffinityGroup(s, createAffinityGroupInput));
             Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
             ManagementOperationContext managementOperationContext = new ManagementOperationContext();
             managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
             managementOperationContext.set_OperationId(operation.OperationTrackingId);
             managementOperationContext.set_OperationStatus(operation.Status);
             ManagementOperationContext managementOperationContext1 = managementOperationContext;
             base.WriteObject(managementOperationContext1, true);
         }
         catch (CommunicationException communicationException1)
         {
             CommunicationException communicationException = communicationException1;
             this.WriteErrorDetails(communicationException);
         }
     }
 }
        /// <summary>
        /// Create an Azure storage account that we can use to upload our
        /// package when creating and deploying a service.
        /// </summary>
        private void CreateStorageAccount()
        {
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.ServiceSettings.StorageAccountName),
                "StorageAccountName cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.Label),
                "Label cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.ServiceSettings.Location),
                "Location cannot be null or empty.");

            CreateStorageServiceInput storageServiceInput = new CreateStorageServiceInput
            {
                ServiceName = _deploymentSettings.ServiceSettings.StorageAccountName,
                Label       = ServiceManagementHelper.EncodeToBase64String(_deploymentSettings.Label),
                Location    = _deploymentSettings.ServiceSettings.Location
            };

            InvokeInOperationContext(() =>
            {
                RetryCall(subscription =>
                          Channel.CreateStorageAccount(subscription, storageServiceInput));

                StorageService storageService = null;
                do
                {
                    storageService = RetryCall(subscription =>
                                               Channel.GetStorageService(subscription, storageServiceInput.ServiceName));
                }while (storageService.StorageServiceProperties.Status != StorageAccountStatus.Created);
            });
        }
        /// <summary>
        /// Create a new deployment for the service.
        /// </summary>
        private void CreateNewDeployment()
        {
            Debug.Assert(
                !string.IsNullOrEmpty(_hostedServiceName),
                "_hostedServiceName cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.ServiceSettings.Slot),
                "Slot cannot be null or empty.");

            CreateDeploymentInput deploymentInput = new CreateDeploymentInput
            {
                PackageUrl      = UploadPackage(),
                Configuration   = GetConfiguration(),
                Label           = ServiceManagementHelper.EncodeToBase64String(_deploymentSettings.Label),
                Name            = _deploymentSettings.DeploymentName,
                StartDeployment = true,
            };

            InvokeInOperationContext(() =>
            {
                RetryCall(subscription =>
                          Channel.CreateOrUpdateDeployment(
                              subscription,
                              _hostedServiceName,
                              _deploymentSettings.ServiceSettings.Slot,
                              deploymentInput));
                WaitForDeploymentToStart();
            });
        }
        /// <summary>
        /// Upgrade the deployment for the service.
        /// </summary>
        private void UpgradeDeployment()
        {
            Debug.Assert(
                !string.IsNullOrEmpty(_hostedServiceName),
                "_hostedServiceName cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.Label),
                "Label cannot be null or empty.");
            Debug.Assert(
                !string.IsNullOrEmpty(_deploymentSettings.DeploymentName),
                "DeploymentName cannot be null or empty.");

            UpgradeDeploymentInput deploymentInput = new UpgradeDeploymentInput
            {
                PackageUrl    = UploadPackage(),
                Configuration = GetConfiguration(),
                Label         = ServiceManagementHelper.EncodeToBase64String(_deploymentSettings.Label),
                Mode          = UpgradeType.Auto
            };

            InvokeInOperationContext(() =>
            {
                SafeWriteObjectWithTimestamp(Resources.PublishUpgradingMessage);
                RetryCall(subscription =>
                          Channel.UpgradeDeployment(
                              subscription,
                              _hostedServiceName,
                              _deploymentSettings.DeploymentName,
                              deploymentInput));
                WaitForDeploymentToStart();
            });
        }
 public void SetAffinityGroupProcess()
 {
     this.ValidateParameters();
     using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
     {
         try
         {
             UpdateAffinityGroupInput updateAffinityGroupInput = new UpdateAffinityGroupInput();
             updateAffinityGroupInput.Label = ServiceManagementHelper.EncodeToBase64String(this.Label);
             UpdateAffinityGroupInput description = updateAffinityGroupInput;
             if (this.Description != null)
             {
                 description.Description = this.Description;
             }
             CmdletExtensions.WriteVerboseOutputForObject(this, description);
             base.RetryCall((string s) => base.Channel.UpdateAffinityGroup(s, this.Name, description));
             Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
             ManagementOperationContext managementOperationContext = new ManagementOperationContext();
             managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
             managementOperationContext.set_OperationId(operation.OperationTrackingId);
             managementOperationContext.set_OperationStatus(operation.Status);
             ManagementOperationContext managementOperationContext1 = managementOperationContext;
             base.WriteObject(managementOperationContext1, true);
         }
         catch (CommunicationException communicationException1)
         {
             CommunicationException communicationException = communicationException1;
             this.WriteErrorDetails(communicationException);
         }
     }
 }
        protected override void ProcessRecord()
        {
            Uri    uri;
            string diskLabel;

            try
            {
                base.ProcessRecord();
                this.ValidateParameters();
                if (string.IsNullOrEmpty(this.Label))
                {
                    this.Label = this.Name;
                }
                this.Label = ServiceManagementHelper.EncodeToBase64String(this.Label);
                PersistentVM persistentVM = new PersistentVM();
                persistentVM.AvailabilitySetName  = this.AvailabilitySetName;
                persistentVM.ConfigurationSets    = new Collection <ConfigurationSet>();
                persistentVM.DataVirtualHardDisks = new Collection <DataVirtualHardDisk>();
                persistentVM.RoleName             = this.Name;
                persistentVM.RoleSize             = this.InstanceSize;
                persistentVM.RoleType             = "PersistentVMRole";
                persistentVM.Label = this.Label;
                PersistentVM      persistentVM1     = persistentVM;
                PersistentVM      persistentVM2     = persistentVM1;
                OSVirtualHardDisk oSVirtualHardDisk = new OSVirtualHardDisk();
                oSVirtualHardDisk.DiskName        = this.DiskName;
                oSVirtualHardDisk.SourceImageName = this.ImageName;
                OSVirtualHardDisk oSVirtualHardDisk1 = oSVirtualHardDisk;
                if (string.IsNullOrEmpty(this.MediaLocation))
                {
                    uri = null;
                }
                else
                {
                    uri = new Uri(this.MediaLocation);
                }
                oSVirtualHardDisk1.MediaLink  = uri;
                oSVirtualHardDisk.HostCaching = this.HostCaching;
                OSVirtualHardDisk oSVirtualHardDisk2 = oSVirtualHardDisk;
                if (string.IsNullOrEmpty(this.DiskLabel))
                {
                    diskLabel = null;
                }
                else
                {
                    diskLabel = this.DiskLabel;
                }
                oSVirtualHardDisk2.DiskLabel    = diskLabel;
                persistentVM2.OSVirtualHardDisk = oSVirtualHardDisk;
                CmdletExtensions.WriteVerboseOutputForObject(this, persistentVM1);
                base.WriteObject(persistentVM1, true);
            }
            catch (Exception exception1)
            {
                Exception exception = exception1;
                base.WriteError(new ErrorRecord(exception, string.Empty, ErrorCategory.CloseError, null));
            }
        }
Esempio n. 11
0
        public void SetRoleInstanceCountProcess()
        {
            Func <XElement, bool> func = null;

            this.GetCurrentDeployment();
            if (this.currentDeployment != null)
            {
                using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
                {
                    try
                    {
                        XNamespace             xNamespace = "http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceConfiguration";
                        XDocument              xDocument  = XDocument.Parse(ServiceManagementHelper.DecodeFromBase64String(this.currentDeployment.Configuration));
                        IEnumerable <XElement> xElements  = xDocument.Root.Elements(xNamespace + "Role");
                        if (func == null)
                        {
                            func = (XElement p) => string.Compare(p.Attribute("name").Value, this.RoleName, true) == 0;
                        }
                        XElement xElement = xElements.Where <XElement>(func).SingleOrDefault <XElement>();
                        if (xElement != null)
                        {
                            xElement.Element(xNamespace + "Instances").SetAttributeValue("count", this.Count);
                        }
                        using (OperationContextScope operationContextScope1 = new OperationContextScope((IContextChannel)base.Channel))
                        {
                            ChangeConfigurationInput changeConfigurationInput = new ChangeConfigurationInput();
                            changeConfigurationInput.Configuration = ServiceManagementHelper.EncodeToBase64String(xDocument.ToString());
                            ChangeConfigurationInput changeConfigurationInput1 = changeConfigurationInput;
                            CmdletExtensions.WriteVerboseOutputForObject(this, xDocument);
                            base.RetryCall((string s) => base.Channel.ChangeConfigurationBySlot(s, this.ServiceName, this.Slot, changeConfigurationInput1));
                            Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
                            ManagementOperationContext managementOperationContext = new ManagementOperationContext();
                            managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
                            managementOperationContext.set_OperationId(operation.OperationTrackingId);
                            managementOperationContext.set_OperationStatus(operation.Status);
                            ManagementOperationContext managementOperationContext1 = managementOperationContext;
                            base.WriteObject(managementOperationContext1, true);
                        }
                    }
                    catch (EndpointNotFoundException endpointNotFoundException1)
                    {
                        EndpointNotFoundException endpointNotFoundException = endpointNotFoundException1;
                        this.WriteErrorDetails(endpointNotFoundException);
                    }
                    catch (CommunicationException communicationException1)
                    {
                        CommunicationException communicationException = communicationException1;
                        this.WriteErrorDetails(communicationException);
                    }
                }
                return;
            }
            else
            {
                return;
            }
        }
Esempio n. 12
0
 internal static string GetSettings(string settingsFile)
 {
     string settings = null;
     try
     {
         settings = String.Join("", File.ReadAllLines(Path.GetFullPath(settingsFile)));
     }
     catch (Exception)
     {
         Console.WriteLine("Error reading settings from file: " + settingsFile);
         throw;
     }
     return ServiceManagementHelper.EncodeToBase64String(settings);
 }
Esempio n. 13
0
        public void NewHostedServiceProcess()
        {
            string                   serviceName;
            Action <string>          action = null;
            CreateHostedServiceInput createHostedServiceInput = new CreateHostedServiceInput();

            createHostedServiceInput.ServiceName = this.ServiceName;
            if (string.IsNullOrEmpty(this.Label))
            {
                serviceName = this.ServiceName;
            }
            else
            {
                serviceName = this.Label;
            }
            string str = serviceName;

            createHostedServiceInput.Label         = ServiceManagementHelper.EncodeToBase64String(str);
            createHostedServiceInput.Description   = this.Description;
            createHostedServiceInput.AffinityGroup = this.AffinityGroup;
            createHostedServiceInput.Location      = this.Location;
            using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
            {
                try
                {
                    CmdletExtensions.WriteVerboseOutputForObject(this, createHostedServiceInput);
                    NewAzureServiceCommand newAzureServiceCommand = this;
                    if (action == null)
                    {
                        action = (string s) => base.Channel.CreateHostedService(s, createHostedServiceInput);
                    }
                    ((CmdletBase <IServiceManagement>)newAzureServiceCommand).RetryCall(action);
                    Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
                    ManagementOperationContext managementOperationContext = new ManagementOperationContext();
                    managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
                    managementOperationContext.set_OperationId(operation.OperationTrackingId);
                    managementOperationContext.set_OperationStatus(operation.Status);
                    ManagementOperationContext managementOperationContext1 = managementOperationContext;
                    base.WriteObject(managementOperationContext1, true);
                }
                catch (CommunicationException communicationException1)
                {
                    CommunicationException communicationException = communicationException1;
                    this.WriteErrorDetails(communicationException);
                }
            }
        }
Esempio n. 14
0
        protected override void PerformOperation(IServiceManagement channel)
        {
            if (!String.IsNullOrEmpty(Label))
            {
                Label = ServiceManagementHelper.EncodeToBase64String(Label);
            }

            UpdateHostedServiceInput input = new UpdateHostedServiceInput()
            {
                Label       = CSManageCommand.Label,
                Description = CSManageCommand.Description
            };


            Console.WriteLine("Updating hosted service {0}", HostedServiceName);
            channel.UpdateHostedService(SubscriptionId, HostedServiceName, input);
        }
 public void SetStorageAccountProcess()
 {
     if (this.Label == null && this.Description == null)
     {
         base.ThrowTerminatingError(new ErrorRecord(new Exception("You must specify a value for either Label or Description."), string.Empty, ErrorCategory.InvalidData, null));
     }
     using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
     {
         try
         {
             UpdateStorageServiceInput updateStorageServiceInput = new UpdateStorageServiceInput();
             bool?geoReplicationEnabled = this.GeoReplicationEnabled;
             if (geoReplicationEnabled.HasValue)
             {
                 bool?nullable = this.GeoReplicationEnabled;
                 updateStorageServiceInput.GeoReplicationEnabled = new bool?(nullable.Value);
             }
             if (this.Description != null)
             {
                 updateStorageServiceInput.Description = this.Description;
             }
             if (this.Label != null)
             {
                 updateStorageServiceInput.Label = ServiceManagementHelper.EncodeToBase64String(this.Label);
             }
             CmdletExtensions.WriteVerboseOutputForObject(this, updateStorageServiceInput);
             base.RetryCall((string s) => base.Channel.UpdateStorageService(s, this.StorageAccountName, updateStorageServiceInput));
             Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
             ManagementOperationContext managementOperationContext = new ManagementOperationContext();
             managementOperationContext.OperationDescription = base.CommandRuntime.ToString();
             managementOperationContext.OperationId          = operation.OperationTrackingId;
             managementOperationContext.OperationStatus      = operation.Status;
             ManagementOperationContext managementOperationContext1 = managementOperationContext;
             base.WriteObject(managementOperationContext1, true);
         }
         catch (CommunicationException communicationException1)
         {
             CommunicationException communicationException = communicationException1;
             this.WriteErrorDetails(communicationException);
         }
     }
 }
Esempio n. 16
0
        protected override void PerformOperation(IServiceManagement channel)
        {
            CreateHostedServiceInput input = new CreateHostedServiceInput()
            {
                ServiceName = HostedServiceName,
                Label       = ServiceManagementHelper.EncodeToBase64String(CSManageCommand.Label),
                Description = CSManageCommand.Description
            };

            if (AffinityGroupName != null)
            {
                input.AffinityGroup = AffinityGroupName;
            }
            else if (LocationConstraintName != null)
            {
                input.Location = LocationConstraintName;
            }

            Console.WriteLine("Creating hosted service {0}", HostedServiceName);
            channel.CreateHostedService(SubscriptionId, input);
        }
Esempio n. 17
0
        public void NewAzureVMProcess()
        {
            NewQuickVM.NewQuickVM variable = null;
            string              serviceName;
            string              instanceSize;
            Uri                 uri;
            string              name;
            string              str;
            Action <string>     action = null;
            SubscriptionData    currentSubscription   = CmdletSubscriptionExtensions.GetCurrentSubscription(this);
            CloudStorageAccount currentStorageAccount = null;

            try
            {
                currentStorageAccount = currentSubscription.GetCurrentStorageAccount(base.Channel);
            }
            catch (EndpointNotFoundException endpointNotFoundException)
            {
                throw new ArgumentException("CurrentStorageAccount is not accessible. Ensure the current storage account is accessible and in the same location or affinity group as your cloud service.");
            }
            if (currentStorageAccount != null)
            {
                NewQuickVM.NewQuickVM variable1        = variable;
                PersistentVMRole      persistentVMRole = new PersistentVMRole();
                persistentVMRole.AvailabilitySetName  = this.AvailabilitySetName;
                persistentVMRole.ConfigurationSets    = new Collection <ConfigurationSet>();
                persistentVMRole.DataVirtualHardDisks = new Collection <DataVirtualHardDisk>();
                PersistentVMRole persistentVMRole1 = persistentVMRole;
                if (string.IsNullOrEmpty(this.Name))
                {
                    serviceName = this.ServiceName;
                }
                else
                {
                    serviceName = this.Name;
                }
                persistentVMRole1.RoleName = serviceName;
                PersistentVMRole persistentVMRole2 = persistentVMRole;
                if (string.IsNullOrEmpty(this.InstanceSize))
                {
                    instanceSize = null;
                }
                else
                {
                    instanceSize = this.InstanceSize;
                }
                persistentVMRole2.RoleSize = instanceSize;
                persistentVMRole.RoleType  = "PersistentVMRole";
                persistentVMRole.Label     = ServiceManagementHelper.EncodeToBase64String(this.ServiceName);
                variable1.vm = persistentVMRole;
                PersistentVMRole  persistentVMRole3 = uri1;
                OSVirtualHardDisk oSVirtualHardDisk = new OSVirtualHardDisk();
                oSVirtualHardDisk.DiskName        = null;
                oSVirtualHardDisk.SourceImageName = this.ImageName;
                OSVirtualHardDisk oSVirtualHardDisk1 = oSVirtualHardDisk;
                if (string.IsNullOrEmpty(this.MediaLocation))
                {
                    uri = null;
                }
                else
                {
                    uri = new Uri(this.MediaLocation);
                }
                oSVirtualHardDisk1.MediaLink        = uri;
                oSVirtualHardDisk.HostCaching       = this.HostCaching;
                persistentVMRole3.OSVirtualHardDisk = oSVirtualHardDisk;
                if (oSVirtualHardDisk1.MediaLink == null && string.IsNullOrEmpty(oSVirtualHardDisk1.DiskName))
                {
                    DateTime now      = DateTime.Now;
                    object[] roleName = new object[6];
                    roleName[0] = this.ServiceName;
                    roleName[1] = uri1.RoleName;
                    roleName[2] = now.Year;
                    roleName[3] = now.Month;
                    roleName[4] = now.Day;
                    roleName[5] = now.Millisecond;
                    string str1        = string.Format("{0}-{1}-{2}-{3}-{4}-{5}.vhd", roleName);
                    string absoluteUri = currentStorageAccount.BlobEndpoint.AbsoluteUri;
                    if (!absoluteUri.EndsWith("/"))
                    {
                        absoluteUri = string.Concat(absoluteUri, "/");
                    }
                    oSVirtualHardDisk1.MediaLink = new Uri(string.Concat(absoluteUri, "vhds/", str1));
                }
                NetworkConfigurationSet networkConfigurationSet = new NetworkConfigurationSet();
                networkConfigurationSet.InputEndpoints = new Collection <InputEndpoint>();
                if (this.SubnetNames != null)
                {
                    networkConfigurationSet.SubnetNames = new SubnetNamesCollection();
                    string[] subnetNames = this.SubnetNames;
                    for (int i = 0; i < (int)subnetNames.Length; i++)
                    {
                        string str2 = subnetNames[i];
                        networkConfigurationSet.SubnetNames.Add(str2);
                    }
                }
                if (!base.ParameterSetName.Equals("Windows", StringComparison.OrdinalIgnoreCase))
                {
                    LinuxProvisioningConfigurationSet linuxProvisioningConfigurationSet  = new LinuxProvisioningConfigurationSet();
                    LinuxProvisioningConfigurationSet linuxProvisioningConfigurationSet1 = linuxProvisioningConfigurationSet;
                    if (string.IsNullOrEmpty(this.Name))
                    {
                        name = this.ServiceName;
                    }
                    else
                    {
                        name = this.Name;
                    }
                    linuxProvisioningConfigurationSet1.HostName    = name;
                    linuxProvisioningConfigurationSet.UserName     = this.LinuxUser;
                    linuxProvisioningConfigurationSet.UserPassword = this.Password;
                    linuxProvisioningConfigurationSet.DisableSshPasswordAuthentication = new bool?(false);
                    if (this.SSHKeyPairs != null && this.SSHKeyPairs.Count > 0 || this.SSHPublicKeys != null && this.SSHPublicKeys.Count > 0)
                    {
                        linuxProvisioningConfigurationSet.SSH            = new LinuxProvisioningConfigurationSet.SSHSettings();
                        linuxProvisioningConfigurationSet.SSH.PublicKeys = this.SSHPublicKeys;
                        linuxProvisioningConfigurationSet.SSH.KeyPairs   = this.SSHKeyPairs;
                    }
                    InputEndpoint inputEndpoint = new InputEndpoint();
                    inputEndpoint.LocalPort = 22;
                    inputEndpoint.Protocol  = "tcp";
                    inputEndpoint.Name      = "SSH";
                    networkConfigurationSet.InputEndpoints.Add(inputEndpoint);
                    uri1.ConfigurationSets.Add(linuxProvisioningConfigurationSet);
                    uri1.ConfigurationSets.Add(networkConfigurationSet);
                }
                else
                {
                    WindowsProvisioningConfigurationSet windowsProvisioningConfigurationSet = new WindowsProvisioningConfigurationSet();
                    windowsProvisioningConfigurationSet.AdminPassword = this.Password;
                    WindowsProvisioningConfigurationSet windowsProvisioningConfigurationSet1 = windowsProvisioningConfigurationSet;
                    if (string.IsNullOrEmpty(this.Name))
                    {
                        str = this.ServiceName;
                    }
                    else
                    {
                        str = this.Name;
                    }
                    windowsProvisioningConfigurationSet1.ComputerName             = str;
                    windowsProvisioningConfigurationSet.EnableAutomaticUpdates    = new bool?(true);
                    windowsProvisioningConfigurationSet.ResetPasswordOnFirstLogon = false;
                    windowsProvisioningConfigurationSet.StoredCertificateSettings = this.Certificates;
                    InputEndpoint inputEndpoint1 = new InputEndpoint();
                    inputEndpoint1.LocalPort = 0xd3d;
                    inputEndpoint1.Protocol  = "tcp";
                    inputEndpoint1.Name      = "RemoteDesktop";
                    networkConfigurationSet.InputEndpoints.Add(inputEndpoint1);
                    uri1.ConfigurationSets.Add(windowsProvisioningConfigurationSet);
                    uri1.ConfigurationSets.Add(networkConfigurationSet);
                }
                new List <string>();
                Operation operation = null;
                bool      flag      = this.DoesCloudServiceExist(this.ServiceName);
                using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
                {
                    try
                    {
                        DateTime dateTime      = DateTime.Now;
                        DateTime universalTime = dateTime.ToUniversalTime();
                        string   str3          = string.Format("Implicitly created hosted service{0}", universalTime.ToString("yyyy-MM-dd HH:mm"));
                        if (!string.IsNullOrEmpty(this.Location) || !string.IsNullOrEmpty(this.AffinityGroup) || !string.IsNullOrEmpty(this.VNetName) && !flag)
                        {
                            CreateHostedServiceInput createHostedServiceInput = new CreateHostedServiceInput();
                            createHostedServiceInput.AffinityGroup = this.AffinityGroup;
                            createHostedServiceInput.Location      = this.Location;
                            createHostedServiceInput.ServiceName   = this.ServiceName;
                            createHostedServiceInput.Description   = str3;
                            createHostedServiceInput.Label         = ServiceManagementHelper.EncodeToBase64String(this.ServiceName);
                            CmdletExtensions.WriteVerboseOutputForObject(this, createHostedServiceInput);
                            base.RetryCall((string s) => base.Channel.CreateHostedService(s, createHostedServiceInput));
                            Operation operation1 = base.WaitForOperation(string.Concat(base.CommandRuntime.ToString(), " - Create Cloud Service"));
                            ManagementOperationContext managementOperationContext = new ManagementOperationContext();
                            managementOperationContext.set_OperationDescription(string.Concat(base.CommandRuntime.ToString(), " - Create Cloud Service"));
                            managementOperationContext.set_OperationId(operation1.OperationTrackingId);
                            managementOperationContext.set_OperationStatus(operation1.Status);
                            ManagementOperationContext managementOperationContext1 = managementOperationContext;
                            base.WriteObject(managementOperationContext1, true);
                        }
                    }
                    catch (CommunicationException communicationException1)
                    {
                        CommunicationException communicationException = communicationException1;
                        this.WriteErrorDetails(communicationException);
                        return;
                    }
                }
                if (operation == null || string.Compare(operation.Status, "Failed", StringComparison.OrdinalIgnoreCase) != 0)
                {
                    if (base.CurrentDeployment != null)
                    {
                        if (this.VNetName != null || this.DnsSettings != null)
                        {
                            base.WriteWarning("VNetName or DnsSettings can only be specified on new deployments.");
                        }
                    }
                    else
                    {
                        using (OperationContextScope operationContextScope1 = new OperationContextScope((IContextChannel)base.Channel))
                        {
                            try
                            {
                                Deployment deployment = new Deployment();
                                deployment.DeploymentSlot = "Production";
                                deployment.Name           = this.ServiceName;
                                deployment.Label          = this.ServiceName;
                                List <Role> roles = new List <Role>();
                                roles.Add(uri1);
                                deployment.RoleList           = new RoleList(roles);
                                deployment.VirtualNetworkName = this.VNetName;
                                Deployment dnsSetting = deployment;
                                if (this.DnsSettings != null)
                                {
                                    dnsSetting.Dns            = new DnsSettings();
                                    dnsSetting.Dns.DnsServers = new DnsServerList();
                                    DnsServer[] dnsSettings = this.DnsSettings;
                                    for (int j = 0; j < (int)dnsSettings.Length; j++)
                                    {
                                        DnsServer dnsServer = dnsSettings[j];
                                        dnsSetting.Dns.DnsServers.Add(dnsServer);
                                    }
                                }
                                CmdletExtensions.WriteVerboseOutputForObject(this, dnsSetting);
                                base.RetryCall((string s) => base.Channel.CreateDeployment(s, this.ServiceName, dnsSetting));
                                Operation operation2 = base.WaitForOperation(string.Concat(base.CommandRuntime.ToString(), " - Create Deployment with VM ", uri1.RoleName));
                                ManagementOperationContext managementOperationContext2 = new ManagementOperationContext();
                                managementOperationContext2.set_OperationDescription(string.Concat(base.CommandRuntime.ToString(), " - Create Deployment with VM ", uri1.RoleName));
                                managementOperationContext2.set_OperationId(operation2.OperationTrackingId);
                                managementOperationContext2.set_OperationStatus(operation2.Status);
                                ManagementOperationContext managementOperationContext3 = managementOperationContext2;
                                base.WriteObject(managementOperationContext3, true);
                            }
                            catch (CommunicationException communicationException3)
                            {
                                CommunicationException communicationException2 = communicationException3;
                                if (communicationException2 as EndpointNotFoundException == null)
                                {
                                    this.WriteErrorDetails(communicationException2);
                                    return;
                                }
                                else
                                {
                                    throw new Exception("Cloud Service does not exist. Specify -Location or -Affinity group to create one.");
                                }
                            }
                            this.CreatedDeployment = true;
                        }
                    }
                    if (operation == null || string.Compare(operation.Status, "Failed", StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        if (!this.CreatedDeployment)
                        {
                            using (OperationContextScope operationContextScope2 = new OperationContextScope((IContextChannel)base.Channel))
                            {
                                try
                                {
                                    CmdletExtensions.WriteVerboseOutputForObject(this, uri1);
                                    NewQuickVM newQuickVM = this;
                                    if (action == null)
                                    {
                                        action = (string s) => base.Channel.AddRole(s, this.ServiceName, this.ServiceName, uri1);
                                    }
                                    ((CmdletBase <IServiceManagement>)newQuickVM).RetryCall(action);
                                    Operation operation3 = base.WaitForOperation(string.Concat(base.CommandRuntime.ToString(), " - Create VM ", uri1.RoleName));
                                    ManagementOperationContext managementOperationContext4 = new ManagementOperationContext();
                                    managementOperationContext4.set_OperationDescription(string.Concat(base.CommandRuntime.ToString(), " - Create VM ", uri1.RoleName));
                                    managementOperationContext4.set_OperationId(operation3.OperationTrackingId);
                                    managementOperationContext4.set_OperationStatus(operation3.Status);
                                    ManagementOperationContext managementOperationContext5 = managementOperationContext4;
                                    base.WriteObject(managementOperationContext5, true);
                                }
                                catch (CommunicationException communicationException5)
                                {
                                    CommunicationException communicationException4 = communicationException5;
                                    this.WriteErrorDetails(communicationException4);
                                    return;
                                }
                            }
                        }
                        return;
                    }
                    else
                    {
                        return;
                    }
                }
                return;
            }
            else
            {
                throw new ArgumentException("CurrentStorageAccount is not set. Use Set-AzureSubscription subname -CurrentStorageAccount storageaccount to set it.");
            }
        }
Esempio n. 18
0
        public void NewAzureVMProcess()
        {
            NewAzureVMCommand.NewAzureVMCommand variable = null;
            int num;
            List <PersistentVMRole> persistentVMRoles  = new List <PersistentVMRole>();
            NewAzureVMCommand       persistentVMRoles1 = this;
            var persistentVMs = new List <PersistentVMRole>();
            SubscriptionData currentSubscription = CmdletSubscriptionExtensions.GetCurrentSubscription(this);

            PersistentVM[] vMs = this.VMs;
            for (int i = 0; i < (int)vMs.Length; i++)
            {
                PersistentVM uri = vMs[i];
                if (uri.OSVirtualHardDisk.MediaLink == null && string.IsNullOrEmpty(uri.OSVirtualHardDisk.DiskName))
                {
                    CloudStorageAccount currentStorageAccount = null;
                    try
                    {
                        currentStorageAccount = currentSubscription.GetCurrentStorageAccount(base.Channel);
                    }
                    catch (EndpointNotFoundException endpointNotFoundException)
                    {
                        throw new ArgumentException("CurrentStorageAccount is not accessible. Ensure the current storage account is accessible and in the same location or affinity group as your cloud service.");
                    }
                    if (currentStorageAccount != null)
                    {
                        DateTime now      = DateTime.Now;
                        string   roleName = uri.RoleName;
                        if (uri.OSVirtualHardDisk.DiskLabel != null)
                        {
                            roleName = string.Concat(roleName, "-", uri.OSVirtualHardDisk.DiskLabel);
                        }
                        object[] serviceName = new object[6];
                        serviceName[0] = this.ServiceName;
                        serviceName[1] = roleName;
                        serviceName[2] = now.Year;
                        serviceName[3] = now.Month;
                        serviceName[4] = now.Day;
                        serviceName[5] = now.Millisecond;
                        string str         = string.Format("{0}-{1}-{2}-{3}-{4}-{5}.vhd", serviceName);
                        string absoluteUri = currentStorageAccount.BlobEndpoint.AbsoluteUri;
                        if (!absoluteUri.EndsWith("/"))
                        {
                            absoluteUri = string.Concat(absoluteUri, "/");
                        }
                        uri.OSVirtualHardDisk.MediaLink = new Uri(string.Concat(absoluteUri, "vhds/", str));
                    }
                    else
                    {
                        throw new ArgumentException("CurrentStorageAccount is not set. Use Set-AzureSubscription subname -CurrentStorageAccount storage account to set it.");
                    }
                }
                foreach (DataVirtualHardDisk dataVirtualHardDisk in uri.DataVirtualHardDisks)
                {
                    if (dataVirtualHardDisk.MediaLink == null && string.IsNullOrEmpty(dataVirtualHardDisk.DiskName))
                    {
                        CloudStorageAccount cloudStorageAccount = currentSubscription.GetCurrentStorageAccount(base.Channel);
                        if (cloudStorageAccount != null)
                        {
                            DateTime dateTime  = DateTime.Now;
                            string   roleName1 = uri.RoleName;
                            if (dataVirtualHardDisk.DiskLabel != null)
                            {
                                roleName1 = string.Concat(roleName1, "-", dataVirtualHardDisk.DiskLabel);
                            }
                            object[] year = new object[6];
                            year[0] = this.ServiceName;
                            year[1] = roleName1;
                            year[2] = dateTime.Year;
                            year[3] = dateTime.Month;
                            year[4] = dateTime.Day;
                            year[5] = dateTime.Millisecond;
                            string str1         = string.Format("{0}-{1}-{2}-{3}-{4}-{5}.vhd", year);
                            string absoluteUri1 = cloudStorageAccount.BlobEndpoint.AbsoluteUri;
                            if (!absoluteUri1.EndsWith("/"))
                            {
                                absoluteUri1 = string.Concat(absoluteUri1, "/");
                            }
                            dataVirtualHardDisk.MediaLink = new Uri(string.Concat(absoluteUri1, "vhds/", str1));
                        }
                        else
                        {
                            throw new ArgumentException("CurrentStorageAccount is not set or not accessible. Use Set-AzureSubscription subname -CurrentStorageAccount storageaccount to set it.");
                        }
                    }
                    if (uri.DataVirtualHardDisks.Count <DataVirtualHardDisk>() <= 1)
                    {
                        continue;
                    }
                    Thread.Sleep(1);
                }
                PersistentVMRole persistentVMRole = new PersistentVMRole();
                persistentVMRole.AvailabilitySetName  = uri.AvailabilitySetName;
                persistentVMRole.ConfigurationSets    = uri.ConfigurationSets;
                persistentVMRole.DataVirtualHardDisks = uri.DataVirtualHardDisks;
                persistentVMRole.OSVirtualHardDisk    = uri.OSVirtualHardDisk;
                persistentVMRole.RoleName             = uri.RoleName;
                persistentVMRole.RoleSize             = uri.RoleSize;
                persistentVMRole.RoleType             = uri.RoleType;
                persistentVMRole.Label = uri.Label;
                PersistentVMRole persistentVMRole1 = persistentVMRole;
                persistentVMRoles1.persistentVMs.Add(persistentVMRole1);
            }
            new List <string>();
            Operation operation = null;

            using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
            {
                try
                {
                    if (base.ParameterSetName.Equals("CreateService", StringComparison.OrdinalIgnoreCase))
                    {
                        CreateHostedServiceInput createHostedServiceInput = new CreateHostedServiceInput();
                        createHostedServiceInput.AffinityGroup = this.AffinityGroup;
                        createHostedServiceInput.Location      = this.Location;
                        createHostedServiceInput.ServiceName   = this.ServiceName;
                        if (this.ServiceDescription != null)
                        {
                            createHostedServiceInput.Description = this.ServiceDescription;
                        }
                        else
                        {
                            DateTime now1          = DateTime.Now;
                            DateTime universalTime = now1.ToUniversalTime();
                            string   str2          = string.Format("Implicitly created hosted service{0}", universalTime.ToString("yyyy-MM-dd HH:mm"));
                            createHostedServiceInput.Description = str2;
                        }
                        if (this.ServiceLabel != null)
                        {
                            createHostedServiceInput.Label = ServiceManagementHelper.EncodeToBase64String(this.ServiceLabel);
                        }
                        else
                        {
                            createHostedServiceInput.Label = ServiceManagementHelper.EncodeToBase64String(this.ServiceName);
                        }
                        CmdletExtensions.WriteVerboseOutputForObject(this, createHostedServiceInput);
                        base.RetryCall((string s) => base.Channel.CreateHostedService(s, createHostedServiceInput));
                        Operation operation1 = base.WaitForOperation(string.Concat(base.CommandRuntime.ToString(), " - Create Cloud Service"));
                        ManagementOperationContext managementOperationContext = new ManagementOperationContext();
                        managementOperationContext.set_OperationDescription(string.Concat(base.CommandRuntime.ToString(), " - Create Cloud Service"));
                        managementOperationContext.set_OperationId(operation1.OperationTrackingId);
                        managementOperationContext.set_OperationStatus(operation1.Status);
                        ManagementOperationContext managementOperationContext1 = managementOperationContext;
                        base.WriteObject(managementOperationContext1, true);
                    }
                }
                catch (CommunicationException communicationException1)
                {
                    CommunicationException communicationException = communicationException1;
                    this.WriteErrorDetails(communicationException);
                    return;
                }
            }
            if (operation == null || string.Compare(operation.Status, "Failed", StringComparison.OrdinalIgnoreCase) != 0)
            {
                if (base.CurrentDeployment != null)
                {
                    if (this.VNetName != null || this.DnsSettings != null || !string.IsNullOrEmpty(this.DeploymentLabel) || !string.IsNullOrEmpty(this.DeploymentName))
                    {
                        base.WriteWarning("VNetName, DnsSettings, DeploymentLabel or DeploymentName Name can only be specified on new deployments.");
                    }
                }
                else
                {
                    using (OperationContextScope operationContextScope1 = new OperationContextScope((IContextChannel)base.Channel))
                    {
                        try
                        {
                            if (string.IsNullOrEmpty(this.DeploymentName))
                            {
                                this.DeploymentName = this.ServiceName;
                            }
                            if (string.IsNullOrEmpty(this.DeploymentLabel))
                            {
                                this.DeploymentLabel = this.ServiceName;
                            }
                            Deployment deployment = new Deployment();
                            deployment.DeploymentSlot = "Production";
                            deployment.Name           = this.DeploymentName;
                            deployment.Label          = this.DeploymentLabel;
                            List <Role> roles = new List <Role>();
                            roles.Add(persistentVMRoles1.persistentVMs[0]);
                            deployment.RoleList           = new RoleList(roles);
                            deployment.VirtualNetworkName = this.VNetName;
                            Deployment dnsSetting = deployment;
                            if (this.DnsSettings != null)
                            {
                                dnsSetting.Dns            = new DnsSettings();
                                dnsSetting.Dns.DnsServers = new DnsServerList();
                                DnsServer[] dnsSettings = this.DnsSettings;
                                for (int j = 0; j < (int)dnsSettings.Length; j++)
                                {
                                    DnsServer dnsServer = dnsSettings[j];
                                    dnsSetting.Dns.DnsServers.Add(dnsServer);
                                }
                            }
                            CmdletExtensions.WriteVerboseOutputForObject(this, dnsSetting);
                            base.RetryCall((string s) => base.Channel.CreateDeployment(s, this.ServiceName, dnsSetting));
                            Operation operation2 = base.WaitForOperation(string.Concat(base.CommandRuntime.ToString(), " - Create Deployment with VM ", persistentVMRoles1.persistentVMs[0].RoleName));
                            ManagementOperationContext managementOperationContext2 = new ManagementOperationContext();
                            managementOperationContext2.set_OperationDescription(string.Concat(base.CommandRuntime.ToString(), " - Create Deployment with VM ", persistentVMRoles1.persistentVMs[0].RoleName));
                            managementOperationContext2.set_OperationId(operation2.OperationTrackingId);
                            managementOperationContext2.set_OperationStatus(operation2.Status);
                            ManagementOperationContext managementOperationContext3 = managementOperationContext2;
                            base.WriteObject(managementOperationContext3, true);
                        }
                        catch (CommunicationException communicationException3)
                        {
                            CommunicationException communicationException2 = communicationException3;
                            if (communicationException2 as EndpointNotFoundException == null)
                            {
                                this.WriteErrorDetails(communicationException2);
                                return;
                            }
                            else
                            {
                                throw new Exception("Cloud Service does not exist. Specify -Location or -AffinityGroup to create one.");
                            }
                        }
                        this.createdDeployment = true;
                    }
                }
                if (!this.createdDeployment && base.CurrentDeployment != null)
                {
                    this.DeploymentName = base.CurrentDeployment.Name;
                }
                if (this.createdDeployment)
                {
                    num = 1;
                }
                else
                {
                    num = 0;
                }
                int             num1   = num;
                Action <string> action = null;
                while (num1 < persistentVMRoles1.persistentVMs.Count)
                {
                    if (operation == null || string.Compare(operation.Status, "Failed", StringComparison.OrdinalIgnoreCase) != 0)
                    {
                        using (OperationContextScope operationContextScope2 = new OperationContextScope((IContextChannel)base.Channel))
                        {
                            try
                            {
                                CmdletExtensions.WriteVerboseOutputForObject(this, persistentVMRoles1.persistentVMs[num1]);
                                NewAzureVMCommand newAzureVMCommand = this;
                                if (action == null)
                                {
                                    action = (string s) => base.Channel.AddRole(s, this.ServiceName, this.DeploymentName, persistentVMRoles[num1]);
                                }
                                ((CmdletBase <IServiceManagement>)newAzureVMCommand).RetryCall(action);
                                Operation operation3 = base.WaitForOperation(string.Concat(base.CommandRuntime.ToString(), " - Create VM ", persistentVMRoles1.persistentVMs[num1].RoleName));
                                ManagementOperationContext managementOperationContext4 = new ManagementOperationContext();
                                managementOperationContext4.set_OperationDescription(string.Concat(base.CommandRuntime.ToString(), " - Create VM ", persistentVMRoles1.persistentVMs[num1].RoleName));
                                managementOperationContext4.set_OperationId(operation3.OperationTrackingId);
                                managementOperationContext4.set_OperationStatus(operation3.Status);
                                ManagementOperationContext managementOperationContext5 = managementOperationContext4;
                                base.WriteObject(managementOperationContext5, true);
                            }
                            catch (CommunicationException communicationException5)
                            {
                                CommunicationException communicationException4 = communicationException5;
                                this.WriteErrorDetails(communicationException4);
                                return;
                            }
                        }
                        NewAzureVMCommand.NewAzureVMCommand variable1 = variable;
                        variable1.i = variable1.i + 1;
                    }
                    else
                    {
                        return;
                    }
                }
                return;
            }
        }
Esempio n. 19
0
        public static string GetConfiguration(string configurationPath)
        {
            string str = string.Join(string.Empty, File.ReadAllLines(configurationPath));

            return(ServiceManagementHelper.EncodeToBase64String(str));
        }
Esempio n. 20
0
        public void SetDeploymentTmpProcess()
        {
            SetAzureDeploymentCommand.SetAzureDeploymentCommand variable = null;
            string mode;
            string base64String;
            string empty = string.Empty;

            if (!string.IsNullOrEmpty(this.Configuration))
            {
                empty = Utility.GetConfiguration(this.Configuration);
            }
            if (string.Compare(base.ParameterSetName, "Upgrade", StringComparison.OrdinalIgnoreCase) != 0)
            {
                if (string.Compare(base.ParameterSetName, "Config", StringComparison.OrdinalIgnoreCase) != 0)
                {
                    Action <string>             action = null;
                    UpdateDeploymentStatusInput updateDeploymentStatusInput = new UpdateDeploymentStatusInput();
                    updateDeploymentStatusInput.Status = this.NewStatus;
                    UpdateDeploymentStatusInput updateDeploymentStatusInput1 = updateDeploymentStatusInput;
                    using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
                    {
                        try
                        {
                            SetAzureDeploymentCommand setAzureDeploymentCommand = this;
                            if (action == null)
                            {
                                action = (string s) => base.Channel.UpdateDeploymentStatusBySlot(s, this.ServiceName, this.Slot, updateDeploymentStatusInput1);
                            }
                            ((CmdletBase <IServiceManagement>)setAzureDeploymentCommand).RetryCall(action);
                            Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
                            ManagementOperationContext managementOperationContext = new ManagementOperationContext();
                            managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
                            managementOperationContext.set_OperationId(operation.OperationTrackingId);
                            managementOperationContext.set_OperationStatus(operation.Status);
                            ManagementOperationContext managementOperationContext1 = managementOperationContext;
                            base.WriteObject(managementOperationContext1, true);
                        }
                        catch (CommunicationException communicationException1)
                        {
                            CommunicationException communicationException = communicationException1;
                            this.WriteErrorDetails(communicationException);
                        }
                    }
                }
                else
                {
                    Action <string>          action1 = null;
                    ChangeConfigurationInput changeConfigurationInput = new ChangeConfigurationInput();
                    changeConfigurationInput.Configuration = empty;
                    ChangeConfigurationInput changeConfigurationInput1 = changeConfigurationInput;
                    using (OperationContextScope operationContextScope1 = new OperationContextScope((IContextChannel)base.Channel))
                    {
                        try
                        {
                            CmdletExtensions.WriteVerboseOutputForObject(this, changeConfigurationInput1);
                            SetAzureDeploymentCommand setAzureDeploymentCommand1 = this;
                            if (action1 == null)
                            {
                                action1 = (string s) => base.Channel.ChangeConfigurationBySlot(s, this.ServiceName, this.Slot, changeConfigurationInput1);
                            }
                            ((CmdletBase <IServiceManagement>)setAzureDeploymentCommand1).RetryCall(action1);
                            Operation operation1 = base.WaitForOperation(base.CommandRuntime.ToString());
                            ManagementOperationContext managementOperationContext2 = new ManagementOperationContext();
                            managementOperationContext2.set_OperationDescription(base.CommandRuntime.ToString());
                            managementOperationContext2.set_OperationId(operation1.OperationTrackingId);
                            managementOperationContext2.set_OperationStatus(operation1.Status);
                            ManagementOperationContext managementOperationContext3 = managementOperationContext2;
                            base.WriteObject(managementOperationContext3, true);
                        }
                        catch (CommunicationException communicationException3)
                        {
                            CommunicationException communicationException2 = communicationException3;
                            this.WriteErrorDetails(communicationException2);
                        }
                    }
                }
            }
            else
            {
                Func <string, Uri> func    = null;
                Action <string>    action2 = null;
                Action <string>    action3 = null;
                bool flag = false;
                base.CurrentSubscription = CmdletSubscriptionExtensions.GetCurrentSubscription(this);
                string currentStorageAccount = base.CurrentSubscription.CurrentStorageAccount;
                if (this.Package.StartsWith(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) || this.Package.StartsWith(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
                {
                    Uri uri = new Uri(this.Package);
                }
                else
                {
                    if (!string.IsNullOrEmpty(currentStorageAccount))
                    {
                        ProgressRecord progressRecord = new ProgressRecord(0, "Please wait...", "Uploading package to blob storage");
                        base.WriteProgress(progressRecord);
                        flag = true;
                        SetAzureDeploymentCommand variable1 = variable;
                        SetAzureDeploymentCommand setAzureDeploymentCommand2 = this;
                        if (func == null)
                        {
                            func = (string s) => AzureBlob.UploadPackageToBlob(this.CreateChannel(), currentStorageAccount, s, this.Package);
                        }
                        packageUrl = ((CmdletBase <IServiceManagement>)setAzureDeploymentCommand2).RetryCall <Uri>(func);
                    }
                    else
                    {
                        throw new ArgumentException("CurrentStorageAccount is not set. Use Set-AzureSubscription subname -CurrentStorageAccount storageaccount to set it.");
                    }
                }
                SetAzureDeploymentCommand variable2 = variable;
                UpgradeDeploymentInput    upgradeDeploymentInput  = new UpgradeDeploymentInput();
                UpgradeDeploymentInput    upgradeDeploymentInput1 = upgradeDeploymentInput;
                if (this.Mode == null)
                {
                    mode = "Auto";
                }
                else
                {
                    mode = this.Mode;
                }
                upgradeDeploymentInput1.Mode         = mode;
                upgradeDeploymentInput.Configuration = empty;
                upgradeDeploymentInput.PackageUrl    = uri;
                UpgradeDeploymentInput upgradeDeploymentInput2 = upgradeDeploymentInput;
                if (this.Label != null)
                {
                    base64String = ServiceManagementHelper.EncodeToBase64String(this.Label);
                }
                else
                {
                    base64String = ServiceManagementHelper.EncodeToBase64String(this.ServiceName);
                }
                upgradeDeploymentInput2.Label = base64String;
                SwitchParameter force = this.Force;
                upgradeDeploymentInput.Force     = new bool?(force.IsPresent);
                variable2.upgradeDeploymentInput = upgradeDeploymentInput;
                if (!string.IsNullOrEmpty(this.RoleName))
                {
                    UpgradeDeploymentInput roleName = this.RoleName;
                }
                using (OperationContextScope operationContextScope2 = new OperationContextScope((IContextChannel)base.Channel))
                {
                    try
                    {
                        CmdletExtensions.WriteVerboseOutputForObject(this, roleName);
                        SetAzureDeploymentCommand setAzureDeploymentCommand3 = this;
                        if (action2 == null)
                        {
                            action2 = (string s) => this.Channel.UpgradeDeploymentBySlot(s, this.ServiceName, this.Slot, this.upgradeDeploymentInput);
                        }
                        ((CmdletBase <IServiceManagement>)setAzureDeploymentCommand3).RetryCall(action2);
                        Operation operation2 = base.WaitForOperation(base.CommandRuntime.ToString());
                        ManagementOperationContext managementOperationContext4 = new ManagementOperationContext();
                        managementOperationContext4.OperationDescription = base.CommandRuntime.ToString();
                        managementOperationContext4.OperationId          = operation2.OperationTrackingId;
                        managementOperationContext4.OperationStatus      = operation2.Status;
                        ManagementOperationContext managementOperationContext5 = managementOperationContext4;
                        base.WriteObject(managementOperationContext5, true);
                        if (flag)
                        {
                            SetAzureDeploymentCommand setAzureDeploymentCommand4 = this;
                            if (action3 == null)
                            {
                                action3 = (string s) => AzureBlob.DeletePackageFromBlob(base.Channel, currentStorageAccount, s, uri);
                            }
                            ((CmdletBase <IServiceManagement>)setAzureDeploymentCommand4).RetryCall(action3);
                        }
                    }
                    catch (CommunicationException communicationException5)
                    {
                        CommunicationException communicationException4 = communicationException5;
                        this.WriteErrorDetails(communicationException4);
                    }
                }
            }
        }
        public void NewPaaSDeploymentProcess()
        {
            NewAzureDeploymentCommand.NewAzureDeploymentCommand variable = null;
            Func <string, Deployment> func    = null;
            Func <string, Uri>        func1   = null;
            Action <string>           action  = null;
            Action <string>           action1 = null;
            bool flag = false;

            using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
            {
                try
                {
                    new List <PersistentVMRoleContext>();
                    NewAzureDeploymentCommand newAzureDeploymentCommand = this;
                    if (func == null)
                    {
                        func = (string s) => base.Channel.GetDeploymentBySlot(s, this.ServiceName, "Production");
                    }
                    Deployment deployment = ((CmdletBase <IServiceManagement>)newAzureDeploymentCommand).RetryCall <Deployment>(func);
                    if (deployment.RoleList != null && string.Compare(deployment.RoleList[0].RoleType, "PersistentVMRole", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        throw new ArgumentException("Cannot Create New Deployment with Virtual Machines Present");
                    }
                }
                catch (CommunicationException communicationException1)
                {
                    CommunicationException communicationException = communicationException1;
                    if (communicationException as EndpointNotFoundException == null && !base.IsVerbose())
                    {
                        this.WriteErrorDetails(communicationException);
                    }
                }
            }
            string currentStorageAccount = base.get_CurrentSubscription().get_CurrentStorageAccount();

            if (this.Package.StartsWith(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) || this.Package.StartsWith(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
            {
                Uri uri = new Uri(this.Package);
            }
            else
            {
                ProgressRecord progressRecord = new ProgressRecord(0, "Please wait...", "Uploading package to blob storage");
                base.WriteProgress(progressRecord);
                flag = true;
                NewAzureDeploymentCommand.NewAzureDeploymentCommand variable1 = variable;
                NewAzureDeploymentCommand newAzureDeploymentCommand1          = this;
                if (func1 == null)
                {
                    func1 = (string s) => AzureBlob.UploadPackageToBlob(base.Channel, currentStorageAccount, s, this.Package);
                }
                variable1.packageUrl = ((CmdletBase <IServiceManagement>)newAzureDeploymentCommand1).RetryCall <Uri>(func1);
            }
            CreateDeploymentInput createDeploymentInput = new CreateDeploymentInput();

            createDeploymentInput.PackageUrl    = uri;
            createDeploymentInput.Configuration = Utility.GetConfiguration(this.Configuration);
            createDeploymentInput.Label         = ServiceManagementHelper.EncodeToBase64String(this.Label);
            createDeploymentInput.Name          = this.Name;
            SwitchParameter doNotStart = this.DoNotStart;

            createDeploymentInput.StartDeployment = new bool?(!doNotStart.IsPresent);
            SwitchParameter treatWarningsAsError = this.TreatWarningsAsError;

            createDeploymentInput.TreatWarningsAsError = new bool?(treatWarningsAsError.IsPresent);
            CreateDeploymentInput createDeploymentInput1 = createDeploymentInput;

            using (OperationContextScope operationContextScope1 = new OperationContextScope((IContextChannel)base.Channel))
            {
                try
                {
                    ProgressRecord progressRecord1 = new ProgressRecord(0, "Please wait...", "Creating the new deployment");
                    base.WriteProgress(progressRecord1);
                    CmdletExtensions.WriteVerboseOutputForObject(this, createDeploymentInput1);
                    NewAzureDeploymentCommand newAzureDeploymentCommand2 = this;
                    if (action == null)
                    {
                        action = (string s) => this.Channel.CreateOrUpdateDeployment(s, this.ServiceName, this.Slot, this.deploymentInput);
                    }

                    ((CmdletBase <IServiceManagement>)newAzureDeploymentCommand2).RetryCall(action);
                    Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
                    ManagementOperationContext managementOperationContext = new ManagementOperationContext();
                    managementOperationContext.OperationDescription = base.CommandRuntime.ToString();
                    managementOperationContext.OperationId          = operation.OperationTrackingId;
                    managementOperationContext.OperationStatus      = operation.Status;
                    ManagementOperationContext managementOperationContext1 = managementOperationContext;
                    base.WriteObject(managementOperationContext1, true);
                    if (flag)
                    {
                        NewAzureDeploymentCommand newAzureDeploymentCommand3 = this;
                        if (action1 == null)
                        {
                            action1 = (string s) => AzureBlob.DeletePackageFromBlob(base.Channel, currentStorageAccount, s, uri);
                        }
                        ((CmdletBase <IServiceManagement>)newAzureDeploymentCommand3).RetryCall(action1);
                    }
                }
                catch (CommunicationException communicationException3)
                {
                    CommunicationException communicationException2 = communicationException3;
                    this.WriteErrorDetails(communicationException2);
                }
            }
        }