Method to deploy pool's

        :param pools: Identifiers of pool's desired to be deployed
        :return: Empty Dict
166745
def create(self, ids):
        

        url = build_uri_with_ids('api/v3/pool/deploy/%s/', ids)
        return super(ApiPoolDeploy, self).post(url)
1210979
def mk_pools(things, keyfnc=lambda x: x):
    ""
    pools = {}
    sthings = sorted(things, key=keyfnc)
    for key, thingz in groupby(sthings, key=keyfnc):
        pools.setdefault(key, []).extend(list(thingz))
    return pools
1226823
function (options) {
        poolId++;

        return new Pool(
            options.name ? options.name + ' (pool #' + poolId + ')' : 'pool #' + poolId,
            options.factory,
            options.initialize || noop,
            options.firstAllocationNumber || 20,
            options.allocationNumber || 1
        );
    }
1082723
def deployment_groups(self):
        
        if not self.__deployment_groups:
            self.__deployment_groups = DeploymentGroups(self.__connection)
        return self.__deployment_groups
301394
def create_api_pool_deploy(self):
        """"""
        return ApiPoolDeploy(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
79491
def init_pool(self):
        """"""

        # initialize the pool if needed
        if self.pool is None:
            if self.nproc > 1:
                self.pool = mp.Pool(processes=self.nproc)
            else:
                self.pool = None
        else:
            print('pool already initialized?')
337349
def get_resource_pool(self, cluster, pool_name):
        
        pool_obj = None

        # get a list of all resource pools in this cluster
        cluster_pools_list = cluster.resourcePool.resourcePool

        # get list of all resource pools with a given text name
        pool_selections = self.get_obj(
            [vim.ResourcePool],
            pool_name,
            return_all=True
        )

        # get the first pool that exists in a given cluster
        if pool_selections:
            for p in pool_selections:
                if p in cluster_pools_list:
                    pool_obj = p
                    break

        return pool_obj
50850
def pool(self, host, port, db, pools={}, **options):
        '''
        
        '''
        key = (host, port, db)
        rval = pools.get(key)
        if not isinstance(rval, ConnectionPool):
            rval = ConnectionPool(host=host, port=port, db=db, **options)
            pools[key] = rval

        return rval
146330
def list_resourcepools(kwargs=None, call=None):
    '''
    
    '''
    if call != 'function':
        raise SaltCloudSystemExit(
            'The list_resourcepools function must be called with '
            '-f or --function.'
        )

    return {'Resource Pools': salt.utils.vmware.list_resourcepools(_get_si())}
1164030
def from_dict(cls, parm, pool = None):
        

        if pool is None:
            pool = Pool()

        pool.id = parm['id']
        pool.name = parm['name']
        pool.description = parm['description']
        pool.default_type = parm['default_type']
        pool.ipv4_default_prefix_length = parm['ipv4_default_prefix_length']
        pool.ipv6_default_prefix_length = parm['ipv6_default_prefix_length']
        for val in ('member_prefixes_v4', 'member_prefixes_v6',
                'used_prefixes_v4', 'used_prefixes_v6', 'free_prefixes_v4',
                'free_prefixes_v6', 'total_prefixes_v4', 'total_prefixes_v6',
                'total_addresses_v4', 'total_addresses_v6', 'used_addresses_v4',
                'used_addresses_v6', 'free_addresses_v4', 'free_addresses_v6'):
            if parm[val] is not None:
                setattr(pool, val, int(parm[val]))

        pool.tags = {}
        for tag_name in parm['tags']:
            tag = Tag.from_dict({'name': tag_name })
            pool.tags[tag_name] = tag

        pool.avps = parm['avps']

        # store VRF object in pool.vrf
        if parm['vrf_id'] is not None:
            pool.vrf = VRF.get(parm['vrf_id'])

        return pool
708873
def get(self, name):
        
        if name not in self.pools:
            self.pools[name] = _Pool(logger=self.logger, name=name)
        return self.pools[name].get()
1367554
def create_pool(module, max_conns, *args, **kwargs):
    
    if not hasattr(module, 'threadsafety'):
        raise NotSupported("Cannot determine driver threadsafety.")
    if max_conns < 1:
        raise ValueError("Minimum number of connections is 1.")
    if module.threadsafety >= 2:
        return Pool(module, max_conns, *args, **kwargs)
    if module.threadsafety >= 1:
        return DummyPool(module, *args, **kwargs)
    raise ValueError("Bad threadsafety level: %d" % module.threadsafety)
446569
def get_lbaas_agent_hosting_pool(self, pool, **_params):
        """"""
        return self.get((self.pool_path + self.LOADBALANCER_AGENT) % pool,
                        params=_params)
1121073
def create_pool(*)
      @connection = ConnectionPool.new(@config.size) do
        client = EM.connect_unix_domain(@config.sock, Connection)
        client.on_connect = self.method(:on_connect)
        client.on_disconnect = self.method(:on_disconnect)
        client
      end
    end
936858
def id_pools_vsn_ranges(self):
        
        if not self.__id_pools_vsn_ranges:
            self.__id_pools_vsn_ranges = IdPoolsRanges('vsn', self.__connection)
        return self.__id_pools_vsn_ranges
414826
def _get_pool(self):
        
        if self.pool:
            return self.pool
        if hadoop().pool:
            return hadoop().pool
146688
def id_pools_ipv4_ranges(self):
        
        if not self.__id_pools_ipv4_ranges:
            self.__id_pools_ipv4_ranges = IdPoolsIpv4Ranges(self.__connection)
        return self.__id_pools_ipv4_ranges