Get servicegroups list

        :return: comma separated list of servicegroups
        :rtype: str
7901
def get_groupnames(self, sgs):
        
        return ','.join([sgs[sg].get_name() for sg in self.servicegroups])
1184398
def list_groups(region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    return [a.name for a in get_all_groups(region=region, key=key, keyid=keyid, profile=profile)]
913359
def get_all_role_config_groups(self):
    
    return role_config_groups.get_all_role_config_groups(
        self._get_resource_root(), self.name, self._get_cluster_name())
349757
def _get_services():
    '''
    
    '''
    serv = []
    services = pyconnman.ConnManager().get_services()
    for path, _ in services:
        serv.append(six.text_type(path[len(SERVICE_PATH):]))
    return serv
295009
def getServiceDependenciesUIDs(self):
        
        deps = self.getServiceDependencies()
        deps_uids = [service.UID() for service in deps]
        return deps_uids
240102
def get_members_of_group(self, gname):
        
        hostgroup = self.find_by_name(gname)
        if hostgroup:
            return hostgroup.get_services()
        return []
1142480
def members(self):
        
        if self._members is None:
            self._members = MemberList(
                self._version,
                service_sid=self._solution['service_sid'],
                channel_sid=self._solution['sid'],
            )
        return self._members
1082723
def deployment_groups(self):
        
        if not self.__deployment_groups:
            self.__deployment_groups = DeploymentGroups(self.__connection)
        return self.__deployment_groups
1315377
def list_resource_groups(call=None):
    '''
    
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The list_hosted_services function must be called with '
            '-f or --function'
        )

    resconn = get_conn(client_type='resource')
    ret = {}
    try:
        groups = resconn.resource_groups.list()

        for group_obj in groups:
            group = group_obj.as_dict()
            ret[group['name']] = group
    except CloudError as exc:
        __utils__['azurearm.log_cloud_error']('resource', exc.message)
        ret = {'Error': exc.message}

    return ret
1151468
def groups(self):
        
        if not self._groups:
            self._groups = ComponentGroups(self.api_client)
        return self._groups
277425
def groups(self):
        
        HiisiHDF._clear_cache()
        self.CACHE['group_paths'].append('/')
        self.visititems(HiisiHDF._is_group)
        return HiisiHDF.CACHE['group_paths']
71752
def _get_groups(self):
        
        if self._groups is None:
            self._groups = _LDAPUserGroups(self)

        return self._groups
768709
def group_list(self, params=None):
        ''' 
        '''
        params = params if params else dict()
        return self.request('/v1/firewall/group_list', params, 'GET')
294951
def _servicegroup_get_server(sg_name, s_name, s_port=None, **connection_args):
    '''
    
    '''
    ret = None
    servers = _servicegroup_get_servers(sg_name, **connection_args)
    if servers is None:
        return None
    for server in servers:
        if server.get_servername() == s_name:
            if s_port is not None and s_port != server.get_port():
                ret = None
            ret = server
    return ret
4081
def list_services(self, namespace=None):
        

        if namespace:
            return [Service(name=s.metadata.name,
                            ports=k8s_ports_to_metadata_ports(s.spec.ports),
                            namespace=s.metadata.namespace,
                            labels=s.metadata.labels, selector=s.spec.selector, spec=s.spec)
                    for s in self.core_api.list_namespaced_service(namespace, watch=False).items]

        return [Service(name=s.metadata.name,
                        ports=k8s_ports_to_metadata_ports(s.spec.ports),
                        namespace=s.metadata.namespace,
                        labels=s.metadata.labels, selector=s.spec.selector, spec=s.spec)
                for s in self.core_api.list_service_for_all_namespaces(watch=False).items]
1095395
def list_services(kwargs=None, conn=None, call=None):
    '''
    
    '''
    if call != 'function':
        raise SaltCloudSystemExit(
            'The list_services function must be called with -f or --function.'
        )

    if not conn:
        conn = get_conn()

    data = conn.list_hosted_services()
    ret = {}
    for item in data.hosted_services:
        ret[item.service_name] = object_to_dict(item)
        ret[item.service_name]['name'] = item.service_name
    return ret
688827
def get_subscribed_services_names(cls):
        
        # This is very inefficient - loops within loops within loops, and
        # many network requests
        # Optimise it?
        accounts_for_service = Account.get_accounts_for_service
        service_data = cls._get_music_services_data().values()
        return [
            service['Name'] for service in service_data
            if len(
                accounts_for_service(service['ServiceType'])
            ) > 0
        ]