/// <summary>
        /// Creates a new pool.
        /// </summary>
        /// <param name="parameters">The parameters to use when creating the pool.</param>
        public void CreatePool(NewPoolParameters parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
            CloudPool      pool           = poolOperations.CreatePool(poolId: parameters.PoolId, osFamily: parameters.OSFamily, virtualMachineSize: parameters.VirtualMachineSize);

            pool.DisplayName            = parameters.DisplayName;
            pool.ResizeTimeout          = parameters.ResizeTimeout;
            pool.MaxTasksPerComputeNode = parameters.MaxTasksPerComputeNode;
            pool.InterComputeNodeCommunicationEnabled = parameters.InterComputeNodeCommunicationEnabled;

            if (!string.IsNullOrEmpty(parameters.AutoScaleFormula))
            {
                pool.AutoScaleEnabled = true;
                pool.AutoScaleFormula = parameters.AutoScaleFormula;
            }
            else if (parameters.TargetDedicated.HasValue)
            {
                pool.TargetDedicated = parameters.TargetDedicated;
            }

            if (parameters.TaskSchedulingPolicy != null)
            {
                pool.TaskSchedulingPolicy = parameters.TaskSchedulingPolicy.omObject;
            }

            if (parameters.StartTask != null)
            {
                Utils.Utils.StartTaskSyncCollections(parameters.StartTask);
                pool.StartTask = parameters.StartTask.omObject;
            }

            if (parameters.Metadata != null)
            {
                pool.Metadata = new List <MetadataItem>();
                foreach (DictionaryEntry m in parameters.Metadata)
                {
                    pool.Metadata.Add(new MetadataItem(m.Key.ToString(), m.Value.ToString()));
                }
            }

            if (parameters.CertificateReferences != null)
            {
                pool.CertificateReferences = new List <CertificateReference>();
                foreach (PSCertificateReference c in parameters.CertificateReferences)
                {
                    pool.CertificateReferences.Add(c.omObject);
                }
            }

            WriteVerbose(string.Format(Resources.CreatingPool, parameters.PoolId));
            pool.Commit(parameters.AdditionalBehaviors);
        }
        private static async Task TestPoolCreateAndUpdateWithCertificateReferencesAsync(
            BatchClient batchCli,
            IList <CertificateReference> certificateReferences)
        {
            PoolOperations poolOperations = batchCli.PoolOperations;

            string poolId = "CreateAndUpdateWithCertificateReferences-" + TestUtilities.GetMyName();

            try
            {
                // create a pool with initial cert refs
                CloudPool boundPool;

                {
                    CloudPool unboundPool = poolOperations.CreatePool(
                        poolId: poolId,
                        virtualMachineSize: PoolFixture.VMSize,
                        cloudServiceConfiguration: new CloudServiceConfiguration(PoolFixture.OSFamily),
                        targetDedicatedComputeNodes: 0);

                    // create the pool with initial cert refs
                    unboundPool.CertificateReferences = certificateReferences;

                    await unboundPool.CommitAsync().ConfigureAwait(false);

                    boundPool = await poolOperations.GetPoolAsync(poolId).ConfigureAwait(false);

                    // confirm the refs are there
                    Assert.NotNull(boundPool.CertificateReferences);
                    AssertCertificateReferenceCollectionsAreSame(certificateReferences, boundPool.CertificateReferences);
                }

                // mutate the cert refs: assign only one
                {
                    List <CertificateReference> listOfOne = new List <CertificateReference>();

                    // just pick one cert
                    listOfOne.Add(certificateReferences.ToArray()[1]);

                    boundPool.CertificateReferences = listOfOne;

                    await boundPool.CommitAsync().ConfigureAwait(false);

                    await boundPool.RefreshAsync().ConfigureAwait(false);

                    // confirm that the ref collection is correct
                    AssertCertificateReferenceCollectionsAreSame(listOfOne, boundPool.CertificateReferences);
                }

                // mutate the pool cert refs: assign null to clear
                {
                    boundPool.CertificateReferences = null;

                    await boundPool.CommitAsync().ConfigureAwait(false);

                    await boundPool.RefreshAsync().ConfigureAwait(false);

                    Assert.Empty(boundPool.CertificateReferences);
                }
            }
            finally
            {
                // cleanup
                TestUtilities.DeletePoolIfExistsAsync(batchCli, poolId).Wait();
            }
        }
        public void Bug1965363_2384616_Wat7OSVersionFeatures()
        {
            Action test = () =>
            {
                using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
                {
                    PoolOperations poolOperations = batchCli.PoolOperations;
                    try
                    {
                        this.testOutputHelper.WriteLine("Listing OS Versions:");

                        /* bug 2384616 ListOsVersions hidden for wat 8
                         *
                         *  // test ListOSVersion
                         *  foreach (OSVersion curOSV in poolMgr.ListOSVersions())
                         *  {
                         *      this.testOutputHelper.WriteLine("Label: " + curOSV.Label);
                         *      this.testOutputHelper.WriteLine("    Version: " + curOSV.Version);
                         *      this.testOutputHelper.WriteLine("    Family: " + curOSV.Family);
                         *      this.testOutputHelper.WriteLine("    FamilyLabel: " + curOSV.FamilyLabel);
                         *      this.testOutputHelper.WriteLine("    isDefault: " + curOSV.IsDefault);
                         *      this.testOutputHelper.WriteLine("    IsActive: " + curOSV.IsActive);
                         *
                         *      string expDate;
                         *
                         *      if (curOSV.ExpirationDate.HasValue)
                         *      {
                         *          expDate = curOSV.ExpirationDate.Value.ToString();
                         *      }
                         *      else
                         *      {
                         *          expDate = "<null/novalue>";
                         *      }
                         *
                         *      this.testOutputHelper.WriteLine("    ExpirationDate: " + expDate);
                         *  }
                         *
                         */

                        // create pool tests


                        // forget to set CloudServiceConfiguration on Create, get error
                        {
                            CloudPool noArgs = poolOperations.CreatePool("Bug1965363ButNoOSFamily-" + TestUtilities.GetMyName(), PoolFixture.VMSize, default(CloudServiceConfiguration), targetDedicated: 0);

                            BatchException ex    = TestUtilities.AssertThrows <BatchException>(() => noArgs.Commit());
                            string         exStr = ex.ToString();

                            // we are expecting an exception, assert if the exception is not the correct one.
                            Assert.Contains("cloudServiceConfiguration", exStr);
                        }

                        // create a pool WITH an osFamily
                        {
                            string poolIdHOSF = "Bug1965363HasOSF-" + TestUtilities.GetMyName();
                            try
                            {
                                CloudPool hasOSF = poolOperations.CreatePool(poolIdHOSF, PoolFixture.VMSize, new CloudServiceConfiguration(PoolFixture.OSFamily), targetDedicated: 0);

                                hasOSF.Commit();
                            }
                            finally
                            {
                                poolOperations.DeletePool(poolIdHOSF);
                            }
                        }

                        // TODO: ultimately we will either need to find (via list) a family with more than one version or
                        //       manually update these strings as OS versions are depricated
                        //See here for other OS versions if this test fails: http://azure.microsoft.com/en-us/documentation/articles/cloud-services-guestos-update-matrix/
                        const string familyVersion0 = "*";
                        const string familyVersion1 = "WA-GUEST-OS-4.32_201605-01";

                        // "UpdatePoolOS" tests (ChangeOSVersion in OM)

                        // PoolManager
                        {
                            string poolIdChangeOSV = "Bug1965363ChangeOSVviaMGR-" + TestUtilities.GetMyName();
                            try
                            {
                                CloudPool unboundPool = poolOperations.CreatePool(
                                    poolIdChangeOSV,
                                    PoolFixture.VMSize,
                                    new CloudServiceConfiguration(PoolFixture.OSFamily, familyVersion0), // start with version 0
                                    targetDedicated: 0);

                                unboundPool.Commit();

                                // fetch the bound pool
                                CloudPool boundPool = poolOperations.GetPool(poolIdChangeOSV);

                                Assert.Equal(familyVersion0, boundPool.CloudServiceConfiguration.CurrentOSVersion);

                                // switch to new version
                                poolOperations.ChangeOSVersion(poolIdChangeOSV, familyVersion1);

                                // UpdatePoolOS is has latency???
                                PollForOSVersionChange(boundPool, familyVersion1);

                                // check to make sure the new value is set
                                boundPool.Refresh();

                                Assert.Equal(familyVersion1, boundPool.CloudServiceConfiguration.CurrentOSVersion);
                            }
                            finally
                            {
                                TestUtilities.DeletePoolIfExistsAsync(batchCli, poolIdChangeOSV).Wait();
                            }
                        }

                        // ICloudPool
                        {
                            string poolIdChangeOSV = "Bug1965363ChangeOSVviaPool-" + TestUtilities.GetMyName();
                            try
                            {
                                CloudPool unboundPool = poolOperations.CreatePool(
                                    poolIdChangeOSV,
                                    PoolFixture.VMSize,
                                    new CloudServiceConfiguration(PoolFixture.OSFamily, familyVersion0), // start with version 0
                                    targetDedicated: 0);

                                unboundPool.Commit();

                                // fetch the bound pool
                                CloudPool boundPool = poolOperations.GetPool(poolIdChangeOSV);

                                Assert.Equal(familyVersion0, boundPool.CloudServiceConfiguration.CurrentOSVersion);

                                // switch to new version
                                boundPool.ChangeOSVersion(familyVersion1);

                                // UpdatePoolOS is has latency???
                                PollForOSVersionChange(boundPool, familyVersion1);

                                // check to make sure the new value is set
                                boundPool.Refresh();

                                Assert.Equal(familyVersion1, boundPool.CloudServiceConfiguration.CurrentOSVersion);
                            }
                            finally
                            {
                                TestUtilities.DeletePoolIfExistsAsync(batchCli, poolIdChangeOSV).Wait();
                            }
                        }

                        // autopoolspec tests
                        {
                            string jobId = "Bug1965363WIName-" + TestUtilities.GetMyName();
                            // test not setting osversion
                            try
                            {
                                CloudJob unboundJob       = batchCli.JobOperations.CreateJob(jobId, new PoolInformation());
                                AutoPoolSpecification aps = new AutoPoolSpecification();
                                PoolSpecification     ps  = new PoolSpecification();

                                // test unbound set constraint
                                ps.CloudServiceConfiguration = new CloudServiceConfiguration(PoolFixture.OSFamily);

                                // test unbound get constraint
                                this.testOutputHelper.WriteLine("pus.CloudServiceConfiguration.OSFamily == " + ps.CloudServiceConfiguration.OSFamily);

                                ps.VirtualMachineSize = PoolFixture.VMSize;
                                ps.TargetDedicated    = 0; // trivial size for testing purposes

                                aps.PoolSpecification  = ps;
                                aps.PoolLifetimeOption = PoolLifetimeOption.Job;

                                unboundJob.PoolInformation.AutoPoolSpecification = aps;

                                // commit to test validation
                                unboundJob.Commit();

                                // get bound job
                                CloudJob boundJob = batchCli.JobOperations.GetJob(jobId);

                                // test bound get constraints
                                this.testOutputHelper.WriteLine("    OSFamily == " +
                                                                boundJob.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.OSFamily);

                                string targetOSVersion =
                                    boundJob.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.TargetOSVersion;

                                if (string.IsNullOrEmpty(targetOSVersion))
                                {
                                    targetOSVersion = "<null or empty";
                                }

                                this.testOutputHelper.WriteLine("    TargetOSVersion == " + targetOSVersion);
                            }
                            finally
                            {
                                // cleanup
                                TestUtilities.DeleteJobIfExistsAsync(batchCli, jobId).Wait();
                            }

                            {
                                string jobScheduleId = "Bug1965363WINameSettingAndChanging-" + TestUtilities.GetMyName();
                                // test setting osversion
                                try
                                {
                                    AutoPoolSpecification aps = new AutoPoolSpecification();
                                    PoolSpecification     ps  = new PoolSpecification();
                                    CloudJobSchedule      unboundJobSchedule = batchCli.JobScheduleOperations.CreateJobSchedule(
                                        jobScheduleId,
                                        new Schedule()
                                    {
                                        RecurrenceInterval = TimeSpan.FromDays(7)
                                    },
                                        new JobSpecification(new PoolInformation()
                                    {
                                        AutoPoolSpecification = aps
                                    }));

                                    // test unbound set constraint
                                    ps.CloudServiceConfiguration = new CloudServiceConfiguration(PoolFixture.OSFamily, familyVersion0);

                                    // test unbound get constraint
                                    this.testOutputHelper.WriteLine("pus.CloudServiceConfiguration.OSFamily == " + ps.CloudServiceConfiguration.OSFamily);
                                    this.testOutputHelper.WriteLine("pus.CloudServiceConfiguration.TargetOSVersion == " + ps.CloudServiceConfiguration.TargetOSVersion);

                                    ps.VirtualMachineSize = PoolFixture.VMSize;
                                    ps.TargetDedicated    = 0; // trivial size for testing purposes

                                    aps.PoolSpecification  = ps;
                                    aps.PoolLifetimeOption = PoolLifetimeOption.Job;

                                    unboundJobSchedule.Commit();

                                    // get bound job schedule
                                    CloudJobSchedule boundJobSchedule = batchCli.JobScheduleOperations.GetJobSchedule(jobScheduleId);

                                    // test bound get constraints
                                    this.testOutputHelper.WriteLine("    OSFamily == " + boundJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.OSFamily);
                                    this.testOutputHelper.WriteLine("    TargetOSVersion == " + boundJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.TargetOSVersion);

                                    // assert the value is as set above
                                    Assert.Equal(familyVersion0, boundJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.TargetOSVersion);

                                    // change values
                                    const string altFamily    = "3";
                                    const string altOSVersion = "WA-GUEST-OS-3.39_201605-01";

                                    // change values on the bound PUS
                                    PoolSpecification boundPS = boundJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification;

                                    boundPS.CloudServiceConfiguration = new CloudServiceConfiguration(altFamily, altOSVersion);

                                    // flush changes
                                    boundJobSchedule.Commit();

                                    // confirm changes took
                                    boundJobSchedule.Refresh();

                                    Assert.Equal(altFamily, boundJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.OSFamily);
                                    Assert.Equal(altOSVersion, boundJobSchedule.JobSpecification.PoolInformation.AutoPoolSpecification.PoolSpecification.CloudServiceConfiguration.TargetOSVersion);
                                }
                                finally
                                {
                                    // cleanup
                                    TestUtilities.DeleteJobScheduleIfExistsAsync(batchCli, jobScheduleId).Wait();
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        // special case os version beacuse it is a common failure and requires human intervention/editing
                        // test for expired os version
                        Assert.DoesNotContain("The specified OS Version does not exists", ex.ToString());

                        throw;
                    }
                }
            };

            SynchronizationContextHelper.RunTest(test, TestTimeout);
        }
Exemple #4
0
        /// <summary>
        /// Creates a new pool.
        /// </summary>
        /// <param name="parameters">The parameters to use when creating the pool.</param>
        public void CreatePool(NewPoolParameters parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;

            CloudPool pool = poolOperations.CreatePool();

            pool.Id = parameters.PoolId;
            pool.VirtualMachineSize     = parameters.VirtualMachineSize;
            pool.DisplayName            = parameters.DisplayName;
            pool.ResizeTimeout          = parameters.ResizeTimeout;
            pool.MaxTasksPerComputeNode = parameters.MaxTasksPerComputeNode;
            pool.InterComputeNodeCommunicationEnabled = parameters.InterComputeNodeCommunicationEnabled;

            if (!string.IsNullOrEmpty(parameters.AutoScaleFormula))
            {
                pool.AutoScaleEnabled            = true;
                pool.AutoScaleEvaluationInterval = parameters.AutoScaleEvaluationInterval;
                pool.AutoScaleFormula            = parameters.AutoScaleFormula;
            }
            else if (parameters.TargetDedicatedComputeNodes.HasValue || parameters.TargetLowPriorityComputeNodes.HasValue)
            {
                pool.TargetDedicatedComputeNodes   = parameters.TargetDedicatedComputeNodes;
                pool.TargetLowPriorityComputeNodes = parameters.TargetLowPriorityComputeNodes;
            }

            if (parameters.TaskSchedulingPolicy != null)
            {
                pool.TaskSchedulingPolicy = parameters.TaskSchedulingPolicy.omObject;
            }

            if (parameters.StartTask != null)
            {
                Utils.Utils.StartTaskSyncCollections(parameters.StartTask);
                pool.StartTask = parameters.StartTask.omObject;
            }

            if (parameters.Metadata != null)
            {
                pool.Metadata = new List <MetadataItem>();
                foreach (DictionaryEntry m in parameters.Metadata)
                {
                    pool.Metadata.Add(new MetadataItem(m.Key.ToString(), m.Value.ToString()));
                }
            }

            if (parameters.CertificateReferences != null)
            {
                pool.CertificateReferences = new List <CertificateReference>();
                foreach (PSCertificateReference c in parameters.CertificateReferences)
                {
                    pool.CertificateReferences.Add(c.omObject);
                }
            }

            if (parameters.ApplicationPackageReferences != null)
            {
                pool.ApplicationPackageReferences = parameters.ApplicationPackageReferences.ToList().ConvertAll(apr => apr.omObject);
            }

            if (parameters.CloudServiceConfiguration != null)
            {
                pool.CloudServiceConfiguration = parameters.CloudServiceConfiguration.omObject;
            }

            if (parameters.VirtualMachineConfiguration != null)
            {
                Utils.Utils.VirtualMachineConfigurationSyncCollections(parameters.VirtualMachineConfiguration);
                pool.VirtualMachineConfiguration = parameters.VirtualMachineConfiguration.omObject;
            }

            if (parameters.NetworkConfiguration != null)
            {
                pool.NetworkConfiguration = parameters.NetworkConfiguration.omObject;
            }

            if (parameters.MountConfiguration != null)
            {
                pool.MountConfiguration = new List <MountConfiguration>();
                foreach (PSMountConfiguration m in parameters.MountConfiguration)
                {
                    pool.MountConfiguration.Add(m.omObject);
                }
            }

            if (parameters.UserAccounts != null)
            {
                pool.UserAccounts = parameters.UserAccounts.ToList().ConvertAll(user => user.omObject);
            }

            if (parameters.ApplicationLicenses != null)
            {
                pool.ApplicationLicenses = parameters.ApplicationLicenses;
            }

            WriteVerbose(string.Format(Resources.CreatingPool, parameters.PoolId));
            pool.Commit(parameters.AdditionalBehaviors);
        }