Use this API to update sslcertkey resources.
552771
public static base_responses update(nitro_service client, sslcertkey resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			sslcertkey updateresources[] = new sslcertkey[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new sslcertkey();
				updateresources[i].certkey = resources[i].certkey;
				updateresources[i].expirymonitor = resources[i].expirymonitor;
				updateresources[i].notificationperiod = resources[i].notificationperiod;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
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);
	}
245539
public static base_response add(nitro_service client, sslcertkey resource) throws Exception {
		sslcertkey addresource = new sslcertkey();
		addresource.certkey = resource.certkey;
		addresource.cert = resource.cert;
		addresource.key = resource.key;
		addresource.password = resource.password;
		addresource.fipskey = resource.fipskey;
		addresource.inform = resource.inform;
		addresource.passplain = resource.passplain;
		addresource.expirymonitor = resource.expirymonitor;
		addresource.notificationperiod = resource.notificationperiod;
		addresource.bundle = resource.bundle;
		return addresource.add_resource(client);
	}
453414
def update(context, resource, **kwargs):
    """"""
    etag = kwargs.pop('etag')
    id = kwargs.pop('id')
    data = utils.sanitize_kwargs(**kwargs)
    uri = '%s/%s/%s' % (context.dci_cs_api, resource, id)
    r = context.session.put(uri, timeout=HTTP_TIMEOUT,
                            headers={'If-match': etag},
                            json=data)
    return r
1063642
def upgrade_transport(
        self,
        context: ssl.SSLContext,
        server_hostname: str = None,
        waiter: Awaitable = None,
    ) -> SSLProtocol:
        
        if self._over_ssl:
            raise RuntimeError("Already using TLS.")

        if self._stream_reader is None or self._stream_writer is None:
            raise SMTPServerDisconnected("Client not connected")

        transport = self._stream_reader._transport  # type: ignore

        tls_protocol = SSLProtocol(
            self._loop,
            self,
            context,
            waiter,
            server_side=False,
            server_hostname=server_hostname,
        )

        app_transport = tls_protocol._app_transport
        # Use set_protocol if we can
        if hasattr(transport, "set_protocol"):
            transport.set_protocol(tls_protocol)
        else:
            transport._protocol = tls_protocol

        self._stream_reader._transport = app_transport  # type: ignore
        self._stream_writer._transport = app_transport  # type: ignore

        tls_protocol.connection_made(transport)
        self._over_ssl = True  # type: bool

        return tls_protocol
137856
public static ns_ssl_certkey_policy update(nitro_service client, ns_ssl_certkey_policy resource) throws Exception
	{
		resource.validate("modify");
		return ((ns_ssl_certkey_policy[]) resource.update_resource(client))[0];
	}
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))
560557
public static base_responses add(nitro_service client, sslcrl resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			sslcrl addresources[] = new sslcrl[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new sslcrl();
				addresources[i].crlname = resources[i].crlname;
				addresources[i].crlpath = resources[i].crlpath;
				addresources[i].inform = resources[i].inform;
				addresources[i].refresh = resources[i].refresh;
				addresources[i].cacert = resources[i].cacert;
				addresources[i].method = resources[i].method;
				addresources[i].server = resources[i].server;
				addresources[i].url = resources[i].url;
				addresources[i].port = resources[i].port;
				addresources[i].basedn = resources[i].basedn;
				addresources[i].scope = resources[i].scope;
				addresources[i].interval = resources[i].interval;
				addresources[i].day = resources[i].day;
				addresources[i].time = resources[i].time;
				addresources[i].binddn = resources[i].binddn;
				addresources[i].password = resources[i].password;
				addresources[i].binary = resources[i].binary;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
805135
def update(self, data, key):
        """"""
        og_data = self.read()
        og_data[key] = data
        self.write(og_data)
336722
protected void updateSubjectWithSharedStateContents() {
        subject.getPrincipals().add((WSPrincipal) sharedState.get(Constants.WSPRINCIPAL_KEY));
        subject.getPublicCredentials().add(sharedState.get(Constants.WSCREDENTIAL_KEY));
        if (sharedState.get(Constants.WSSSOTOKEN_KEY) != null)
            subject.getPrivateCredentials().add(sharedState.get(Constants.WSSSOTOKEN_KEY));
    }
334822
def SetUseSSL(self, use_ssl):
    
    self._use_ssl = use_ssl
    logger.debug('Elasticsearch use_ssl: {0!s}'.format(use_ssl))
710659
def update_keys(self):
        """"""
        from ...main import add_api_key
        add_api_key("google_api_key", self.google_api_key.get())
        add_api_key("soundcloud_client_id", self.soundcloud_client_id.get())
505408
public static base_responses update(nitro_service client, sslservicegroup resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			sslservicegroup updateresources[] = new sslservicegroup[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new sslservicegroup();
				updateresources[i].servicegroupname = resources[i].servicegroupname;
				updateresources[i].sessreuse = resources[i].sessreuse;
				updateresources[i].sesstimeout = resources[i].sesstimeout;
				updateresources[i].nonfipsciphers = resources[i].nonfipsciphers;
				updateresources[i].ssl3 = resources[i].ssl3;
				updateresources[i].tls1 = resources[i].tls1;
				updateresources[i].serverauth = resources[i].serverauth;
				updateresources[i].commonname = resources[i].commonname;
				updateresources[i].sendclosenotify = resources[i].sendclosenotify;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
72500
public static base_response update(nitro_service client, sslcrl resource) throws Exception {
		sslcrl updateresource = new sslcrl();
		updateresource.crlname = resource.crlname;
		updateresource.refresh = resource.refresh;
		updateresource.cacert = resource.cacert;
		updateresource.server = resource.server;
		updateresource.method = resource.method;
		updateresource.url = resource.url;
		updateresource.port = resource.port;
		updateresource.basedn = resource.basedn;
		updateresource.scope = resource.scope;
		updateresource.interval = resource.interval;
		updateresource.day = resource.day;
		updateresource.time = resource.time;
		updateresource.binddn = resource.binddn;
		updateresource.password = resource.password;
		updateresource.binary = resource.binary;
		return updateresource.update_resource(client);
	}
1211143
public static base_responses link(nitro_service client, sslcertkey resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			sslcertkey linkresources[] = new sslcertkey[resources.length];
			for (int i=0;i<resources.length;i++){
				linkresources[i] = new sslcertkey();
				linkresources[i].certkey = resources[i].certkey;
				linkresources[i].linkcertkeyname = resources[i].linkcertkeyname;
			}
			result = perform_operation_bulk_request(client, linkresources,"link");
		}
		return result;
	}
1213107
def update
      say "Fetching certificate chain from DNSimple for #{options['dnsimple_common_name']} ...", :green
      dnsimple_certificate.certificate_chain

      say "Fetching private key from DNSimple for #{options['dnsimple_common_name']}. ..", :green
      dnsimple_certificate.private_key

      say "Fetching certificates from Heroku app #{options['heroku_app']} ...", :green
      heroku_certificate.certificates

      if heroku_certificate.certificates.any?
        say "Updating existing certificate on Heroku app #{options['heroku_app']} ...", :green
        heroku_certificate.update
      else
        say "Adding new certificate on Heroku app #{options['heroku_app']} ...", :green
        heroku_certificate.create
      end

      say "Done!", :green
    rescue => e
      say "Error adding certificate ...", :red
      say "   Response: #{e}", :red

      abort
    end
917144
def _update_ssl_params(host):
        
        if host[HostParsing.HOST] \
                and EsParser._is_secure_connection_type(host):
            host[HostParsing.PORT] = EsParser.SSL_DEFAULT_PORT
            host[HostParsing.USE_SSL] = True
            parsed_url = urlparse(EsParser._fix_host_prefix(host[HostParsing.HOST]))
            host[HostParsing.HOST] = parsed_url.hostname
            host[HostParsing.SCHEME] = HostParsing.HTTPS
        return host