:class:`~zhmcclient.VirtualStorageResourceManager`: Access to the
        :term:`virtual storage resources <Virtual Storage Resource>` in this
        storage group.
970127
def virtual_storage_resources(self):
        
        # We do here some lazy loading.
        if not self._virtual_storage_resources:
            self._virtual_storage_resources = \
                VirtualStorageResourceManager(self)
        return self._virtual_storage_resources
391323
def monitored_resource_from_local_resource_id(local_resource_id)
      return unless local_resource_id
      if @enable_metadata_agent
        @log.debug 'Calling metadata agent with local_resource_id: ' \
                  "#{local_resource_id}."
        resource = query_metadata_agent_for_monitored_resource(
          local_resource_id)
        @log.debug 'Retrieved monitored resource from metadata agent: ' \
                  "#{resource.inspect}."
        if resource
          # TODO(qingling128): Fix this temporary renaming from 'gke_container'
          # to 'container'.
          resource.type = 'container' if resource.type == 'gke_container'
          return resource
        end
      end
      # Fall back to constructing monitored resource locally.
      # TODO(qingling128): This entire else clause is temporary until we
      # implement buffering and caching.
      @log.debug('Failed to retrieve monitored resource from Metadata' \
                 " Agent with local_resource_id #{local_resource_id}.")
      construct_k8s_resource_locally(local_resource_id)
    end
234
def access_storage_list(**kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('access:storage:list', **{
        'storage': ctx.repo.create_secure_service('storage'),
    })
697544
def get_calendar_resource(self, cal_resource):
        
        selector = cal_resource.to_selector()
        resp = self.request_single('GetCalendarResource',
                                   {'calresource': selector})
        return zobjects.CalendarResource.from_dict(resp)
1335985
def index_resources(self):
        
        if not self.__index_resources:
            self.__index_resources = IndexResources(self.__connection)
        return self.__index_resources
6074
def _configure_manager(self):
        
        self._manager = ScalingGroupManager(self,
                resource_class=ScalingGroup, response_key="group",
                uri_base="groups")
521449
def create_cvmfs_storage_class(cvmfs_volume):
    """"""
    from kubernetes.client.rest import ApiException
    from reana_commons.k8s.api_client import current_k8s_storagev1_api_client

    try:
        current_k8s_storagev1_api_client.\
            create_storage_class(
                render_cvmfs_sc(cvmfs_volume)
            )
    except ApiException as e:
        if e.status != 409:
            raise e
729584
def get_service_resources(cls, model):
        
        key = cls.get_model_key(model)
        return cls.get_service_name_resources(key)
601138
def get_storage(clear=False):
    
    portal = getUtility(ISiteRoot)
    annotations = IAnnotations(portal)
    if ANNOTATION_KEY not in annotations or clear:
        annotations[ANNOTATION_KEY] = OOBTree()
    return annotations[ANNOTATION_KEY]
628822
def virtual_resource(self):
        
        resource = create_collection(
            self.get_relation(
                'virtual_resources',
                UnsupportedEngineFeature),
            VirtualResource)
        resource._load_from_engine(self, 'virtualResources')
        return resource
1162093
static public FileSystemManager getManager(){
		StandardFileSystemManager fsManager = new StandardFileSystemManager();
		try {
			fsManager.init();
		} catch (FileSystemException e) {
			log.error("Cannot initialize StandardFileSystemManager.", e);
		}
		return fsManager;
	}
177544
def resources(self):
        

        if self._resources_objects is not None:
            return self._resources_objects

        resources = self.parent.parent.resources
        resources = [resources[name] for name in self._resources]
        self._resources_objects = resources
        return resources
551438
def get_provider(self):
        
        if 'providerId' not in self._my_map or not self._my_map['providerId']:
            raise errors.IllegalState('this sourceable object has no provider set')
        mgr = self._get_provider_manager('RESOURCE')
        lookup_session = mgr.get_resource_lookup_session()  # What about the Proxy?
        lookup_session.use_federated_bin_view()
        return lookup_session.get_resource(self.get_provider_id())
10260
def register_resources(klass, registry, resource_class):
        
        services = {'acm-certificate', 'directconnect', 'dms-instance', 'directory', 'ec2',
                    'dynamodb-table', 'cache-cluster', 'efs', 'app-elb', 'elb', 'emr', 'rds',
                    'storage-gateway'}
        if resource_class.type in services:
            resource_class.filter_registry.register('health-event', klass)
806145
def _get_vsan_datastore(si, cluster_name):
    ''''''

    log.trace('Retrieving vsan datastore')
    vsan_datastores = [ds for ds in
                       __salt__['vsphere.list_datastores_via_proxy'](
                           service_instance=si)
                       if ds['type'] == 'vsan']

    if not vsan_datastores:
        raise salt.exceptions.VMwareObjectRetrievalError(
            'No vSAN datastores where retrieved for cluster '
            '\'{0}\''.format(cluster_name))
    return vsan_datastores[0]
697900
def initialize_resources_class_accessors! #:nodoc:
        # First priority is the namespaced model, e.g. User::Group
        self.resource_class ||= begin
          namespaced_class = self.name.sub(/Controller$/, '').singularize
          namespaced_class.constantize
        rescue NameError
          nil
        end

        # Second priority is the top namespace model, e.g. EngineName::Article for EngineName::Admin::ArticlesController
        self.resource_class ||= begin
          namespaced_classes = self.name.sub(/Controller$/, '').split('::')
          namespaced_class = [namespaced_classes.first, namespaced_classes.last].join('::').singularize
          namespaced_class.constantize
        rescue NameError
          nil
        end

        # Third priority the camelcased c, i.e. UserGroup
        self.resource_class ||= begin
          camelcased_class = self.name.sub(/Controller$/, '').gsub('::', '').singularize
          camelcased_class.constantize
        rescue NameError
          nil
        end

        # Otherwise use the Group class, or fail
        self.resource_class ||= begin
          class_name = self.controller_name.classify
          class_name.constantize
        rescue NameError => e
          raise unless e.message.include?(class_name)
          nil
        end

        self.parents_symbols = self.parents_symbols.try(:dup) || []

        # Initialize resources configuration hash
        self.resources_configuration = self.resources_configuration.try(:dup) || {}
        self.resources_configuration.each do |key, value|
          next unless value.is_a?(Hash) || value.is_a?(Array)
          self.resources_configuration[key] = value.dup
        end

        config = (self.resources_configuration[:self] ||= {})
        config[:collection_name] = self.controller_name.to_sym
        config[:instance_name]   = self.controller_name.singularize.to_sym

        config[:route_collection_name] = config[:collection_name]
        config[:route_instance_name]   = config[:instance_name]

        # Deal with namespaced controllers
        namespaces = self.controller_path.split('/')[0..-2]

        # Remove namespace if its a mountable engine
        namespaces.delete_if do |namespace|
          begin
            "#{namespace}/engine".camelize.constantize.isolated?
          rescue StandardError, LoadError
            false
          end
        end

        config[:route_prefix] = namespaces.join('_') unless namespaces.empty?

        # Deal with default request parameters in namespaced controllers, e.g.
        # Forum::Thread#create will properly pick up the request parameter
        # which will be forum_thread, and not thread
        # Additionally make this work orthogonally with instance_name
        config[:request_name] = self.resource_class.to_s.underscore.gsub('/', '_')

        # Initialize polymorphic, singleton, scopes and belongs_to parameters
        polymorphic = self.resources_configuration[:polymorphic] || { symbols: [], optional: false }
        polymorphic[:symbols] = polymorphic[:symbols].dup
        self.resources_configuration[:polymorphic] = polymorphic
      end
1253660
def instance(cls) -> 'MiddlewareManager':
        

        if cls._instance is None:
            cls._instance = cls()
            cls._instance.init()
        return cls._instance