Python x509main.x509main函数代码示例

    def test_add_remove_autofailover(self):
        rest = RestConnection(self.master)
        serv_out = self.servers[3]
        shell = RemoteMachineShellConnection(serv_out)
        known_nodes = ['[email protected]'+self.master.ip]

        rest.create_bucket(bucket='default', ramQuotaMB=100)
        rest.update_autofailover_settings(True,30)

        x509main(self.master).setup_master()
        x509main().setup_cluster_nodes_ssl(self.servers[1:4])
        for server in self.servers[1:4]:
            rest.add_node('Administrator','password',server.ip)
            known_nodes.append('[email protected]'+server.ip)

        rest.rebalance(known_nodes)
        self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")

        shell.stop_server()
        self.sleep(60)
        shell.start_server()
        self.sleep(30)
        for server in self.servers:
            status = x509main(server)._validate_ssl_login()
            self.assertEqual(status,200,"Not able to login via SSL code")

 def test_get_cluster_ca(self):
     x509main(self.master).setup_master()
     status, content, header = x509main(self.master)._get_cluster_ca_cert()
     content = json.loads(content)
     self.assertEqual(content['cert']['type'],"uploaded","Type of certificate is mismatch")
     #self.assertEqual(content['cert']['pem'],"uploaded","Type of certificate is mismatch")
     self.assertEqual(content['cert']['subject'],"CN=Root Authority","Common Name is incorrect")

 def test_add_node_without_cert(self):
     rest = RestConnection(self.master)
     servs_inout = self.servers[1]
     x509main(self.master).setup_master()
     try:
         rest.add_node('Administrator','password',servs_inout.ip)
     except Exception, ex:
         ex = str(ex)
         expected_result  = "Error adding node: " + servs_inout.ip + " to the cluster:" + self.master.ip + " - [\"Prepare join failed. Error applying node certificate. Unable to read certificate chain file\"]"
         #self.assertEqual(ex,expected_result)
         self.assertTrue(expected_result in ex,"Incorrect Error message in exception")

 def _reset_original(self):
     self.log.info ("Reverting to original state - regenerating certificate and removing inbox folder")
     tmp_path = "/tmp/abcd.pem"
     for servers in self.servers:
         cli_command = "ssl-manage"
         remote_client = RemoteMachineShellConnection(servers)
         options = "--regenerate-cert={0}".format(tmp_path)
         output, error = remote_client.execute_couchbase_cli(cli_command=cli_command, options=options,
                                                             cluster_host=servers.ip, user="Administrator",
                                                             password="password")
         x509main(servers)._delete_inbox_folder()

    def test_sdk_existing_cluster(self):
        servers_in = self.servers[1:]
        self.cluster.rebalance(self.servers, servers_in, [])

        rest = RestConnection(self.master)
        x509main(self.master).setup_master()
        x509main().setup_cluster_nodes_ssl(self.servers,reload_cert=True)
        rest.create_bucket(bucket='default', ramQuotaMB=100)

        for server in self.servers:
            result = self._sdk_connection(host_ip=server.ip)
            self.assertTrue(result,"Cannot create a security connection with server")

    def test_sdk_cluster_incorrect_cert(self):
        rest = RestConnection(self.master)
        x509main(self.master).setup_master()
        x509main().setup_cluster_nodes_ssl(self.servers)
        rest.create_bucket(bucket='default', ramQuotaMB=100)

        servers_in = self.servers[1:]
        self.cluster.rebalance(self.servers, servers_in, [])

        root_incorrect_ca_path = x509main.CACERTFILEPATH + x509main.INCORRECT_ROOT_CERT
        for server in self.servers:
            result = self._sdk_connection(host_ip=server.ip,root_ca_path=root_incorrect_ca_path)
            self.assertFalse(result,"Can create a security connection with incorrect root cert")

 def test_get_cluster_ca_cluster(self):
     servs_inout = self.servers[1]
     rest = RestConnection(self.master)
     x509main(self.master).setup_master()
     x509main(servs_inout)._setup_node_certificates(reload_cert=False)
     servs_inout = self.servers[1]
     rest.add_node('Administrator','password',servs_inout.ip)
     for server in self.servers[:2]:
         status, content, header = x509main(server)._get_cluster_ca_cert()
         content = json.loads(content)
         self.assertTrue(status,"Issue while Cluster CA Cert")
         self.assertEqual(content['cert']['type'],"uploaded","Type of certificate is mismatch")
         self.assertEqual(content['cert']['subject'],"CN=Root Authority","Common Name is incorrect")

 def test_add_node_with_cert(self):
     servs_inout = self.servers[1:4]
     rest = RestConnection(self.master)
     x509main(self.master).setup_master()
     x509main().setup_cluster_nodes_ssl(servs_inout)
     known_nodes = ['[email protected]'+self.master.ip]
     for server in servs_inout:
         rest.add_node('Administrator','password',server.ip)
         known_nodes.append('[email protected]' + server.ip)
     rest.rebalance(known_nodes)
     self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")
     for server in self.servers:
         status = x509main(server)._validate_ssl_login()
         self.assertEqual(status,200,"Not able to login via SSL code")

 def test_get_cluster_ca_self_signed(self):
     rest = RestConnection(self.master)
     rest.regenerate_cluster_certificate()
     status, content, header = x509main(self.master)._get_cluster_ca_cert()
     content = json.loads(content)
     self.assertTrue(status,"Issue while Cluster CA Cert")
     self.assertEqual(content['cert']['type'],"generated","Type of certificate is mismatch")

 def setUp(self):
     super(x509_upgrade, self).setUp()
     self.initial_version = self.input.param("initial_version",'4.5.0-900')
     self.upgrade_version = self.input.param("upgrade_version", "4.5.0-1069")
     self._reset_original()
     x509main(self.master)._generate_cert(self.servers)
     self.ip_address = self.getLocalIPAddress()
     enable_audit=self.input.param('audit',None)
     if enable_audit:
         Audit = audit(host=self.master)
         currentState = Audit.getAuditStatus()
         self.log.info ("Current status of audit on ip - {0} is {1}".format(self.master.ip, currentState))
         if not currentState:
             self.log.info ("Enabling Audit ")
             Audit.setAuditEnable('true')
             self.sleep(30)

    def test_sdk_change_ca_self_signed(self):
        rest = RestConnection(self.master)
        temp_file_name = '/tmp/newcerts/orig_cert.pem'
        x509main(self.master).setup_master()
        x509main().setup_cluster_nodes_ssl(self.servers)
        rest.create_bucket(bucket='default', ramQuotaMB=100)
        result = self._sdk_connection(host_ip=self.master.ip)
        self.assertTrue(result,"Cannot create a security connection with server")
        rest.regenerate_cluster_certificate()

        temp_cert = rest.get_cluster_ceritificate()
        temp_file = open(temp_file_name,'w')
        temp_file.write(temp_cert)
        temp_file.close()

        result = self._sdk_connection(root_ca_path=temp_file_name,host_ip=self.master.ip)
        self.assertTrue(result,"Cannot create a security connection with server")

 def test_end_to_end_after_cluster(self):
     output, error = self._upload_cert_cli()
     self._setup_all_cluster_nodes(self.servers)
     servers_in = self.servers[1:]
     self.cluster.rebalance(self.servers, servers_in, [])
     for server in self.servers:
         status = x509main(server)._validate_ssl_login()
         self.assertEqual(status,200,"Not able to login via SSL code")

    def upgrade_all_nodes(self):
        servers_in = self.servers[1:]
        self._install(self.servers)
        rest_conn = RestConnection(self.master)
        rest_conn.init_cluster(username='Administrator', password='password')
        rest_conn.create_bucket(bucket='default', ramQuotaMB=512)
        self.cluster.rebalance(self.servers, servers_in, [])

        upgrade_threads = self._async_update(upgrade_version=self.upgrade_version, servers=self.servers)
        for threads in upgrade_threads:
            threads.join()


        x509main(self.master).setup_master()
        x509main().setup_cluster_nodes_ssl(self.servers,reload_cert=True)

        for server in self.servers:
            result = self._sdk_connection(host_ip=server.ip)
            self.assertTrue(result,"Cannot create a security connection with server")

    def test_add_remove_graceful_add_back_node_with_cert(self,recovery_type=None):
        recovery_type = self.input.param('recovery_type')
        rest = RestConnection(self.master)
        known_nodes = ['[email protected]'+self.master.ip]
        progress = None
        count = 0
        servs_inout = self.servers[1:]
        serv_out = '[email protected]' + servs_inout[1].ip

        rest.create_bucket(bucket='default', ramQuotaMB=100)

        x509main(self.master).setup_master()
        x509main().setup_cluster_nodes_ssl(servs_inout)
        for server in servs_inout:
            rest.add_node('Administrator','password',server.ip)
            known_nodes.append('[email protected]' + server.ip)

        rest.rebalance(known_nodes)
        self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")

        for server in servs_inout:
            status = x509main(server)._validate_ssl_login()
            self.assertEqual(status,200,"Not able to login via SSL code")

        rest.fail_over(serv_out,graceful=True)
        self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")
        rest.set_recovery_type(serv_out,recovery_type)
        rest.add_back_node(serv_out)
        rest.rebalance(known_nodes)
        self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")

        for server in servs_inout:
            status = x509main(server)._validate_ssl_login()
            self.assertEqual(status,200,"Not able to login via SSL code")

 def test_add_remove_add_back_node_with_cert(self,rebalance=None):
     rebalance = self.input.param('rebalance')
     rest = RestConnection(self.master)
     servs_inout = self.servers[1:3]
     serv_out = '[email protected]' + servs_inout[1].ip
     known_nodes = ['[email protected]'+self.master.ip]
     x509main(self.master).setup_master()
     x509main().setup_cluster_nodes_ssl(servs_inout)
     for server in servs_inout:
         rest.add_node('Administrator','password',server.ip)
         known_nodes.append('[email protected]' + server.ip)
     rest.rebalance(known_nodes)
     self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")
     for server in servs_inout:
         status = x509main(server)._validate_ssl_login()
         self.assertEqual(status,200,"Not able to login via SSL code")
     rest.fail_over(serv_out,graceful=False)
     if (rebalance):
         rest.rebalance(known_nodes,[serv_out])
         self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")
         rest.add_node('Administrator','password',servs_inout[1].ip)
     else:
         rest.add_back_node(serv_out)
     rest.rebalance(known_nodes)
     self.assertTrue(self.check_rebalance_complete(rest),"Issue with rebalance")
     for server in servs_inout:
         response = x509main(server)._validate_ssl_login()
         self.assertEqual(status,200,"Not able to login via SSL code")