Use this API to fetch all the vrid resources that are configured on netscaler.
176426
public static vrid[] get(nitro_service service) throws Exception{
		vrid obj = new vrid();
		vrid[] response = (vrid[])obj.get_resources(service);
		return response;
	}
553162
def getall(self):
        

        vrrps = dict()

        # Find the available interfaces
        interfaces = re.findall(r'^interface\s(\S+)', self.config, re.M)

        # Get the vrrps defined for each interface
        for interface in interfaces:
            vrrp = self.get(interface)
            # Only add those interfaces that have vrrps defined
            if vrrp:
                vrrps.update({interface: vrrp})

        return vrrps
888538
public static nd6ravariables[] get(nitro_service service, Long vlan[]) throws Exception{
		if (vlan !=null && vlan.length>0) {
			nd6ravariables response[] = new nd6ravariables[vlan.length];
			nd6ravariables obj[] = new nd6ravariables[vlan.length];
			for (int i=0;i<vlan.length;i++) {
				obj[i] = new nd6ravariables();
				obj[i].set_vlan(vlan[i]);
				response[i] = (nd6ravariables) obj[i].get_resource(service);
			}
			return response;
		}
		return null;
	}
818658
def get_supported_resources(netid):
    
    url = _netid_supported_url(netid)
    response = get_resource(url)
    return _json_to_supported(response)
884548
def get_all(cls, parent=None, **params):

        if parent is not None:
            route = copy(parent.route)
        else:
            route = {}
        if cls.ID_NAME is not None:
            # Empty string triggers "get all resources"
            route[cls.ID_NAME] = ""

        base_obj = cls(key=parent.key, route=route, config=parent.config)
        """"""

        start = datetime.now()
        r = requests.get(
            base_obj._url(), auth=(base_obj.key, ""), params=params)
        cls._delay_for_ratelimits(start)

        if r.status_code not in cls.TRUTHY_CODES:
            return base_obj._handle_request_exception(r)

        response = r.json()
        objects_data = response.get(base_obj.ENVELOPE or base_obj, [])

        return_objects = []
        for data in objects_data:
            # Note that this approach does not get meta data
            return_objects.append(
                cls.get(
                    parent=parent,
                    id=data.get(cls.ID_NAME, data.get("id")),
                    data=data))

        return return_objects
327771
public static callhome get(nitro_service service) throws Exception{
		callhome obj = new callhome();
		callhome[] response = (callhome[])obj.get_resources(service);
		return response[0];
	}
871522
public VirtualResourcePoolUsage getVRPUsage(String vrpId) throws InvalidState, NotFound, RuntimeFault, RemoteException {
        return getVimService().getVRPUsage(getMOR(), vrpId);
    }
439631
public static base_response add(nitro_service client, vrid resource) throws Exception {
		vrid addresource = new vrid();
		addresource.id = resource.id;
		addresource.priority = resource.priority;
		addresource.preemption = resource.preemption;
		addresource.sharing = resource.sharing;
		addresource.tracking = resource.tracking;
		return addresource.add_resource(client);
	}
413128
def get_resources(self):
        
        json_resources = self.rest_client.make_request(self.resource_url)['resources']
        return [RestResource(resource, self.rest_client) for resource in json_resources]
841187
def _get_dvs_infrastructure_traffic_resources(dvs_name,
                                              dvs_infra_traffic_ress):
    '''
    
    '''
    log.trace('Building the dicts of the DVS \'%s\' infrastructure '
              'traffic resources', dvs_name)
    res_dicts = []
    for res in dvs_infra_traffic_ress:
        res_dict = {'key': res.key,
                    'limit': res.allocationInfo.limit,
                    'reservation': res.allocationInfo.reservation}
        if res.allocationInfo.shares:
            res_dict.update({'num_shares': res.allocationInfo.shares.shares,
                             'share_level': res.allocationInfo.shares.level})
        res_dicts.append(res_dict)
    return res_dicts
460192
public static vrid get(nitro_service service, Long id) throws Exception{
		vrid obj = new vrid();
		obj.set_id(id);
		vrid response = (vrid) obj.get_resource(service);
		return response;
	}
467754
public static br_vm_template[] get(nitro_service client) throws Exception
	{
		br_vm_template resource = new br_vm_template();
		resource.validate("get");
		return (br_vm_template[]) resource.get_resources(client);
	}
323505
public static vpnglobal_vpnurl_binding[] get(nitro_service service) throws Exception{
		vpnglobal_vpnurl_binding obj = new vpnglobal_vpnurl_binding();
		vpnglobal_vpnurl_binding response[] = (vpnglobal_vpnurl_binding[]) obj.get_resources(service);
		return response;
	}
1089210
public java.util.List<VirtualInterface> getVirtualInterfaces() {
        if (virtualInterfaces == null) {
            virtualInterfaces = new com.amazonaws.internal.SdkInternalList<VirtualInterface>();
        }
        return virtualInterfaces;
    }
309488
def get_network_instances(self, name=""):
        

        # command 'show vrf detail' returns all VRFs with detailed information
        # format: list of dictionaries with keys such as 'vrf_name' and 'rd'
        command = "show vrf detail"
        vrf_table_raw = self._get_command_table(command, "TABLE_vrf", "ROW_vrf")

        # command 'show vrf interface' returns all interfaces including their assigned VRF
        # format: list of dictionaries with keys 'if_name', 'vrf_name', 'vrf_id' and 'soo'
        command = "show vrf interface"
        intf_table_raw = self._get_command_table(command, "TABLE_if", "ROW_if")

        # create a dictionary with key = 'vrf_name' and value = list of interfaces
        vrf_intfs = defaultdict(list)
        for intf in intf_table_raw:
            vrf_intfs[intf["vrf_name"]].append(py23_compat.text_type(intf["if_name"]))

        vrfs = {}
        for vrf in vrf_table_raw:
            vrf_name = py23_compat.text_type(vrf.get("vrf_name"))
            vrfs[vrf_name] = {}
            vrfs[vrf_name]["name"] = vrf_name

            # differentiate between VRF type 'DEFAULT_INSTANCE' and 'L3VRF'
            if vrf_name == "default":
                vrfs[vrf_name]["type"] = "DEFAULT_INSTANCE"
            else:
                vrfs[vrf_name]["type"] = "L3VRF"

            vrfs[vrf_name]["state"] = {
                "route_distinguisher": py23_compat.text_type(vrf.get("rd"))
            }

            # convert list of interfaces (vrf_intfs[vrf_name]) to expected format
            # format = dict with key = interface name and empty values
            vrfs[vrf_name]["interfaces"] = {}
            vrfs[vrf_name]["interfaces"]["interface"] = dict.fromkeys(
                vrf_intfs[vrf_name], {}
            )

        # if name of a specific VRF was passed as an argument
        # only return results for this particular VRF
        if name:
            if name in vrfs.keys():
                return {py23_compat.text_type(name): vrfs[name]}
            else:
                return {}
        # else return results for all VRFs
        else:
            return vrfs
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
961602
public static vpnintranetapplication[] get(nitro_service service) throws Exception{
		vpnintranetapplication obj = new vpnintranetapplication();
		vpnintranetapplication[] response = (vpnintranetapplication[])obj.get_resources(service);
		return response;
	}