Use this API to update snmpengineid.
16441
public static base_response update(nitro_service client, snmpengineid resource) throws Exception {
		snmpengineid updateresource = new snmpengineid();
		updateresource.engineid = resource.engineid;
		updateresource.ownernode = resource.ownernode;
		return updateresource.update_resource(client);
	}
73533
def put(self):
        """"""
        cred_payload = utils.uni_to_str(json.loads(request.get_data()))
        return self.manager.update_credential(cred_payload)
1036498
def update(self):
        """"""
        # Init new stats
        stats = self.get_init_value()

        if self.input_method == 'local':
            # Update stats using the standard system lib
            # Here, update is call for processcount AND processlist
            glances_processes.update()

            # Return the processes count
            stats = glances_processes.getcount()
        elif self.input_method == 'snmp':
            # Update stats using SNMP
            # Not avalaible
            pass

        # Update the stats
        self.stats = stats

        return self.stats
473089
def update(self, ip):
        """"""
        timeout = 60
        LOG.debug("Updating '%s' to '%s' at service '%s'", self.hostname, ip, self._updateurl)
        params = {"domains": self.hostname.partition(".")[0], "token": self.__token}
        if ip is None:
            params["ip"] = ""
        else:
            params["ip"] = ip
        # LOG.debug("Update params: %r", params)
        req = requests.get(self._updateurl, params=params, headers=constants.REQUEST_HEADERS_DEFAULT,
                           timeout=timeout)
        LOG.debug("status %i, %s", req.status_code, req.text)
        # duckdns response codes seem undocumented...
        if req.status_code == 200:
            if req.text.startswith("OK"):
                return ip
            return req.text
        return "invalid http status code: %s" % req.status_code
1227066
public static base_response update(nitro_service client, snmpgroup resource) throws Exception {
		snmpgroup updateresource = new snmpgroup();
		updateresource.name = resource.name;
		updateresource.securitylevel = resource.securitylevel;
		updateresource.readviewname = resource.readviewname;
		return updateresource.update_resource(client);
	}
164027
public static base_response update(nitro_service client, snmptrap resource) throws Exception {
		snmptrap updateresource = new snmptrap();
		updateresource.trapclass = resource.trapclass;
		updateresource.trapdestination = resource.trapdestination;
		updateresource.destport = resource.destport;
		updateresource.version = resource.version;
		updateresource.communityname = resource.communityname;
		updateresource.srcip = resource.srcip;
		updateresource.severity = resource.severity;
		return updateresource.update_resource(client);
	}
203121
def update(self, typ, id, **kwargs):
        
        return self._load(self._request(typ, id=id, method='PUT', data=kwargs))
295482
def update(self):
        """"""
        # For each plugins, call the update method
        for p in self._plugins:
            if self._plugins[p].is_disable():
                # If current plugin is disable
                # then continue to next plugin
                continue

            # Set the input method to SNMP
            self._plugins[p].input_method = 'snmp'
            self._plugins[p].short_system_name = self.system_name

            # Update the stats...
            try:
                self._plugins[p].update()
            except Exception as e:
                logger.error("Update {} failed: {}".format(p, e))
            else:
                # ... the history
                self._plugins[p].update_stats_history()
                # ... and the views
                self._plugins[p].update_views()
426963
public static base_response update(nitro_service client, ipv6 resource) throws Exception {
		ipv6 updateresource = new ipv6();
		updateresource.ralearning = resource.ralearning;
		updateresource.routerredirection = resource.routerredirection;
		updateresource.ndbasereachtime = resource.ndbasereachtime;
		updateresource.ndretransmissiontime = resource.ndretransmissiontime;
		updateresource.natprefix = resource.natprefix;
		updateresource.dodad = resource.dodad;
		return updateresource.update_resource(client);
	}
875788
public static base_response update(nitro_service client, nsdiameter resource) throws Exception {
		nsdiameter updateresource = new nsdiameter();
		updateresource.identity = resource.identity;
		updateresource.realm = resource.realm;
		updateresource.serverclosepropagation = resource.serverclosepropagation;
		return updateresource.update_resource(client);
	}
1083738
public static base_response update(nitro_service client, snmpmanager resource) throws Exception {
		snmpmanager updateresource = new snmpmanager();
		updateresource.ipaddress = resource.ipaddress;
		updateresource.netmask = resource.netmask;
		updateresource.domainresolveretry = resource.domainresolveretry;
		return updateresource.update_resource(client);
	}
1010588
def _registry_update(s, oldid):
        '''
        
        '''
        with _lock:
            sock_queue = ApplicationLayer._to_app.pop(oldid)
            ApplicationLayer._to_app[s._sockid()] = sock_queue
828762
def update(self, **kwargs):
        """"""
        url_str = self.base_url + '/%s' % kwargs['alarm_id']
        del kwargs['alarm_id']

        resp = self.client.create(url=url_str,
                                  method='PUT',
                                  json=kwargs)

        return resp
554729
def update(self):
        """"""
        # Init new stats
        stats = self.get_init_value()

        # Grab per-CPU stats using psutil's cpu_percent(percpu=True) and
        # cpu_times_percent(percpu=True) methods
        if self.input_method == 'local':
            stats = cpu_percent.get(percpu=True)
        else:
            # Update stats using SNMP
            pass

        # Update the stats
        self.stats = stats

        return self.stats
905229
def update(self, ipv4s):
        

        data = {'ips': ipv4s}
        ipv4s_ids = [str(ipv4.get('id')) for ipv4 in ipv4s]

        return super(ApiIPv4, self).put('api/v3/ipv4/%s/' %
                                        ';'.join(ipv4s_ids), data)
187230
public void updateServiceInstance(ProvidedServiceInstance instance){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UpdateServiceInstance);

        UpdateServiceInstanceProtocol p = new UpdateServiceInstanceProtocol(instance);
        connection.submitRequest(header, p, null);
    }
1068406
def update_dme(username, password, dme_id, ip_address):
    
    dme_url = 'https://www.dnsmadeeasy.com/servlet/updateip'
    dme_url += '?username=%s&password=%s&id=%s&ip=%s'
    s = urllib2.urlopen(dme_url % (username, password, dme_id, ip_address))
    return s.read()