Use this API to update snmpalarm.
188657
public static base_response update(nitro_service client, snmpalarm resource) throws Exception {
		snmpalarm updateresource = new snmpalarm();
		updateresource.trapname = resource.trapname;
		updateresource.thresholdvalue = resource.thresholdvalue;
		updateresource.normalvalue = resource.normalvalue;
		updateresource.time = resource.time;
		updateresource.state = resource.state;
		updateresource.severity = resource.severity;
		updateresource.logging = resource.logging;
		return updateresource.update_resource(client);
	}
527883
public static base_response update(nitro_service client, nspbr6 resource) throws Exception {
		nspbr6 updateresource = new nspbr6();
		updateresource.name = resource.name;
		updateresource.action = resource.action;
		updateresource.srcipv6 = resource.srcipv6;
		updateresource.srcipop = resource.srcipop;
		updateresource.srcipv6val = resource.srcipv6val;
		updateresource.srcport = resource.srcport;
		updateresource.srcportop = resource.srcportop;
		updateresource.srcportval = resource.srcportval;
		updateresource.destipv6 = resource.destipv6;
		updateresource.destipop = resource.destipop;
		updateresource.destipv6val = resource.destipv6val;
		updateresource.destport = resource.destport;
		updateresource.destportop = resource.destportop;
		updateresource.destportval = resource.destportval;
		updateresource.srcmac = resource.srcmac;
		updateresource.protocol = resource.protocol;
		updateresource.protocolnumber = resource.protocolnumber;
		updateresource.vlan = resource.vlan;
		updateresource.Interface = resource.Interface;
		updateresource.priority = resource.priority;
		updateresource.msr = resource.msr;
		updateresource.monitor = resource.monitor;
		updateresource.nexthop = resource.nexthop;
		updateresource.nexthopval = resource.nexthopval;
		updateresource.nexthopvlan = resource.nexthopvlan;
		return updateresource.update_resource(client);
	}
261173
def updateNetwork(self, data, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id
        return self.client.post(uri, data, headers, query_params, content_type)
667324
def update(self):
        """"""

        from ambry.orm.exc import NotFoundError
        from requests.exceptions import ConnectionError, HTTPError
        from boto.exception import S3ResponseError

        d = {}

        try:
            for k, v in self.list(full=True):
                if not v:
                    continue

                d[v['vid']] = {
                    'vid': v['vid'],
                    'vname': v.get('vname'),
                    'id': v.get('id'),
                    'name': v.get('name')
                }

            self.data['list'] = d
        except (NotFoundError, ConnectionError, S3ResponseError, HTTPError) as e:
            raise RemoteAccessError("Failed to update {}: {}".format(self.short_name, e))
62825
def _update(self, **kwargs):
        """"""
        if 'content' in kwargs:
            content = kwargs.pop('content')
            path = self._construct_path_to_source_content()
            self._http.put(path, json.dumps({'content': content}))
        super(Resource, self)._update(**kwargs)
157568
public static ntp_server update(nitro_service client, ntp_server resource) throws Exception
	{
		resource.validate("modify");
		return ((ntp_server[]) resource.update_resource(client))[0];
	}
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;
	}
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()
819522
def update(self):
        """"""
        # Init new stats
        stats = self.get_init_value()

        if self.input_method == 'local':
            # Update stats using the dedicated lib
            stats = []
            # Get the temperature
            try:
                temperature = self.__set_type(self.glancesgrabsensors.get('temperature_core'),
                                              'temperature_core')
            except Exception as e:
                logger.error("Cannot grab sensors temperatures (%s)" % e)
            else:
                # Append temperature
                stats.extend(temperature)
            # Get the FAN speed
            try:
                fan_speed = self.__set_type(self.glancesgrabsensors.get('fan_speed'),
                                            'fan_speed')
            except Exception as e:
                logger.error("Cannot grab FAN speed (%s)" % e)
            else:
                # Append FAN speed
                stats.extend(fan_speed)
            # Update HDDtemp stats
            try:
                hddtemp = self.__set_type(self.hddtemp_plugin.update(),
                                          'temperature_hdd')
            except Exception as e:
                logger.error("Cannot grab HDD temperature (%s)" % e)
            else:
                # Append HDD temperature
                stats.extend(hddtemp)
            # Update batteries stats
            try:
                batpercent = self.__set_type(self.batpercent_plugin.update(),
                                             'battery')
            except Exception as e:
                logger.error("Cannot grab battery percent (%s)" % e)
            else:
                # Append Batteries %
                stats.extend(batpercent)

        elif self.input_method == 'snmp':
            # Update stats using SNMP
            # No standard:
            # http://www.net-snmp.org/wiki/index.php/Net-SNMP_and_lm-sensors_on_Ubuntu_10.04

            pass

        # Set the alias for each stat
        for stat in stats:
            alias = self.has_alias(stat["label"].lower())
            if alias:
                stat["label"] = alias

        # Update the stats
        self.stats = stats

        return self.stats
337937
public static base_response update(nitro_service client, ntpparam resource) throws Exception {
		ntpparam updateresource = new ntpparam();
		updateresource.authentication = resource.authentication;
		updateresource.trustedkey = resource.trustedkey;
		updateresource.autokeylogsec = resource.autokeylogsec;
		updateresource.revokelogsec = resource.revokelogsec;
		return updateresource.update_resource(client);
	}
506272
def UpdateSNMPObjsAsync():
	

	# UpdateSNMPObjs() will be executed in a separate thread so that the main
	# thread can continue looping and processing SNMP requests while the data
	# update is still in progress. However we'll make sure only one update
	# thread is run at any time, even if the data update interval has been set
	# too low.
	if threading.active_count() == 1:
		LogMsg("Creating thread for UpdateSNMPObjs().")
		t = threading.Thread(target=UpdateSNMPObjs, name="UpdateSNMPObjsThread")
		t.daemon = True
		t.start()
	else:
		LogMsg("Data update still active, data update interval too low?")
851632
public static base_response update(nitro_service client, inatparam resource) throws Exception {
		inatparam updateresource = new inatparam();
		updateresource.nat46v6prefix = resource.nat46v6prefix;
		updateresource.nat46ignoretos = resource.nat46ignoretos;
		updateresource.nat46zerochecksum = resource.nat46zerochecksum;
		updateresource.nat46v6mtu = resource.nat46v6mtu;
		updateresource.nat46fragheader = resource.nat46fragheader;
		return updateresource.update_resource(client);
	}
444403
def update(self, *args, **kwargs):
        """"""
        self._write_op(self._update_nosync, *args, **kwargs)
1271975
public static snmp_user update(nitro_service client, snmp_user resource) throws Exception
	{
		resource.validate("modify");
		return ((snmp_user[]) resource.update_resource(client))[0];
	}
536513
public static base_response update(nitro_service client, nsparam resource) throws Exception {
		nsparam updateresource = new nsparam();
		updateresource.httpport = resource.httpport;
		updateresource.maxconn = resource.maxconn;
		updateresource.maxreq = resource.maxreq;
		updateresource.cip = resource.cip;
		updateresource.cipheader = resource.cipheader;
		updateresource.cookieversion = resource.cookieversion;
		updateresource.securecookie = resource.securecookie;
		updateresource.pmtumin = resource.pmtumin;
		updateresource.pmtutimeout = resource.pmtutimeout;
		updateresource.ftpportrange = resource.ftpportrange;
		updateresource.crportrange = resource.crportrange;
		updateresource.timezone = resource.timezone;
		updateresource.grantquotamaxclient = resource.grantquotamaxclient;
		updateresource.exclusivequotamaxclient = resource.exclusivequotamaxclient;
		updateresource.grantquotaspillover = resource.grantquotaspillover;
		updateresource.exclusivequotaspillover = resource.exclusivequotaspillover;
		updateresource.useproxyport = resource.useproxyport;
		updateresource.internaluserlogin = resource.internaluserlogin;
		updateresource.aftpallowrandomsourceport = resource.aftpallowrandomsourceport;
		updateresource.icaports = resource.icaports;
		return updateresource.update_resource(client);
	}
808455
public static base_responses update(nitro_service client, snmptrap resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			snmptrap updateresources[] = new snmptrap[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new snmptrap();
				updateresources[i].trapclass = resources[i].trapclass;
				updateresources[i].trapdestination = resources[i].trapdestination;
				updateresources[i].destport = resources[i].destport;
				updateresources[i].version = resources[i].version;
				updateresources[i].communityname = resources[i].communityname;
				updateresources[i].srcip = resources[i].srcip;
				updateresources[i].severity = resources[i].severity;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
967583
def update(cls, id, params):
        """"""
        cls.echo('Updating your vlan.')
        result = cls.call('hosting.vlan.update', cls.usable_id(id), params)
        return result