Use this API to fetch all the callhome resources that are configured on netscaler.
327771
public static callhome get(nitro_service service) throws Exception{
		callhome obj = new callhome();
		callhome[] response = (callhome[])obj.get_resources(service);
		return response[0];
	}
262981
public ServiceFuture<List<Domain>> getDomainsAsync(final ServiceCallback<List<Domain>> serviceCallback) {
        return ServiceFuture.fromResponse(getDomainsWithServiceResponseAsync(), serviceCallback);
    }
1235263
def calls(self):
        
        if self._calls is None:
            self._calls = AuthTypeCallsList(
                self._version,
                account_sid=self._solution['account_sid'],
                domain_sid=self._solution['domain_sid'],
            )
        return self._calls
1111074
public static vpntrafficpolicy[] get(nitro_service service) throws Exception{
		vpntrafficpolicy obj = new vpntrafficpolicy();
		vpntrafficpolicy[] response = (vpntrafficpolicy[])obj.get_resources(service);
		return response;
	}
427397
def get_resources(cls):
        """"""
        exts = []
        parent = dict(member_name="agent",
                      collection_name="agents")
        controller = resource.Resource(HostingDeviceSchedulerController(),
                                       cb_faults.FAULT_MAP)
        exts.append(extensions.ResourceExtension(CFG_AGENT_HOSTING_DEVICES,
                                                 controller, parent))
        parent = dict(member_name=ciscohostingdevicemanager.DEVICE,
                      collection_name=ciscohostingdevicemanager.DEVICES)
        controller = resource.Resource(
            CfgAgentsHandlingHostingDeviceController(), cb_faults.FAULT_MAP)
        exts.append(extensions.ResourceExtension(HOSTING_DEVICE_CFG_AGENTS,
                                                 controller, parent,
                                                 PATH_PREFIX))
        return exts
846960
def get_all_hosts(resource_root, view=None):
  
  return call(resource_root.get, HOSTS_PATH, ApiHost, True,
          params=view and dict(view=view) or None)
220339
def get(cls, parent=None):
        
        data = cls._process_request(connection.get, parent=parent)
        return cls._load_resources(data)
26725
def get_resources(cls):
        """"""
        exts = []
        parent = dict(member_name=ciscohostingdevicemanager.DEVICE,
                      collection_name=ciscohostingdevicemanager.DEVICES)
        controller = resource.Resource(
            RouterHostingDeviceSchedulerController(), cb_faults.FAULT_MAP)
        exts.append(extensions.ResourceExtension(
            DEVICE_L3_ROUTERS, controller, parent, path_prefix="/dev_mgr"))
        parent = dict(member_name="router",
                      collection_name=l3_const.ROUTERS)
        controller = resource.Resource(
            HostingDevicesHostingRouterController(), cb_faults.FAULT_MAP)
        exts.append(extensions.ResourceExtension(L3_ROUTER_DEVICES, controller,
                                                 parent))
        return exts
177544
def resources(self):
        

        if self._resources_objects is not None:
            return self._resources_objects

        resources = self.parent.parent.resources
        resources = [resources[name] for name in self._resources]
        self._resources_objects = resources
        return resources
375690
public static service[] get(nitro_service service, options option) throws Exception{
		service obj = new service();
		service[] response = (service[])obj.get_resources(service,option);
		return response;
	}
954525
def get_addresses(self, fetch=False):
        """"""
        return Addresses(self.resource.addresses, self.client, populate=fetch)
593664
def fetch_platform_informations(self, callback):
        

        self._protocolVersion = -1
        self._callback = callback

        self._request_protocol_version()
482724
def get_resource_operations(cls):
        ''''''
        operations = []
        for http, callback in cls.implemented_methods.items():
            # Parse docstring
            summary, notes = utils.parse_docstring(callback)
            # Parse return annotations
            responses = utils.parse_return_annotation(callback)
            ok_result_model = responses[200]['responseModel']
            operations.append({
                'method': http,
                'nickname': callback.__name__,
                'type': ok_result_model,
                'parameters': cls.parse_signature(callback),
                'summary': summary.strip(),
                'notes': notes.strip(),
                'responseMessages': list(responses.values())
            })
        return operations
732222
public static snmpalarm[] get(nitro_service service) throws Exception{
		snmpalarm obj = new snmpalarm();
		snmpalarm[] response = (snmpalarm[])obj.get_resources(service);
		return response;
	}
422177
public static ns_vlan[] get(nitro_service client) throws Exception
	{
		ns_vlan resource = new ns_vlan();
		resource.validate("get");
		return (ns_vlan[]) resource.get_resources(client);
	}
9748
public static ip6tunnel[] get(nitro_service service) throws Exception{
		ip6tunnel obj = new ip6tunnel();
		ip6tunnel[] response = (ip6tunnel[])obj.get_resources(service);
		return response;
	}
779750
function getResourceNames() {
        var resourceNames = {};
        var resourcesDir = this.injector.rootDir + '/' + this.injector.servicesDir + '/resources';

        if (!fs.existsSync(path.normalize(resourcesDir))) {
            return resourceNames;
        }

        var names = fs.readdirSync(path.normalize(resourcesDir));
        _.each(names, function (name) {
            if (name.substring(name.length - 3) !== '.js') {  // only dirs, not js files
                resourceNames[utils.getPascalCase(name)] = utils.getCamelCase(name);
            }
        });

        return resourceNames;
    }