Use this API to update snmpmib.
516018
public static base_response update(nitro_service client, snmpmib resource) throws Exception {
		snmpmib updateresource = new snmpmib();
		updateresource.contact = resource.contact;
		updateresource.name = resource.name;
		updateresource.location = resource.location;
		updateresource.customid = resource.customid;
		return updateresource.update_resource(client);
	}
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);
	}
1205675
public static base_responses update(nitro_service client, snmpalarm resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			snmpalarm updateresources[] = new snmpalarm[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new snmpalarm();
				updateresources[i].trapname = resources[i].trapname;
				updateresources[i].thresholdvalue = resources[i].thresholdvalue;
				updateresources[i].normalvalue = resources[i].normalvalue;
				updateresources[i].time = resources[i].time;
				updateresources[i].state = resources[i].state;
				updateresources[i].severity = resources[i].severity;
				updateresources[i].logging = resources[i].logging;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
516591
def update(connection, silent, hgnc_file_path, hcop_file_path, low_memory):
    """"""
    database.update(connection=connection,
                    silent=silent,
                    hgnc_file_path=hgnc_file_path,
                    hcop_file_path=hcop_file_path,
                    low_memory=low_memory)
778233
def update(self, name=None, algorithm=None, protocol=None, halfClosed=None,
            port=None, timeout=None, httpsRedirect=None):
        
        return self.manager.update(self, name=name, algorithm=algorithm,
                protocol=protocol, halfClosed=halfClosed, port=port,
                timeout=timeout, httpsRedirect=httpsRedirect)
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);
	}
382845
def upgrade_api(request, client, version):
    """"""

    min_ver, max_ver = api_versions._get_server_version_range(client)
    if min_ver <= api_versions.APIVersion(version) <= max_ver:
        client = _nova.novaclient(request, version)
    return client
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
937993
def update(self):
        """"""

        # Grab stats into self.stats
        if self.input_method == 'local':
            stats = self.update_local()
        elif self.input_method == 'snmp':
            stats = self.update_snmp()
        else:
            stats = self.get_init_value()

        # Update the stats
        self.stats = stats

        return self.stats
253320
def update(self, name=None, password=None, host=None):
        
        return self.manager.update(self, name=name, password=password,
                host=host)
11507
public static snmp_manager add(nitro_service client, snmp_manager resource) throws Exception
	{
		resource.validate("add");
		return ((snmp_manager[]) resource.perform_operation(client, "add"))[0];
	}
799037
def update(connection, force_download):
    """"""
    manager.database.update(
        connection=connection,
        force_download=force_download
    )
1006310
def update(self):
        """"""
        # Init new stats
        stats = self.get_init_value()

        if self.input_method == 'local':
            # Update stats using the standard system lib
            # Note: Update is done in the processcount plugin
            # Just return the processes list
            stats = glances_processes.getlist()

        elif self.input_method == 'snmp':
            # No SNMP grab for processes
            pass

        # Update the stats
        self.stats = stats

        # Get the max values (dict)
        # Use Deep copy to avoid change between update and display
        self.max_values = copy.deepcopy(glances_processes.max_values())

        return self.stats
898488
def update(self, update_finished_cb):
        """"""
        if not self._update_finished_cb:
            self._update_finished_cb = update_finished_cb
            self.valid = False
            logger.debug('Updating content of memory {}'.format(self.id))
            # Start reading the header
            self.mem_handler.read(self, 0, 11)
1164714
public static base_response update(nitro_service client, systemparameter resource) throws Exception {
		systemparameter updateresource = new systemparameter();
		updateresource.rbaonresponse = resource.rbaonresponse;
		updateresource.promptstring = resource.promptstring;
		updateresource.natpcbforceflushlimit = resource.natpcbforceflushlimit;
		updateresource.natpcbrstontimeout = resource.natpcbrstontimeout;
		updateresource.timeout = resource.timeout;
		return updateresource.update_resource(client);
	}
444403
def update(self, *args, **kwargs):
        """"""
        self._write_op(self._update_nosync, *args, **kwargs)
814105
def update(self):
        """"""
        if self.client_mode == 'glances':
            return self.update_glances()
        elif self.client_mode == 'snmp':
            return self.update_snmp()
        else:
            self.end()
            logger.critical("Unknown server mode: {}".format(self.client_mode))
            sys.exit(2)