Use this API to update dnskey.
432932
public static base_response update(nitro_service client, dnskey resource) throws Exception {
		dnskey updateresource = new dnskey();
		updateresource.keyname = resource.keyname;
		updateresource.expires = resource.expires;
		updateresource.units1 = resource.units1;
		updateresource.notificationperiod = resource.notificationperiod;
		updateresource.units2 = resource.units2;
		updateresource.ttl = resource.ttl;
		return updateresource.update_resource(client);
	}
1154478
public void updateVersion()
    {
        try
        {
            MessageDigest versionDigest = MessageDigest.getInstance("MD5");

            for (Row row : SystemKeyspace.serializedSchema())
            {
                if (invalidSchemaRow(row) || ignoredSchemaRow(row))
                    continue;

                // we want to digest only live columns
                ColumnFamilyStore.removeDeletedColumnsOnly(row.cf, Integer.MAX_VALUE, SecondaryIndexManager.nullUpdater);
                row.cf.purgeTombstones(Integer.MAX_VALUE);
                row.cf.updateDigest(versionDigest);
            }

            version = UUID.nameUUIDFromBytes(versionDigest.digest());
            SystemKeyspace.updateSchemaVersion(version);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
845185
def update(self, mapping):
        """"""
        return self.api.mset(dict((key, self.prepare_value(value))
                                for key, value in mapping.items()))
1117171
private void updateBuddyProperties(BuddyProperties buddyProperties,
            ApiBuddyProperties apiBuddyProperties) {
        apiBuddyProperties.setInited(buddyProperties.isInited());
        apiBuddyProperties.setNickName(buddyProperties.getNickName());
        apiBuddyProperties.setOnline(buddyProperties.isOnline());
        apiBuddyProperties.setState(buddyProperties.getState());
    }
163674
def update(self, async_=False, **kw):
        
        async_ = kw.get('async', async_)
        headers = {'Content-Type': 'application/xml'}

        new_kw = dict()
        if self.offline_model_name:
            upload_keys = ('_parent', 'name', 'offline_model_name', 'offline_model_project', 'qos', 'instance_num')
        else:
            upload_keys = ('_parent', 'name', 'qos', '_model_resource', 'instance_num', 'predictor', 'runtime')

        for k in upload_keys:
            new_kw[k] = getattr(self, k)
        new_kw.update(kw)

        obj = type(self)(version='0', **new_kw)

        data = obj.serialize()
        self._client.put(self.resource(), data, headers=headers)
        self.reload()

        if not async_:
            self.wait_for_service()
1127585
def update(self, *args, **kwargs):
        
        if len(args) > 1:
            raise TypeError("update expected at most 1 arguments, got %d" % len(args))

        for key, value in dict(*args, **kwargs).items():
            self[key] = value
995486
def update(details)
      details.each do |k, v|
        send("#{k}=", v)
      end
      self.class.update(version_key, details)
    end
1222268
def update(options = {})
      response = ProfitBricks.request(
        method: :patch,
        path: "/datacenters/#{datacenterId}/loadbalancers/#{id}",
        expects: 202,
        body: options.to_json
      )
      if response
        self.requestId = response['requestId']
        @properties = @properties.merge(response['properties'])
      end
      self
    end
625172
def _update(self, api_obj):
    """"""
    if not isinstance(self, api_obj.__class__):
      raise ValueError(
          "Class %s does not derive from %s; cannot update attributes." %
          (self.__class__, api_obj.__class__))

    for name in self._get_attributes().keys():
      try:
        val = getattr(api_obj, name)
        setattr(self, name, val)
      except AttributeError, ignored:
        pass
658036
void update()
    {
        mx = x - oldX;
        my = y - oldY;
        oldX = x;
        oldY = y;
    }
876067
def update(self, data):
        
        if not data:
            return
        _rk, _dumps = self.get_key, self._dumps
        data = self._client.mset({
            _rk(key): _dumps(value)
            for key, value in data.items()})
433860
def update(self, key, value=None, dir=False, ttl=None, refresh=False,
               prev_value=None, prev_index=None, timeout=None):
        """"""
        return self.adapter.set(key, value, dir=dir, ttl=ttl, refresh=refresh,
                                prev_value=prev_value, prev_index=prev_index,
                                prev_exist=True, timeout=timeout)
259295
def update(self, **kwargs):
        
        return self.__class__(self.resource.update(kwargs),
                              self.client,
                              wallet=self.wallet)
730341
def update(access_key, resource_policy, is_admin, is_active,  rate_limit):
    '''
    
    '''
    with Session() as session:
        try:
            data = session.KeyPair.update(
                access_key,
                is_active=is_active,
                is_admin=is_admin,
                resource_policy=resource_policy,
                rate_limit=rate_limit)
        except Exception as e:
            print_error(e)
            sys.exit(1)
        if not data['ok']:
            print_fail('KeyPair creation has failed: {0}'.format(data['msg']))
            sys.exit(1)
        print('Key pair is updated: ' + access_key + '.')
882697
def update(self):
        '''
        
        '''
        self._json = self._request(
            method='GET',
            url=self.API
        )._json
1310640
def user_update(object_id, input_params={}, always_retry=False, **kwargs):
    
    return DXHTTPRequest('/%s/update' % object_id, input_params, always_retry=always_retry, **kwargs)
845973
def users_update(self, user_id, **kwargs):
        """"""
        return self.__call_api_post('users.update', userId=user_id, data=kwargs)