Returns a List of all the PhysicalNetworkFunctionRecords that are contained in a particular
NetworkServiceRecord.

@param idNsr the ID of the NetworkServiceRecord
@return a List of PhysicalNetworkFunctionRecords
@throws SDKException if the request fails
507522
@Help(
    help = "Get all the PhysicalNetworkFunctionRecords of a specific NetworkServiceRecord with id"
  )
  public List<PhysicalNetworkFunctionRecord> getPhysicalNetworkFunctionRecords(final String idNsr)
      throws SDKException {
    String url = idNsr + "/pnfrecords";
    return Arrays.asList(
        (PhysicalNetworkFunctionRecord[]) requestGetAll(url, PhysicalNetworkFunctionRecord.class));
  }
911265
public Annotation getDomainList(int i) {
    if (OntRelationMention_Type.featOkTst && ((OntRelationMention_Type)jcasType).casFeat_domainList == null)
      jcasType.jcas.throwFeatMissing("domainList", "de.julielab.jules.types.OntRelationMention");
    jcasType.jcas.checkArrayBounds(jcasType.ll_cas.ll_getRefValue(addr, ((OntRelationMention_Type)jcasType).casFeatCode_domainList), i);
    return (Annotation)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefArrayValue(jcasType.ll_cas.ll_getRefValue(addr, ((OntRelationMention_Type)jcasType).casFeatCode_domainList), i)));}
296986
public static dnsaddrec[] get(nitro_service service) throws Exception{
		dnsaddrec obj = new dnsaddrec();
		dnsaddrec[] response = (dnsaddrec[])obj.get_resources(service);
		return response;
	}
5465
@Help(
    help =
        "Get all the VirtualNetworkFunctionDescriptor Dependency of a NetworkServiceDescriptor with specific id"
  )
  public List<VNFDependency> getVNFDependencies(final String idNSD) throws SDKException {
    String url = idNSD + "/vnfdependencies";
    return Arrays.asList((VNFDependency[]) requestGetAll(url, VNFDependency.class));
  }
1201115
public DatanodeRegistration getDNRegistrationForNS(int namespaceId) 
  throws IOException {
    NamespaceService nsos = namespaceManager.get(namespaceId);
    if(nsos==null || nsos.getNsRegistration()==null) {
      throw new IOException("cannot find NSOfferService for namespaceId="+namespaceId);
    }
    return nsos.getNsRegistration();
  }
432960
public <T extends RegisteredService> List<T> getDynamicServices(Class<T> serviceInterface) {
        List<T> dynServices = new ArrayList<>();
        if (dynamicServices.containsKey(serviceInterface.getName())) {
            Set<String> deregister = new HashSet<>();
            for (String serviceClassName : dynamicServices.get(serviceInterface.getName())) {
                try {
                    Class<?> clazz = CompiledJavaCache.getClassFromAssetName(null, serviceClassName);
                    if (clazz != null)  {
                        RegisteredService rs = (RegisteredService)(clazz).newInstance();
                        dynServices.add(serviceInterface.cast(rs));
                    }
                } catch (Exception ex) {
                    logger.severeException("Failed to get Dynamic Java service : " + serviceClassName + " (removing from registry)", ex);
                    deregister.add(serviceClassName);
                }
            }
            // avoid repeated attempts to recompile until cache is refreshed
            dynamicServices.get(serviceInterface.getName()).removeAll(deregister);
        }
        return dynServices;
    }
1363764
public static appfwtransactionrecords[] get(nitro_service service) throws Exception{
		appfwtransactionrecords obj = new appfwtransactionrecords();
		appfwtransactionrecords[] response = (appfwtransactionrecords[])obj.get_resources(service);
		return response;
	}
294057
def network_interfaces_list_all(**kwargs):
    '''
    

    '''
    result = {}
    netconn = __utils__['azurearm.get_client']('network', **kwargs)
    try:
        nics = __utils__['azurearm.paged_object_to_list'](netconn.network_interfaces.list_all())

        for nic in nics:
            result[nic['name']] = nic
    except CloudError as exc:
        __utils__['azurearm.log_cloud_error']('network', str(exc), **kwargs)
        result = {'error': str(exc)}

    return result
832993
@Help(help = "Updates a VNFR to a defined VNFD in a running NSR with specific id")
  public void updateVnfr(final String idNsr, final String idVnfr) throws SDKException {
    String url = idNsr + "/vnfrecords" + "/" + idVnfr + "/update";
    requestPost(url);
  }
1082818
private List<ConnectionFuture<StatefulRedisPubSubConnection<String, String>>> potentiallyConnectSentinels() {

        List<ConnectionFuture<StatefulRedisPubSubConnection<String, String>>> connectionFutures = new ArrayList<>();
        for (RedisURI sentinel : sentinels) {

            if (pubSubConnections.containsKey(sentinel)) {
                continue;
            }

            ConnectionFuture<StatefulRedisPubSubConnection<String, String>> future = redisClient.connectPubSubAsync(CODEC,
                    sentinel);
            pubSubConnections.put(sentinel, future);

            future.whenComplete((connection, throwable) -> {

                if (throwable != null || closed) {
                    pubSubConnections.remove(sentinel);
                }

                if (closed) {
                    connection.closeAsync();
                }
            });

            connectionFutures.add(future);
        }

        return connectionFutures;
    }
362582
public Map getNodeSettings(InetAddress addr) {

	IPRangeNode<Map> ipr = this.get(addr);

	if (ipr != null) {

	    Map result = ipr.getData();

	    if (result != null) return result;
	}

	return EMPTY;
    }
1270039
@Trace(dispatcher = true)
	public List<Record> listAll(Long domainId) throws GloboDnsException {
		NewRelic.setTransactionName(null, "/globodns/listRecords");
		if (domainId == null) {
			throw new GloboDnsException("Domain id cannot be null");
		}
		
		GloboDnsRoot<Record> globoDnsRoot = this.get("/domains/" + domainId + "/records.json", true);
		if (globoDnsRoot == null) {
			throw new GloboDnsException("Invalid response");
		}
		return globoDnsRoot.getObjectList();
	}
34565
private List<ConnectionSpecWrapper> getConnectionWrappers() {
        List<ConnectionSpecWrapper> allConnections = DbConfiguration.getConnectionSpecWrappers();
        List<ConnectionSpecWrapper> result = new LinkedList<>();

        for (ConnectionSpecWrapper connectionWrapper : allConnections) {
            if (!connectionWrapper.isTesting() && (dbName == null || dbName.equals(connectionWrapper.getDbName())))
                result.add(connectionWrapper);
        }
        return result;
    }
203008
public static dnsnameserver[] get(nitro_service service) throws Exception{
		dnsnameserver obj = new dnsnameserver();
		dnsnameserver[] response = (dnsnameserver[])obj.get_resources(service);
		return response;
	}
225041
public static List<String> getServerAddrs() {
        Node node = ArbitrateConfigRegistry.getConfig().currentNode();
        if (node != null) {
            String addr = StringUtils.join(node.getParameters().getZkCluster().getServerList(), ',');
            return Arrays.asList(addr);
        } else {
            return new ArrayList<String>();
        }
    }
112641
public static SPSSODescriptor getSPSsoDescriptor(final EntityDescriptor entityDescriptor) {
        LOGGER.trace("Locating SP SSO descriptor for SAML2 protocol...");
        var spssoDescriptor = entityDescriptor.getSPSSODescriptor(SAMLConstants.SAML20P_NS);
        if (spssoDescriptor == null) {
            LOGGER.trace("Locating SP SSO descriptor for SAML11 protocol...");
            spssoDescriptor = entityDescriptor.getSPSSODescriptor(SAMLConstants.SAML11P_NS);
        }
        if (spssoDescriptor == null) {
            LOGGER.trace("Locating SP SSO descriptor for SAML1 protocol...");
            spssoDescriptor = entityDescriptor.getSPSSODescriptor(SAMLConstants.SAML10P_NS);
        }
        LOGGER.trace("SP SSO descriptor resolved to be [{}]", spssoDescriptor);
        return spssoDescriptor;
    }
1359035
public Set<Address> getAddresses(T physicalAddress)
   {
      Set<Address> result = new HashSet<Address>();

      for (Entry<Address, T> entry : nodes.entrySet())
      {
         if (entry.getValue() == null || entry.getValue().equals(physicalAddress))
         {
            result.add(entry.getKey());
         }
      }

      if (trace)
         log.tracef("Addresses: %s", result);

      return Collections.unmodifiableSet(result);
   }