Get ScaleIO StoragePool object by its name
        :param name: Name of StoragePool
        :return: ScaleIO StoragePool object
        :raise KeyError: No StoragePool with specified name found
        :rtype: StoragePool object
173444
def get_storage_pool_by_name(self, name):
        
        for storage_pool in self.conn.storage_pools:
            if storage_pool.name == name:
                return storage_pool
        raise KeyError("Storage pool of that name not found")
605022
def container_by_name(self, name):
        
        if not name:
            return None

        # docker prepends a '/' to container names in the container dict
        name = '/'+name
        return next((container for container in self.containers(all=True)
                     if name in container['Names']), None)
301233
def getDatasetByName(self, name):
        
        if name not in self._datasetNameMap:
            raise exceptions.DatasetNameNotFoundException(name)
        return self._datasetNameMap[name]
1076818
def get_cube(self, name):
        
        return Cube(self.get_engine(), name, self.get_cube_model(name))
1208728
def get_database(self, name):
        
        try:
            return [db for db in self.list_databases()
                    if db.name == name][0]
        except IndexError:
            raise exc.NoSuchDatabase("No database by the name '%s' exists." %
                    name)
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
1286502
def get_server(self, name):
        
        mech = self.get(name)
        return mech if isinstance(mech, ServerMechanism) else None
369857
def get(self, name):
        ""
        for bucket in self:
            for k,v in self[bucket].items():
                if k == name:
                    return v
459730
def get_by_name(self, name):
        
        managed_sans = self.get_all()
        result = [x for x in managed_sans if x['name'] == name]

        resource = result[0] if result else None
        if resource:
            resource = self.new(self._connection, resource)

        return resource
1310376
def get_by_name(self, name): # pylint: disable=invalid-name,redefined-builtin
        
        rs, _ = self.list(filter=field('name').eq(name), limit=1)
        if len(rs) is 0:
            raise CDRouterError('no such device')
        return rs[0]
468941
def find_volume(self, name):
        
        try:
            return Volume(self.virsp.storageVolLookupByName(name), self)
        except libvirtError:
            return None
81198
public static autoscaleaction get(nitro_service service, String name) throws Exception{
		autoscaleaction obj = new autoscaleaction();
		obj.set_name(name);
		autoscaleaction response = (autoscaleaction) obj.get_resource(service);
		return response;
	}
804473
def get(self, name, default=None, cache=False):
        
        if cache == True:
            for pane in self.cache:
                if pane.name == name:
                    return pane
            return default
        for pane in self:
            if pane.name == name:
                return pane
        return default
61025
def get(self, path, name):
        
        container = self.get_container(path)
        try:
            return container._values[name]
        except KeyError:
            raise KeyError()
318297
def _get_pool(name=None, session=None):
    '''
    
    '''
    if session is None:
        session = _get_session()
    pools = session.xenapi.pool.get_all()
    for pool in pools:
        pool_record = session.xenapi.pool.get_record(pool)
        if name in pool_record.get('name_label'):
            return pool
    return None
605395
def get_by_name(self, name):
        
        result = self.get_by("name", name)

        if result:
            data = result[0]
            new_resource = self.new(self._connection, data)
        else:
            new_resource = None

        return new_resource
1160858
def _storage_get_key_names(bucket, pattern):
  
  return [item.metadata.name for item in _storage_get_keys(bucket, pattern)]