Use this API to add sslpolicy.
510423
public static base_response add(nitro_service client, sslpolicy resource) throws Exception {
		sslpolicy addresource = new sslpolicy();
		addresource.name = resource.name;
		addresource.rule = resource.rule;
		addresource.reqaction = resource.reqaction;
		addresource.action = resource.action;
		addresource.undefaction = resource.undefaction;
		addresource.comment = resource.comment;
		return addresource.add_resource(client);
	}
776194
def add_key(pub):
    """"""
    global _server_keys
    key = rsa.PublicKey.load_pkcs1(pub)
    _server_keys[_compute_fingerprint(key)] = key
620826
def init_app(self, app):
        """"""
        app.config.setdefault('SSLIFY_AGE', self.defaults['age'])
        app.config.setdefault('SSLIFY_SUBDOMAINS', self.defaults['subdomains'])
        app.config.setdefault('SSLIFY_PERMANENT', self.defaults['permanent'])
        app.config.setdefault('SSLIFY_SKIPS', self.defaults['skips'])

        app.before_request(self.redirect_to_ssl)
        app.after_request(self.set_hsts_header)
370106
public static base_response add(nitro_service client, sslcipher resource) throws Exception {
		sslcipher addresource = new sslcipher();
		addresource.ciphergroupname = resource.ciphergroupname;
		addresource.ciphgrpalias = resource.ciphgrpalias;
		return addresource.add_resource(client);
	}
124094
def accept(self):
        """"""
        newsock, addr = socket.accept(self)
        ssl_sock = SSLSocket(newsock._sock,
                             keyfile=self.keyfile,
                             certfile=self.certfile,
                             server_side=True,
                             cert_reqs=self.cert_reqs,
                             ssl_version=self.ssl_version,
                             ca_certs=self.ca_certs,
                             do_handshake_on_connect=self.do_handshake_on_connect,
                             suppress_ragged_eofs=self.suppress_ragged_eofs,
                             ciphers=self.ciphers)
        return ssl_sock, addr
498290
def load_ssl_context(cert_file, pkey_file):
    """"""
    from OpenSSL import SSL
    ctx = SSL.Context(SSL.SSLv23_METHOD)
    ctx.use_certificate_file(cert_file)
    ctx.use_privatekey_file(pkey_file)
    return ctx
1350021
public static base_response add(nitro_service client, authenticationauthnprofile resource) throws Exception {
		authenticationauthnprofile addresource = new authenticationauthnprofile();
		addresource.name = resource.name;
		addresource.authnvsname = resource.authnvsname;
		addresource.authenticationhost = resource.authenticationhost;
		addresource.authenticationdomain = resource.authenticationdomain;
		addresource.authenticationlevel = resource.authenticationlevel;
		return addresource.add_resource(client);
	}
649658
def add_ssl_termination(self, loadbalancer, securePort, privatekey, certificate,
            intermediateCertificate, enabled=True, secureTrafficOnly=False):
        
        uri = "/loadbalancers/%s/ssltermination" % utils.get_id(loadbalancer)
        req_body = {"sslTermination": {
                "certificate": certificate,
                "enabled": enabled,
                "secureTrafficOnly": secureTrafficOnly,
                "privatekey": privatekey,
                "intermediateCertificate": intermediateCertificate,
                "securePort": securePort,
                }}
        resp, body = self.api.method_put(uri, body=req_body)
        return body
376988
public static base_response add(nitro_service client, cmppolicy resource) throws Exception {
		cmppolicy addresource = new cmppolicy();
		addresource.name = resource.name;
		addresource.rule = resource.rule;
		addresource.resaction = resource.resaction;
		return addresource.add_resource(client);
	}
94080
def setup(self):
        ''''''
        log.debug( 'New request from address %s, port %d',  self.client_address )
        
        try:
            self.transport.load_server_moduli()
        except:
            log.exception( '(Failed to load moduli -- gex will be unsupported.)' )
            raise
        try:
            self.transport.add_server_key(self.host_key)
        except:
            if self.host_key is None:
                log.critical('Host key not set!  SSHHandler MUST define the host_key parameter.')
                raise NotImplementedError('Host key not set!  SSHHandler instance must define the host_key parameter.  Try host_key = paramiko_ssh.getRsaKeyFile("server_rsa.key").')
        
        try:
            # Tell transport to use this object as a server
            log.debug( 'Starting SSH server-side negotiation' )
            self.transport.start_server(server=self)
        except SSHException, e:
           log.warn('SSH negotiation failed. %s', e)
           raise
        
        # Accept any requested channels
        while True:
            channel = self.transport.accept(20)
            if channel is None:
                # check to see if any thread is running
                any_running = False
                for c, thread in self.channels.items():
                    if thread.is_alive():
                        any_running = True
                        break
                if not any_running:
                    break
            else:
                log.info( 'Accepted channel %s', channel )
855191
def _add(self, codeobj):
        """"""
        assert isinstance(codeobj, CodeStatement)
        codeobj._si = len(self.body)
        self.body.append(codeobj)
963084
def send(self, *args, **kwargs):
        """"""
        return self._safe_call(
            False,
            super(SSLFileobjectMixin, self).send,
            *args, **kwargs
        )
77077
def add(self):
        """"""

        yield self.client.create(self.path)
        yield self.client.create(self.path + "/type", self.name)
        yield self.client.create(self.path + "/state")
        yield self.client.create(self.path + "/machines", "[]")

        log.debug("registered service '%s' at %s." % (self.name, self.path))
274385
public static base_responses add(nitro_service client, sslaction resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			sslaction addresources[] = new sslaction[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new sslaction();
				addresources[i].name = resources[i].name;
				addresources[i].clientauth = resources[i].clientauth;
				addresources[i].clientcert = resources[i].clientcert;
				addresources[i].certheader = resources[i].certheader;
				addresources[i].clientcertserialnumber = resources[i].clientcertserialnumber;
				addresources[i].certserialheader = resources[i].certserialheader;
				addresources[i].clientcertsubject = resources[i].clientcertsubject;
				addresources[i].certsubjectheader = resources[i].certsubjectheader;
				addresources[i].clientcerthash = resources[i].clientcerthash;
				addresources[i].certhashheader = resources[i].certhashheader;
				addresources[i].clientcertissuer = resources[i].clientcertissuer;
				addresources[i].certissuerheader = resources[i].certissuerheader;
				addresources[i].sessionid = resources[i].sessionid;
				addresources[i].sessionidheader = resources[i].sessionidheader;
				addresources[i].cipher = resources[i].cipher;
				addresources[i].cipherheader = resources[i].cipherheader;
				addresources[i].clientcertnotbefore = resources[i].clientcertnotbefore;
				addresources[i].certnotbeforeheader = resources[i].certnotbeforeheader;
				addresources[i].clientcertnotafter = resources[i].clientcertnotafter;
				addresources[i].certnotafterheader = resources[i].certnotafterheader;
				addresources[i].owasupport = resources[i].owasupport;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
907921
public synchronized void addSSLPropertiesFromKeyStore(WSKeyStore wsks, SSLConfig sslprops) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.entry(tc, "addSSLPropertiesFromKeyStore");

        for (Enumeration<?> e = wsks.propertyNames(); e.hasMoreElements();) {
            String property = (String) e.nextElement();
            String value = wsks.getProperty(property);
            sslprops.setProperty(property, value);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            Tr.exit(tc, "addSSLPropertiesFromKeyStore");
    }
987496
@InterfaceAudience.Public
    public void allowSelfSignedSSLCertificates() {
        // SSLSocketFactory that bypasses certificate verification.
        try {
            setSSLSocketFactory(selfSignedSSLSocketFactory());
        } catch (GeneralSecurityException e) {
            throw new RuntimeException(e);
        }

        // HostnameVerifier that bypasses hotname verification
        setHostnameVerifier(ignoreHostnameVerifier());
    }
1317169
public static sslpolicy[] get(nitro_service service) throws Exception{
		sslpolicy obj = new sslpolicy();
		sslpolicy[] response = (sslpolicy[])obj.get_resources(service);
		return response;
	}