Use this API to update route6 resources.
766429
public static base_responses update(nitro_service client, route6 resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			route6 updateresources[] = new route6[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new route6();
				updateresources[i].network = resources[i].network;
				updateresources[i].gateway = resources[i].gateway;
				updateresources[i].vlan = resources[i].vlan;
				updateresources[i].weight = resources[i].weight;
				updateresources[i].distance = resources[i].distance;
				updateresources[i].cost = resources[i].cost;
				updateresources[i].advertise = resources[i].advertise;
				updateresources[i].msr = resources[i].msr;
				updateresources[i].monitor = resources[i].monitor;
				updateresources[i].td = resources[i].td;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
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
1270903
public static base_responses add(nitro_service client, route6 resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			route6 addresources[] = new route6[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new route6();
				addresources[i].network = resources[i].network;
				addresources[i].gateway = resources[i].gateway;
				addresources[i].vlan = resources[i].vlan;
				addresources[i].weight = resources[i].weight;
				addresources[i].distance = resources[i].distance;
				addresources[i].cost = resources[i].cost;
				addresources[i].advertise = resources[i].advertise;
				addresources[i].msr = resources[i].msr;
				addresources[i].monitor = resources[i].monitor;
				addresources[i].td = resources[i].td;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
1054473
public static base_response update(nitro_service client, route resource) throws Exception {
		route updateresource = new route();
		updateresource.network = resource.network;
		updateresource.netmask = resource.netmask;
		updateresource.gateway = resource.gateway;
		updateresource.td = resource.td;
		updateresource.distance = resource.distance;
		updateresource.cost1 = resource.cost1;
		updateresource.weight = resource.weight;
		updateresource.advertise = resource.advertise;
		updateresource.protocol = resource.protocol;
		updateresource.msr = resource.msr;
		updateresource.monitor = resource.monitor;
		return updateresource.update_resource(client);
	}
1006398
public static base_responses update(nitro_service client, dnsaction64 resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			dnsaction64 updateresources[] = new dnsaction64[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new dnsaction64();
				updateresources[i].actionname = resources[i].actionname;
				updateresources[i].prefix = resources[i].prefix;
				updateresources[i].mappedrule = resources[i].mappedrule;
				updateresources[i].excluderule = resources[i].excluderule;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
456728
protected void updateApiVersionResource(Object resource) {
    if (resource instanceof HasMetadata) {
      HasMetadata hasMetadata = (HasMetadata) resource;
      updateApiVersion(hasMetadata);
    } else if (resource instanceof KubernetesResourceList) {
      KubernetesResourceList list = (KubernetesResourceList) resource;
      updateApiVersion(list);
    }
  }
739706
def UpdateProtoResources(self, status):
    """"""
    user_cpu = status.cpu_time_used.user_cpu_time
    system_cpu = status.cpu_time_used.system_cpu_time
    self.context.client_resources.cpu_usage.user_cpu_time += user_cpu
    self.context.client_resources.cpu_usage.system_cpu_time += system_cpu

    user_cpu_total = self.context.client_resources.cpu_usage.user_cpu_time
    system_cpu_total = self.context.client_resources.cpu_usage.system_cpu_time

    self.context.network_bytes_sent += status.network_bytes_sent

    if self.runner_args.cpu_limit:
      if self.runner_args.cpu_limit < (user_cpu_total + system_cpu_total):
        # We have exceeded our limit, stop this flow.
        raise FlowRunnerError("CPU limit exceeded.")

    if self.runner_args.network_bytes_limit:
      if (self.runner_args.network_bytes_limit <
          self.context.network_bytes_sent):
        # We have exceeded our byte limit, stop this flow.
        raise FlowRunnerError("Network bytes limit exceeded.")
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);
	}
882697
def update(self):
        '''
        
        '''
        self._json = self._request(
            method='GET',
            url=self.API
        )._json
1039925
public static base_responses update(nitro_service client, bridgegroup resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			bridgegroup updateresources[] = new bridgegroup[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new bridgegroup();
				updateresources[i].id = resources[i].id;
				updateresources[i].ipv6dynamicrouting = resources[i].ipv6dynamicrouting;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
745522
def update_resource(self, resource):
        ''''''
        index = self.resources.index(resource)
        data = {
            'resources__{index}'.format(index=index): resource
        }
        self.update(**data)
        self.reload()
        post_save.send(self.__class__, document=self)
143166
def update_router(self, context, router_id, router):
        """"""

        # Read existing router record from DB
        original_router = self.get_router(context, router_id)
        # Update router DB
        new_router = super(AristaL3ServicePlugin, self).update_router(
            context, router_id, router)

        # Modify router on the Arista Hw
        try:
            self.driver.update_router(context, router_id,
                                      original_router, new_router)
            return new_router
        except Exception:
            LOG.error(_LE("Error updating router on Arista HW router=%s "),
                      new_router)
90853
def _update_from_api_repr(self, resource):
        """"""
        self.destination = resource["destination"]
        self.filter_ = resource.get("filter")
        self._writer_identity = resource.get("writerIdentity")
1222159
def update_resource(id_or_uri, resource, opts = {})
      data, _status_code, _headers = update_resource_with_http_info(id_or_uri, resource, opts)
      return data
    end
321527
public static base_responses update(nitro_service client, channel resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			channel updateresources[] = new channel[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new channel();
				updateresources[i].id = resources[i].id;
				updateresources[i].state = resources[i].state;
				updateresources[i].mode = resources[i].mode;
				updateresources[i].conndistr = resources[i].conndistr;
				updateresources[i].macdistr = resources[i].macdistr;
				updateresources[i].lamac = resources[i].lamac;
				updateresources[i].speed = resources[i].speed;
				updateresources[i].flowctl = resources[i].flowctl;
				updateresources[i].hamonitor = resources[i].hamonitor;
				updateresources[i].tagall = resources[i].tagall;
				updateresources[i].trunk = resources[i].trunk;
				updateresources[i].ifalias = resources[i].ifalias;
				updateresources[i].throughput = resources[i].throughput;
				updateresources[i].lrminthroughput = resources[i].lrminthroughput;
				updateresources[i].bandwidthhigh = resources[i].bandwidthhigh;
				updateresources[i].bandwidthnormal = resources[i].bandwidthnormal;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
234245
def _update_url_map(self):
        '''
        
        '''
        if HAS_WEBSOCKETS:
            self.url_map.update({
                'ws': WebsocketEndpoint,
            })

        # Allow the Webhook URL to be overridden from the conf.
        self.url_map.update({
            self.apiopts.get('webhook_url', 'hook').lstrip('/'): Webhook,
        })

        # Enable the single-page JS app URL.
        self.url_map.update({
            self.apiopts.get('app_path', 'app').lstrip('/'): App,
        })
835622
public static base_response update(nitro_service client, vpathparam resource) throws Exception {
		vpathparam updateresource = new vpathparam();
		updateresource.srcip = resource.srcip;
		return updateresource.update_resource(client);
	}