Use this operation to get SDX network configuration.
16066
public static sdx_network_config get(nitro_service client) throws Exception
	{
		sdx_network_config resource = new sdx_network_config();
		resource.validate("get");
		return ((sdx_network_config[]) resource.get_resources(client))[0];
	}
253240
def get_vlan_allocation(self):
        
        if not self.cli_commands['resource-pool']:
            LOG.warning(_('The version of CVX you are using does not support'
                          'arista VLAN type driver.'))
        else:
            cmd = ['show openstack resource-pools region %s' % self.region]
            command_output = self._run_eos_cmds(cmd)
            if command_output:
                regions = command_output[0]['physicalNetwork']
                if self.region in regions.keys():
                    return regions[self.region]['vlanPool']['default']
        return {'assignedVlans': '',
                'availableVlans': '',
                'allocatedVlans': ''}
1136265
def _provision_network(self, port_id, net_uuid, network_type,
                           physical_network, segmentation_id):
        """"""
        LOG.info("Provisioning network %s", net_uuid)

        vswitch_name = self._get_vswitch_name(network_type, physical_network)
        vswitch_map = {
            'network_type': network_type,
            'vswitch_name': vswitch_name,
            'ports': [],
            'vlan_id': segmentation_id}
        self._network_vswitch_map[net_uuid] = vswitch_map
896943
async def restore_networking_configuration(self):
        
        self._data = await self._handler.restore_networking_configuration(
            system_id=self.system_id)
1043447
def cdn_get_conf(self, cname, environment):
        
        response = self.client.service.cdn_get_conf(cname, environment)
        cdn_config = CotendoCDN(response)
        return cdn_config
813172
def get_network(self, org, segid):
        
        network_info = {
            'organizationName': org,
            'partitionName': self._part_name,
            'segmentId': segid,
        }
        res = self._get_network(network_info)
        if res and res.status_code in self._resp_ok:
            return res.json()
93039
def get_snmp_configuration(self):
        
        uri = "{}{}".format(self.data["uri"], self.SNMP_CONFIGURATION_PATH)
        return self._helper.do_get(uri)
1329058
def get_default_config(self):
        
        config = super(NetworkCollector, self).get_default_config()
        config.update({
            'path':         'network',
            'interfaces':   ['eth', 'bond', 'em', 'p1p', 'eno', 'enp', 'ens',
                             'enx'],
            'byte_unit':    ['bit', 'byte'],
            'greedy':       'true',
        })
        return config
744713
def _getConfiguration(self):
        
        info =configuration.getConfiguration()

        try:            
            # This returns only the parameters needed by each wrapper. E. g., for Tor:
            # {
            #    "host" : "127.0.0.1"
            #    "port" : "9150"
            # }    
            return info[self.name]
            
        except KeyError, e:
            errMsg = "ERROR. WTF! There was not found any configuration for " + self.name + " in the configuration file!"
            raise Exception( errMsg )
814781
def network_interface_tap_configurations(self):
        
        api_version = self._get_api_version('network_interface_tap_configurations')
        if api_version == '2018-08-01':
            from .v2018_08_01.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
        else:
            raise NotImplementedError("APIVersion {} is not available".format(api_version))
        return OperationClass(self._client, self.config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
1078938
def get_configuration(self, uri):
        '''
        
        '''

        req_headers = {
            'Accept': 'application/vnd.onshape.v1+json',
            'Content-Type': 'application/json'
        }
        return self._api.request('get', '/api/partstudios/d/' + uri["did"] + '/' + uri["wvm_type"] + '/' + uri["wvm"] + '/e/' + uri["eid"] + '/configuration', headers=req_headers)
956129
private JSONObject getNodeConfig() {
    JSONObject res = new JSONObject();
    try {
      res.put("class", "org.openqa.grid.common.RegistrationRequest");
      res.put("configuration", getConfiguration());
      JSONArray caps = new JSONArray();
      JSONArray devices = driver.getSupportedDevices();
      for (int i = 0; i < devices.length(); i++) {
        JSONObject device = (JSONObject) devices.get(i);
        for (int x = 0; x < driver.getSupportedApps().length(); x++) {
          caps.put(getDeviceConfig(device, driver.getSupportedApps().getJSONObject(x)));
        }
      }
      res.put("capabilities", caps);
    } catch (JSONException e) {
      throw new SelendroidException(e.getMessage(), e);
    }
    return res;
  }
3052
def _get_connection(self, x, y):
        """"""
        if (self._width is None or self._height is None or
                self._root_chip is None):
            return self.connections[None]
        else:
            # If possible, use the local Ethernet connected chip
            eth_chip = spinn5_local_eth_coord(x, y, self._width, self._height,
                                              *self._root_chip)
            conn = self.connections.get(eth_chip)
            if conn is not None:
                return conn
            else:
                # If no connection was available to the local board, choose
                # another arbitrarily.
                # XXX: This choice will cause lots of contention in systems
                # with many missing Ethernet connections.
                return self.connections[None]
227284
def _ifconfig_getnode():
    """"""

    # This works on Linux ('' or '-a'), Tru64 ('-av'), but not all Unixes.
    for args in ('', '-a', '-av'):
        mac = _find_mac('ifconfig', args, ['hwaddr', 'ether'], lambda i: i+1)
        if mac:
            return mac

    import socket
    ip_addr = socket.gethostbyname(socket.gethostname())

    # Try getting the MAC addr from arp based on our IP address (Solaris).
    mac = _find_mac('arp', '-an', [ip_addr], lambda i: -1)
    if mac:
        return mac

    # This might work on HP-UX.
    mac = _find_mac('lanscan', '-ai', ['lan0'], lambda i: 0)
    if mac:
        return mac

    return None
628248
public static ns_vserver_appflow_config[] get(nitro_service client) throws Exception
	{
		ns_vserver_appflow_config resource = new ns_vserver_appflow_config();
		resource.validate("get");
		return (ns_vserver_appflow_config[]) resource.get_resources(client);
	}
242079
public static mps_network_config get(nitro_service client) throws Exception
	{
		mps_network_config resource = new mps_network_config();
		resource.validate("get");
		return ((mps_network_config[]) resource.get_resources(client))[0];
	}
1140967
def get_default_config(self):
        
        default_config = super(SNMPInterfaceCollector,
                               self).get_default_config()
        default_config['path'] = 'interface'
        default_config['byte_unit'] = ['bit', 'byte']
        return default_config