Use this API to update vrid resources.
542750
public static base_responses update(nitro_service client, vrid resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vrid updateresources[] = new vrid[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new vrid();
				updateresources[i].id = resources[i].id;
				updateresources[i].priority = resources[i].priority;
				updateresources[i].preemption = resources[i].preemption;
				updateresources[i].sharing = resources[i].sharing;
				updateresources[i].tracking = resources[i].tracking;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1119323
def update(cls, id, memory, cores, console, password, background,
               max_memory):
        """"""
        if not background and not cls.intty():
            background = True

        vm_params = {}

        if memory:
            vm_params['memory'] = memory

        if cores:
            vm_params['cores'] = cores

        if console:
            vm_params['console'] = console

        if password:
            vm_params['password'] = password

        if max_memory:
            vm_params['vm_max_memory'] = max_memory

        result = cls.call('hosting.vm.update', cls.usable_id(id), vm_params)
        if background:
            return result

        # interactive mode, run a progress bar
        cls.echo('Updating your Virtual Machine %s.' % id)
        cls.display_progress(result)
594781
def update_line(self, resource_id, data):
        """"""
        return OrderLines(self.client).on(self).update(resource_id, data)
971883
public static base_responses update(nitro_service client, vpnsessionaction resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			vpnsessionaction updateresources[] = new vpnsessionaction[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new vpnsessionaction();
				updateresources[i].name = resources[i].name;
				updateresources[i].httpport = resources[i].httpport;
				updateresources[i].winsip = resources[i].winsip;
				updateresources[i].dnsvservername = resources[i].dnsvservername;
				updateresources[i].splitdns = resources[i].splitdns;
				updateresources[i].sesstimeout = resources[i].sesstimeout;
				updateresources[i].clientsecurity = resources[i].clientsecurity;
				updateresources[i].clientsecuritygroup = resources[i].clientsecuritygroup;
				updateresources[i].clientsecuritymessage = resources[i].clientsecuritymessage;
				updateresources[i].clientsecuritylog = resources[i].clientsecuritylog;
				updateresources[i].splittunnel = resources[i].splittunnel;
				updateresources[i].locallanaccess = resources[i].locallanaccess;
				updateresources[i].rfc1918 = resources[i].rfc1918;
				updateresources[i].spoofiip = resources[i].spoofiip;
				updateresources[i].killconnections = resources[i].killconnections;
				updateresources[i].transparentinterception = resources[i].transparentinterception;
				updateresources[i].windowsclienttype = resources[i].windowsclienttype;
				updateresources[i].defaultauthorizationaction = resources[i].defaultauthorizationaction;
				updateresources[i].authorizationgroup = resources[i].authorizationgroup;
				updateresources[i].clientidletimeout = resources[i].clientidletimeout;
				updateresources[i].proxy = resources[i].proxy;
				updateresources[i].allprotocolproxy = resources[i].allprotocolproxy;
				updateresources[i].httpproxy = resources[i].httpproxy;
				updateresources[i].ftpproxy = resources[i].ftpproxy;
				updateresources[i].socksproxy = resources[i].socksproxy;
				updateresources[i].gopherproxy = resources[i].gopherproxy;
				updateresources[i].sslproxy = resources[i].sslproxy;
				updateresources[i].proxyexception = resources[i].proxyexception;
				updateresources[i].proxylocalbypass = resources[i].proxylocalbypass;
				updateresources[i].clientcleanupprompt = resources[i].clientcleanupprompt;
				updateresources[i].forcecleanup = resources[i].forcecleanup;
				updateresources[i].clientoptions = resources[i].clientoptions;
				updateresources[i].clientconfiguration = resources[i].clientconfiguration;
				updateresources[i].sso = resources[i].sso;
				updateresources[i].ssocredential = resources[i].ssocredential;
				updateresources[i].windowsautologon = resources[i].windowsautologon;
				updateresources[i].usemip = resources[i].usemip;
				updateresources[i].useiip = resources[i].useiip;
				updateresources[i].clientdebug = resources[i].clientdebug;
				updateresources[i].loginscript = resources[i].loginscript;
				updateresources[i].logoutscript = resources[i].logoutscript;
				updateresources[i].homepage = resources[i].homepage;
				updateresources[i].icaproxy = resources[i].icaproxy;
				updateresources[i].wihome = resources[i].wihome;
				updateresources[i].citrixreceiverhome = resources[i].citrixreceiverhome;
				updateresources[i].wiportalmode = resources[i].wiportalmode;
				updateresources[i].clientchoices = resources[i].clientchoices;
				updateresources[i].epaclienttype = resources[i].epaclienttype;
				updateresources[i].iipdnssuffix = resources[i].iipdnssuffix;
				updateresources[i].forcedtimeout = resources[i].forcedtimeout;
				updateresources[i].forcedtimeoutwarning = resources[i].forcedtimeoutwarning;
				updateresources[i].ntdomain = resources[i].ntdomain;
				updateresources[i].clientlessvpnmode = resources[i].clientlessvpnmode;
				updateresources[i].emailhome = resources[i].emailhome;
				updateresources[i].clientlessmodeurlencoding = resources[i].clientlessmodeurlencoding;
				updateresources[i].clientlesspersistentcookie = resources[i].clientlesspersistentcookie;
				updateresources[i].allowedlogingroups = resources[i].allowedlogingroups;
				updateresources[i].securebrowse = resources[i].securebrowse;
				updateresources[i].storefronturl = resources[i].storefronturl;
				updateresources[i].kcdaccount = resources[i].kcdaccount;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
404992
def update_resources(self, cpu, gpu, **kwargs):
        
        if self.status is Trial.RUNNING:
            raise ValueError("Cannot update resources while Trial is running.")
        self.resources = Resources(cpu, gpu, **kwargs)
312104
def _update(self, resource, update_dict=None, params=None, **kwargs):
        """"""
        url = self._client._build_url(resource, **kwargs)
        response = self._client._request('PUT', url, json=update_dict, params=params)

        if response.status_code != requests.codes.ok:  # pragma: no cover
            raise APIError("Could not update {} ({})".format(self.__class__.__name__, response.json().get('results')))
        else:
            self.refresh()
153821
def add_vrf(self):
        

        v = VRF()
        if 'rt' in request.json:
            v.rt = validate_string(request.json, 'rt')
        if 'name' in request.json:
            v.name = validate_string(request.json, 'name')
        if 'description' in request.json:
            v.description = validate_string(request.json, 'description')
        if 'tags' in request.json:
            v.tags = request.json['tags']
        if 'avps' in request.json:
            v.avps = request.json['avps']

        try:
            v.save()
        except NipapError, e:
            return json.dumps({'error': 1, 'message': e.args, 'type': type(e).__name__})

        return json.dumps(v, cls=NipapJSONEncoder)
1041922
public static base_responses update(nitro_service client, snmpengineid resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			snmpengineid updateresources[] = new snmpengineid[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new snmpengineid();
				updateresources[i].engineid = resources[i].engineid;
				updateresources[i].ownernode = resources[i].ownernode;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1044448
public void updateServiceInstanceUri(String serviceName, String instanceId, String uri){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UpdateServiceInstanceUri);

        UpdateServiceInstanceUriProtocol p = new UpdateServiceInstanceUriProtocol(serviceName, instanceId, uri);
        connection.submitRequest(header, p, null);
    }
906836
def update(self, resource, id_, updates):
        """"""
        args = self._es_args(resource, refresh=True)
        if self._get_retry_on_conflict():
            args['retry_on_conflict'] = self._get_retry_on_conflict()

        updates.pop('_id', None)
        updates.pop('_type', None)
        self._update_parent_args(resource, args, updates)
        return self.elastic(resource).update(id=id_, body={'doc': updates}, **args)
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);
	}
967583
def update(cls, id, params):
        """"""
        cls.echo('Updating your vlan.')
        result = cls.call('hosting.vlan.update', cls.usable_id(id), params)
        return result
542219
public static vrid6[] get(nitro_service service) throws Exception{
		vrid6 obj = new vrid6();
		vrid6[] response = (vrid6[])obj.get_resources(service);
		return response;
	}
464081
def update(self, resource, rid, updates):
        
        if resource[-1] != '/':
            resource += '/'
        resource += str(rid)
        return self.put(resource, data=updates)
771840
def add_current_vrf(self):
        

        vrf_id = request.json['vrf_id']

        if vrf_id is not None:

            if vrf_id == 'null':
                vrf = VRF()
            else:
                vrf_id = int(vrf_id)
                vrf = VRF.get(vrf_id)

            session['current_vrfs'][vrf_id] = { 'id': vrf.id, 'rt': vrf.rt,
                    'name': vrf.name, 'description': vrf.description }
            session.save()

        return json.dumps(session.get('current_vrfs', {}))
1101326
public static base_response update(nitro_service client, vpnvserver resource) throws Exception {
		vpnvserver updateresource = new vpnvserver();
		updateresource.name = resource.name;
		updateresource.ipv46 = resource.ipv46;
		updateresource.authentication = resource.authentication;
		updateresource.doublehop = resource.doublehop;
		updateresource.icaonly = resource.icaonly;
		updateresource.maxaaausers = resource.maxaaausers;
		updateresource.downstateflush = resource.downstateflush;
		updateresource.listenpolicy = resource.listenpolicy;
		updateresource.listenpriority = resource.listenpriority;
		updateresource.tcpprofilename = resource.tcpprofilename;
		updateresource.httpprofilename = resource.httpprofilename;
		updateresource.comment = resource.comment;
		updateresource.appflowlog = resource.appflowlog;
		updateresource.icmpvsrresponse = resource.icmpvsrresponse;
		updateresource.netprofile = resource.netprofile;
		updateresource.cginfrahomepageredirect = resource.cginfrahomepageredirect;
		updateresource.maxloginattempts = resource.maxloginattempts;
		updateresource.failedlogintimeout = resource.failedlogintimeout;
		return updateresource.update_resource(client);
	}
534102
def update(self, device_json=None, info_json=None, settings_json=None,
               avatar_json=None):
        """"""
        if device_json:
            UTILS.update(self._device_json, device_json)

        if avatar_json:
            UTILS.update(self._avatar_json, avatar_json)

        if info_json:
            UTILS.update(self._info_json, info_json)

        if settings_json:
            UTILS.update(self._settings_json, settings_json)