Use this API to update dnsparameter.
183397
public static base_response update(nitro_service client, dnsparameter resource) throws Exception {
		dnsparameter updateresource = new dnsparameter();
		updateresource.retries = resource.retries;
		updateresource.minttl = resource.minttl;
		updateresource.maxttl = resource.maxttl;
		updateresource.cacherecords = resource.cacherecords;
		updateresource.namelookuppriority = resource.namelookuppriority;
		updateresource.recursion = resource.recursion;
		updateresource.resolutionorder = resource.resolutionorder;
		updateresource.dnssec = resource.dnssec;
		updateresource.maxpipeline = resource.maxpipeline;
		updateresource.dnsrootreferral = resource.dnsrootreferral;
		updateresource.dns64timeout = resource.dns64timeout;
		return updateresource.update_resource(client);
	}
732663
public static base_responses update(nitro_service client, dnsmxrec resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			dnsmxrec updateresources[] = new dnsmxrec[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new dnsmxrec();
				updateresources[i].domain = resources[i].domain;
				updateresources[i].mx = resources[i].mx;
				updateresources[i].pref = resources[i].pref;
				updateresources[i].ttl = resources[i].ttl;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
375637
public static base_responses update(nitro_service client, dnsaction resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			dnsaction updateresources[] = new dnsaction[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new dnsaction();
				updateresources[i].actionname = resources[i].actionname;
				updateresources[i].ipaddress = resources[i].ipaddress;
				updateresources[i].ttl = resources[i].ttl;
				updateresources[i].viewname = resources[i].viewname;
				updateresources[i].preferredloclist = resources[i].preferredloclist;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
1260716
public static base_response update(nitro_service client, dnsmxrec resource) throws Exception {
		dnsmxrec updateresource = new dnsmxrec();
		updateresource.domain = resource.domain;
		updateresource.mx = resource.mx;
		updateresource.pref = resource.pref;
		updateresource.ttl = resource.ttl;
		return updateresource.update_resource(client);
	}
814639
public static base_response update(nitro_service client, lbparameter resource) throws Exception {
		lbparameter updateresource = new lbparameter();
		updateresource.httponlycookieflag = resource.httponlycookieflag;
		updateresource.consolidatedlconn = resource.consolidatedlconn;
		updateresource.useportforhashlb = resource.useportforhashlb;
		updateresource.preferdirectroute = resource.preferdirectroute;
		updateresource.startuprrfactor = resource.startuprrfactor;
		updateresource.monitorskipmaxclient = resource.monitorskipmaxclient;
		updateresource.monitorconnectionclose = resource.monitorconnectionclose;
		updateresource.vserverspecificmac = resource.vserverspecificmac;
		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)
668576
def Update(self):
		

		return(clc.v2.Requests(clc.v2.API.Call('PUT','servers/%s/%s/publicIPAddresses/%s' % (self.parent.server.alias,self.parent.server.id,self.id),
						                       json.dumps({'ports': [o.ToDict() for o in self.ports],
											               'sourceRestrictions': [o.ToDict() for o in self.source_restrictions] }),
											   session=self.session),
							   alias=self.parent.server.alias,
							   session=self.session))
1291798
function updateDomainDns (dns, ip, cb) {
        var body = {
            content: ip
        };
        _hoverRequest('PUT', '/dns/' + dns, body, cb);
    }
1121991
def modify(self, **params):
        """"""
        data = self.api_client.update_current_user(**params)
        self.update(data)
        return data
1194377
public static base_responses update(nitro_service client, dnspolicy resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			dnspolicy updateresources[] = new dnspolicy[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new dnspolicy();
				updateresources[i].name = resources[i].name;
				updateresources[i].rule = resources[i].rule;
				updateresources[i].viewname = resources[i].viewname;
				updateresources[i].preferredlocation = resources[i].preferredlocation;
				updateresources[i].preferredloclist = resources[i].preferredloclist;
				updateresources[i].drop = resources[i].drop;
				updateresources[i].cachebypass = resources[i].cachebypass;
				updateresources[i].actionname = resources[i].actionname;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
546061
public void updateAnonymity() throws IOException {
    ProxyBinResponse response = GhostMeHelper.getMyInformation(this.getJavaNetProxy());

    if (!response.getOrigin().equalsIgnoreCase(this.getIp())) {
      anonymous = false;
      return;
    }

    if (!response.getHeaders().get("X-Forwarded-For").equalsIgnoreCase(this.getIp())) {
      anonymous = false;
      return;
    }

    if (!response.getHeaders().get("X-Real-Ip").equalsIgnoreCase(this.getIp())) {
      anonymous = false;
      return;
    }

    anonymous = true;

  }
686882
def domain_update(auth=None, **kwargs):
    '''
    
    '''
    cloud = get_operator_cloud(auth)
    kwargs = _clean_kwargs(**kwargs)
    if 'new_name' in kwargs:
        kwargs['name'] = kwargs.pop('new_name')
    return cloud.update_domain(**kwargs)
917171
public static base_response update(nitro_service client, vlan resource) throws Exception {
		vlan updateresource = new vlan();
		updateresource.id = resource.id;
		updateresource.aliasname = resource.aliasname;
		updateresource.ipv6dynamicrouting = resource.ipv6dynamicrouting;
		return updateresource.update_resource(client);
	}
237677
def update(self, update):
        

        params = shlex.split(update)
        if params[0] in self.addr:
            self.addr[params[0]].update(*params)

        else:
            a = Addr(self)
            # add both name and IP address
            self.addr[params[0]] = a
            self.addr[params[1]] = a
            a.update(*params)
            self.notify("addrmap_added", *[a], **{})
105691
public static base_response update(nitro_service client, ip6tunnelparam resource) throws Exception {
		ip6tunnelparam updateresource = new ip6tunnelparam();
		updateresource.srcip = resource.srcip;
		updateresource.dropfrag = resource.dropfrag;
		updateresource.dropfragcputhreshold = resource.dropfragcputhreshold;
		updateresource.srciproundrobin = resource.srciproundrobin;
		return updateresource.update_resource(client);
	}
1261696
def updateNetwork(self,
                      dhcp='dhcp',
                      ipaddress=None,
                      netmask=None,
                      gateway=None,
                      dns=None):
        """"""
        return self.__post('/api/updateNetwork',
                           data={
                               'dhcp': dhcp,
                               'ipaddress': ipaddress,
                               'netmask': netmask,
                               'gateway': gateway,
                               'dns': json.dumps(dns)
                           })
285425
def update_api_mappings(self):
        """"""
        response_provider = None
        response_action = None
        domain = self.generated.apigateway()['domain']
        try:
            response_provider = self.client.create_base_path_mapping(
                domainName=domain,
                basePath=self._format_base_path(self.trigger_settings['api_name']),
                restApiId=self.api_id,
                stage=self.env, )
            response_action = 'API mapping added.'
        except botocore.exceptions.ClientError as error:
            error_code = error.response['Error']['Code']
            if error_code == 'ConflictException':
                response_action = 'API mapping already exist.'
            else:
                response_action = 'Unknown error: {0}'.format(error_code)

        self.log.debug('Provider response: %s', response_provider)
        self.log.info(response_action)
        return response_provider