DisplayPoolResourcePoolSettingData(
            string resourceDisplayName,
            string poolId)
        {
            Console.WriteLine(
                "Displaying the Msvm_ResourcePoolSettingData properties for the following " +
                "resource pool:\n" +
                "\tPool Id: " + poolId);

            ResourceUtilities.DisplayResourceInformation(resourceDisplayName);

            ManagementScope scope = ResourcePoolUtilities.GetManagementScope();

            using (ManagementObject rpsd =
                       MsvmResourcePoolSettingData.GetPoolResourcePoolSettingData(
                           scope,
                           ResourceUtilities.GetResourceType(resourceDisplayName),
                           ResourceUtilities.GetResourceSubType(resourceDisplayName),
                           poolId))
            {
                Console.WriteLine("Msvm_ResourcePoolSettingData:");

                Console.WriteLine("\tElementName: " + rpsd.GetPropertyValue("ElementName").ToString());
            }
        }
コード例 #2
0
        DisplayPoolVerbose(
            string resourceDisplayName,
            string poolId)
        {
            Console.WriteLine(
                "Displaying the Msvm_ResourcePool, Msvm_ResourcePoolSettingData and " +
                "the Msvm_ResourceAllocationSettingsData properties for the following " +
                "resource pool:\n");

            ManagementScope scope = ResourcePoolUtilities.GetManagementScope();

            using (ManagementObject pool = WmiUtilities.GetResourcePool(
                       ResourceUtilities.GetResourceType(resourceDisplayName),
                       ResourceUtilities.GetResourceSubType(resourceDisplayName),
                       poolId,
                       scope))
            {
                DisplayResourcePool(pool);

                MsvmResourceAllocationSettingData.DisplayPoolResourceAllocationSettingData(
                    scope,
                    pool);

                MsvmResourcePoolSettingData.DisplayPoolResourcePoolSettingData(
                    scope,
                    pool);
            }
        }
 DisplayPoolResourcePoolSettingData(
     ManagementScope scope,
     ManagementObject pool)
 {
     using (ManagementObject rpsd =
                MsvmResourcePoolSettingData.GetPoolResourcePoolSettingData(
                    scope,
                    pool.GetPropertyValue("ResourceType").ToString(),
                    pool.GetPropertyValue("ResourceSubType").ToString(),
                    pool.GetPropertyValue("PoolId").ToString()))
     {
         Console.WriteLine("Msvm_ResourcePoolSettingData:");
         Console.WriteLine("\tPoolId: {0}", rpsd.GetPropertyValue("PoolId"));
         Console.WriteLine("\tElementName: {0}", rpsd.GetPropertyValue("ElementName"));
         Console.WriteLine("\tInstanceID: {0}", rpsd.GetPropertyValue("InstanceID"));
         Console.WriteLine("\tResourceType: {0}", rpsd.GetPropertyValue("ResourceType"));
         Console.WriteLine("\tResourceSubType: {0}", rpsd.GetPropertyValue("ResourceSubType"));
     }
 }
        ModifyPoolSettings(
            string resourceDisplayName,
            string poolId,
            string newPoolId,
            string newPoolName)
        {
            Console.WriteLine(
                "Modifying a resource pool's settings:\n" +
                "\tPool ID: " + poolId + " (change to " + newPoolId + ")\n" +
                "\tPool Name: (change to " + newPoolName + ")");

            ResourceUtilities.DisplayResourceInformation(
                resourceDisplayName);
            ManagementScope scope = ResourcePoolUtilities.GetManagementScope();

            using (ManagementObject rPConfigurationService =
                       MsvmResourcePoolConfigurationService.GetResourcePoolConfigurationService(
                           scope))
            {
                string resourcePoolSettingData =
                    MsvmResourcePoolSettingData.GetSettingsForPool(
                        scope,
                        ResourceUtilities.GetResourceType(resourceDisplayName),
                        ResourceUtilities.GetResourceSubType(resourceDisplayName),
                        newPoolId,
                        newPoolName);

                ModifyPoolSettingsHelper(
                    scope,
                    rPConfigurationService,
                    ResourceUtilities.GetResourceType(resourceDisplayName),
                    ResourceUtilities.GetResourceSubType(resourceDisplayName),
                    poolId,
                    resourcePoolSettingData);
            }
        }
        CreatePoolHelper(
            ManagementScope scope,
            ManagementObject rPConfigurationService,
            string resourceType,
            string resourceSubType,
            string childPoolId,
            string childPoolName,
            string[] parentPoolIdArray,
            string[][] parentHostResourcesArray)
        {
            if (parentPoolIdArray.Length == 0)
            {
                throw new ManagementException(string.Format(
                                                  CultureInfo.CurrentCulture,
                                                  @"At least one parent pool must be specified when creating a 
                    child resource pool (PoolId ""{0}"")", childPoolId));
            }

            if (parentPoolIdArray.Length != parentHostResourcesArray.Length)
            {
                throw new ManagementException(string.Format(
                                                  CultureInfo.CurrentCulture,
                                                  @"When creating a child resource pool, a host resource must be 
                    specified for each parent pool. Shared allocations are not 
                    supported (PoolId ""{0}"")", childPoolId));
            }

            string resourcePoolSettingData =
                MsvmResourcePoolSettingData.GetSettingsForPool(
                    scope,
                    resourceType,
                    resourceSubType,
                    childPoolId,
                    childPoolName);

            string[] parentPoolPathArray =
                ResourcePoolUtilities.GetParentPoolArrayFromPoolIds(
                    scope,
                    resourceType,
                    resourceSubType,
                    parentPoolIdArray);

            string[] resourceAllocationSettingDataArray =
                MsvmResourceAllocationSettingData.GetNewPoolAllocationSettingsArray(
                    scope,
                    resourceType,
                    resourceSubType,
                    parentPoolIdArray,
                    parentHostResourcesArray);

            using (ManagementBaseObject inParams =
                       rPConfigurationService.GetMethodParameters(
                           "CreatePool"))
            {
                inParams["PoolSettings"]       = resourcePoolSettingData;
                inParams["ParentPools"]        = parentPoolPathArray;
                inParams["AllocationSettings"] = resourceAllocationSettingDataArray;

                using (ManagementBaseObject outParams =
                           rPConfigurationService.InvokeMethod(
                               "CreatePool",
                               inParams,
                               null))
                {
                    if (WmiUtilities.ValidateOutput(outParams, scope, true, true))
                    {
                        string poolPath = outParams["Pool"].ToString();

                        return(new ManagementObject(
                                   scope,
                                   new ManagementPath(poolPath),
                                   null));
                    }
                    else
                    {
                        return(null);
                    }
                }
            }
        }
コード例 #6
0
 Main(
     string[] args)
 {
     if (args.Length > 0)
     {
         if (string.Equals(args[0], "EnumerateSupportedResources", StringComparison.OrdinalIgnoreCase) &&
             args.Length == 1)
         {
             ResourceUtilities.EnumerateSupportedResources();
         }
         else if (string.Equals(args[0], "CreatePool", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 6)
         {
             MsvmResourcePoolConfigurationService.CreatePool(
                 args[1],
                 args[2],
                 args[3],
                 args[4],
                 args[5]);
         }
         else if (string.Equals(args[0], "DisplayPoolResources", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourceAllocationSettingData.DisplayPoolResourceAllocationSettingData(
                 args[1],
                 args[2]);
         }
         else if (string.Equals(args[0], "ModifyPoolResources", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 5)
         {
             MsvmResourcePoolConfigurationService.ModifyPoolResources(
                 args[1],
                 args[2],
                 args[3],
                 args[4]);
         }
         else if (string.Equals(args[0], "DisplayPoolSettings", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourcePoolSettingData.DisplayPoolResourcePoolSettingData(
                 args[1],
                 args[2]);
         }
         else if (string.Equals(args[0], "ModifyPoolSettings", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 5)
         {
             MsvmResourcePoolConfigurationService.ModifyPoolSettings(
                 args[1],
                 args[2],
                 args[3],
                 args[4]);
         }
         else if (string.Equals(args[0], "DeletePool", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourcePoolConfigurationService.DeletePool(
                 args[1],
                 args[2]);
         }
         else if (string.Equals(args[0], "DisplayPool", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourcePool.DisplayPoolVerbose(
                 args[1],
                 args[2]);
         }
         else if (string.Equals(args[0], "DisplayChildPools", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourcePool.DisplayChildPools(
                 args[1],
                 args[2]);
         }
         else if (string.Equals(args[0], "DisplayParentPools", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourcePool.DisplayParentPools(
                 args[1],
                 args[2]);
         }
         else if (string.Equals(args[0], "DisplayAllocationCapabilities", StringComparison.OrdinalIgnoreCase) &&
                  args.Length == 3)
         {
             MsvmResourceAllocationSettingData.DisplayValidResourceAllocationSettingDataSettings(
                 args[1],
                 args[2]);
         }
         else
         {
             ShowUsage();
         }
     }
     else
     {
         ShowUsage();
     }
 }