List SNS lambda subscriptions.

    Returns:
        list: List of Lambda subscribed SNS ARNs.
320607
def get_sns_subscriptions(app_name, env, region):
    
    session = boto3.Session(profile_name=env, region_name=region)
    sns_client = session.client('sns')

    lambda_alias_arn = get_lambda_alias_arn(app=app_name, account=env, region=region)

    lambda_subscriptions = []
    subscriptions = sns_client.list_subscriptions()

    for subscription in subscriptions['Subscriptions']:
        if subscription['Protocol'] == "lambda" and subscription['Endpoint'] == lambda_alias_arn:
            lambda_subscriptions.append(subscription['SubscriptionArn'])

    if not lambda_subscriptions:
        LOG.debug('SNS subscription for function %s not found', lambda_alias_arn)

    return lambda_subscriptions
4089
def get_service_list(self) -> list:
        
        # Initialising empty list
        services = []

        # Raise an exception if we are not a manager
        if not self._manager:
            raise RuntimeError('Only the Swarm manager node can retrieve'
                               ' all the services.')

        service_list = self._client.services.list()
        for s_list in service_list:
            services.append(s_list.short_id)
        return services
876285
def get_all_subscriptions_by_topic(name, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    cache_key = _subscriptions_cache_key(name)
    try:
        return __context__[cache_key]
    except KeyError:
        pass

    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
    ret = conn.get_all_subscriptions_by_topic(get_arn(name, region, key, keyid, profile))
    __context__[cache_key] = ret['ListSubscriptionsByTopicResponse']['ListSubscriptionsByTopicResult']['Subscriptions']
    return __context__[cache_key]
384567
def get_subscriptions(self):
        
        # Example: {'subscriptions': ['subscriptions/TripDistance~sub', 'subscriptions/FuelRate~sub', ]}
        subscriptions = []
        for uri in self.get_http_client().get("subscriptions").get('subscriptions'):
            subscriptions.append(self.get_subscription(uri.split("/")[-1]))
        return subscriptions
802223
def get_kerberos_subs(netid):
    
    subs = get_netid_subscriptions(netid, Subscription.SUBS_CODE_KERBEROS)
    if subs is not None:
        for subscription in subs:
            if subscription.subscription_code == Subscription.SUBS_CODE_KERBEROS:
                return subscription
    return None
1341170
def list(self):
        """"""
        service = self._service

        lxc_names = service.list_names()
        lxc_list = []
        for name in lxc_names:
            lxc = self.get(name)
            lxc_list.append(lxc)
        return lxc_list
521106
def list(self, subid, params=None):
        ''' 
        '''
        params = update_params(params, {'SUBID': subid})
        return self.request('/v1/server/list_ipv4', params, 'GET')
80700
def list_networks(conn=None, call=None):
    '''
    

    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'The list_networks function must be called with '
            '-f or --function'
        )
    if conn is None:
        conn = get_conn()
    return conn.list_networks()
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
848664
def subscriptions(self):
        """"""
        if _debug: ChangeOfValueServices._debug("subscriptions")

        subscription_list = []

        # loop through the object and detection list
        for obj, cov_detection in self.cov_detections.items():
            for cov in cov_detection.cov_subscriptions:
                subscription_list.append(cov)

        return subscription_list
217518
def list(ctx):
    """"""
    wva = get_wva(ctx)
    for subscription in wva.get_subscriptions():
        print(subscription.short_name)
1280545
def notifications(self):
        
        if self._notifications is None:
            self._notifications = NotificationList(self._version, service_sid=self._solution['sid'], )
        return self._notifications
624975
def list_subnets(self, retrieve_all=True, **_params):
        """"""
        return self.list('subnets', self.subnets_path, retrieve_all,
                         **_params)
192854
def list_subdomains(self, domain, limit=None, offset=None):
        
        return domain.list_subdomains(limit=limit, offset=offset)
496625
function listSubscribers(req, res, next) {
  var listSubscribersParams = {
    _id: req.params.id
  };

  logger.debug("Middleware: listSubscribers: ", {params: listSubscribersParams});

  forms.getNotifications(_.extend(req.connectionOptions, listSubscribersParams), formsResultHandlers(constants.resultTypes.forms, req, next));
}
805619
def list_vmss_sub(access_token, subscription_id):
    '''
    '''
    endpoint = ''.join([get_rm_endpoint(),
                        '/subscriptions/', subscription_id,
                        '/providers/Microsoft.Compute/virtualMachineScaleSets',
                        '?api-version=', COMP_API])
    return do_get_next(endpoint, access_token)
40493
def list(self):
        
        response = self.client._make_request('/accounts')
        response = response.json()
        return self.client._list_response(response)