Esempio n. 1
0
 def test_list_machines(self):
     switch.add_switch_machine(
         self.user_object,
         1,
         mac='28:6e:d4:46:c4:25',
         port='1'
     )
     list_machine = machine.list_machines(self.user_object)
     self.assertIsNotNone(list_machine)
Esempio n. 2
0
 def test_list_machines(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     list_machine = machine.list_machines(self.user_object)
     self.assertIsNotNone(list_machine)
     self.assertEqual(list_machine[0]['mac'], '28:6e:d4:46:c4:25')
Esempio n. 3
0
 def test_list_machines(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     list_machine = machine.list_machines(self.user_object)
     self.assertIsNotNone(list_machine)
     self.assertEqual(list_machine[0]['mac'], '28:6e:d4:46:c4:25')
Esempio n. 4
0
def list_machines():
    """List machines."""
    data = _get_request_args()
    _filter_tag(data)
    _filter_location(data)
    return utils.make_json_response(
        200,
        machine_api.list_machines(
            current_user, **data
        )
    )
Esempio n. 5
0
 def test_del_machine(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     machine.del_machine(
         1,
         user=self.user_object,
     )
     del_machine = machine.list_machines(self.user_object)
     self.assertEqual([], del_machine)
Esempio n. 6
0
 def test_del_machine(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     machine.del_machine(
         1,
         user=self.user_object,
     )
     del_machine = machine.list_machines(self.user_object)
     self.assertEqual([], del_machine)
Esempio n. 7
0
 def test_patch_machine(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     machine.patch_machine(1,
                           user=self.user_object,
                           tag={'patched_tag': 'test'})
     patch_machine = machine.list_machines(self.user_object)
     expected = {'tag': {'patched_tag': 'test'}}
     self.assertTrue(
         all(item in patch_machine[0].items() for item in expected.items()))
Esempio n. 8
0
 def test_patch_machine(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     machine.patch_machine(
         1,
         user=self.user_object,
         tag={'patched_tag': 'test'}
     )
     patch_machine = machine.list_machines(self.user_object)
     expected = {'tag': {'patched_tag': 'test'}}
     self.assertTrue(
         all(item in patch_machine[0].items() for item in expected.items())
     )
Esempio n. 9
0
 def test_update_machine(self):
     switch.add_switch_machine(
         self.user_object,
         1,
         mac='28:6e:d4:46:c4:25',
         port='1'
     )
     machine.update_machine(
         self.user_object,
         1,
         tag='test'
     )
     update_machine = machine.list_machines(self.user_object)
     expected = {'tag': 'test'}
     self.assertTrue(
         item in update_machine[0].items() for item in expected.items()
     )
Esempio n. 10
0
 def test_update_machine(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     machine.update_machine(
         1,
         tag='test',
         user=self.user_object,
     )
     update_machine = machine.list_machines(self.user_object)
     expected = {
         'id': 1,
         'mac': '28:6e:d4:46:c4:25',
         'tag': 'test',
         'switch_ip': '0.0.0.0',
         'port': '1'
     }
     self.assertTrue(
         all(item in update_machine[0].items()
             for item in expected.items()))
Esempio n. 11
0
 def test_update_machine(self):
     switch.add_switch_machine(
         1,
         mac='28:6e:d4:46:c4:25',
         port='1',
         user=self.user_object,
     )
     machine.update_machine(
         1,
         tag='test',
         user=self.user_object,
     )
     update_machine = machine.list_machines(self.user_object)
     expected = {
         'id': 1,
         'mac': '28:6e:d4:46:c4:25',
         'tag': 'test',
         'switch_ip': '0.0.0.0',
         'port': '1'
     }
     self.assertTrue(
         all(item in update_machine[0].items() for item in expected.items())
     )
Esempio n. 12
0
    def setUp(self):
        super(HostTestCase, self).setUp()
        os.environ['COMPASS_IGNORE_SETTING'] = 'true'
        os.environ['COMPASS_CONFIG_DIR'] = os.path.join(
            os.path.dirname(os.path.abspath(__file__)),
            'data'
        )
        reload(setting)
        database.init('sqlite://')
        database.create_db()
        adapter.load_adapters(force_reload=True)
        metadata.load_metadatas(force_reload=True)
        adapter.load_flavors(force_reload=True)

        self.user_object = (
            user_api.get_user_object(
                setting.COMPASS_ADMIN_EMAIL
            )
        )
        # get adapter information
        list_adapters = adapter.list_adapters(user=self.user_object)
        for list_adapter in list_adapters:
            for supported_os in list_adapter['supported_oses']:
                self.os_id = supported_os['os_id']
                break
            if list_adapter['flavors']:
                details = list_adapter['flavors']
                for detail in details:
                    if detail['display_name'] == 'allinone':
                        roles = detail['roles']
                        for role in roles:
                            self.adapter_id = role['adapter_id']
                            self.flavor_id = role['flavor_id']
                            break

        # add cluster
        cluster_names = ['test_cluster1', 'test_cluster2']
        for cluster_name in cluster_names:
            cluster.add_cluster(
                user=self.user_object,
                adapter_id=self.adapter_id,
                os_id=self.os_id,
                flavor_id=self.flavor_id,
                name=cluster_name
            )
        clusters = cluster.list_clusters(user=self.user_object)
        self.roles = None
        for list_cluster in clusters:
            for item in list_cluster['flavor']['roles']:
                self.roles = item
            if list_cluster['name'] == 'test_cluster1':
                self.cluster_id = list_cluster['id']
                break
        # add switch
        switch.add_switch(
            user=self.user_object,
            ip='172.29.8.40'
        )
        switches = switch.list_switches(user=self.user_object)
        self.switch_id = None
        for item in switches:
            self.switch_id = item['id']
        macs = ['28:6e:d4:46:c4:25', '00:0c:29:bf:eb:1d']
        for mac in macs:
            switch.add_switch_machine(
                self.switch_id,
                user=self.user_object,
                mac=mac,
                port='1'
            )
        # get machine information
        machines = machine.list_machines(user=self.user_object)
        self.machine_ids = []
        for item in machines:
            self.machine_ids.append(item['id'])
        # add cluster host
        name = ['newname1', 'newname2']
        for i in range(0, 2):
            cluster.add_cluster_host(
                self.cluster_id,
                user=self.user_object,
                machine_id=self.machine_ids[i],
                name=name[i]
            )
        self.host_ids = []
        clusterhosts = cluster.list_clusterhosts(user=self.user_object)
        for clusterhost in clusterhosts:
            self.host_ids.append(clusterhost['host_id'])
        # add subnet
        subnets = ['10.145.88.0/23', '192.168.100.0/23']
        for subnet in subnets:
            network.add_subnet(
                user=self.user_object,
                subnet=subnet
            )
        list_subnet = network.list_subnets(
            user=self.user_object
        )
        self.subnet_ids = []
        for item in list_subnet:
            self.subnet_ids.append(item['id'])
        # add host network
        host.add_host_network(
            self.host_ids[0],
            user=self.user_object,
            interface='eth0',
            ip='10.145.88.0',
            subnet_id=self.subnet_ids[0],
            is_mgmt=True
        )
        host.add_host_network(
            self.host_ids[1],
            user=self.user_object,
            interface='eth1',
            ip='192.168.100.0',
            subnet_id=self.subnet_ids[1],
            is_promiscuous=True
        )
        # add log history
        filenames = ['log1', 'log2']
        for filename in filenames:
            host.add_host_log_history(
                self.host_ids[0],
                user=self.user_object,
                filename=filename
            )

        self.os_configs = {
            'general': {
                'language': 'EN',
                'timezone': 'UTC',
                'http_proxy': 'http://127.0.0.1:3128',
                'https_proxy': 'http://127.0.0.1:3128',
                'no_proxy': [
                    '127.0.0.1',
                    'compass'
                ],
                'ntp_server': '127.0.0.1',
                'dns_servers': [
                    '127.0.0.1'
                ],
                'domain': 'ods.com',
                'search_path': [
                    'ods.com'
                ],
                'default_gateway': '127.0.0.1',
            },
            'server_credentials': {
                'username': '******',
                'password': '******',
            },
            'partition': {
                '/var': {
                    'max_size': '100G',
                    'percentage': 10,
                    'size': '1G'
                }
            }
        }
        self.package_configs = {
            'security': {
                'service_credentials': {
                    '$service': {
                        'username': '******',
                        'password': '******'
                    }
                },
                'console_credentials': {
                    '$console': {
                        'username': '******',
                        'password': '******'
                    }
                }
            },
            'network_mapping': {
                '$interface_type': 'eth0'
            }
        }
    def _prepare_database(self):
        adapter.load_adapters()
        metadata.load_metadatas()

        self.user_object = (
            user_api.get_user_object(
                setting.COMPASS_ADMIN_EMAIL
            )
        )
        self.adapter_id = None
        self.os_id = None
        self.flavor_id = None
        self.cluster_id = None

        # get adapter information
        list_adapters = adapter.list_adapters(user=self.user_object)
        for adptr in list_adapters:
            self.adapter_id = None
            if adptr['name'] != ADAPTER_NAME:
                continue
            self.adapter_id = adptr['id']
            self.os_id = None
            for supported_os in adptr['supported_oses']:
                if supported_os['name'] == OS_NAME:
                    self.os_id = supported_os['os_id']
                    break
            if not self.os_id:
                continue
            if (
                'package_installer' in adptr.keys() and
                adptr['flavors'] != [] and
                adptr['distributed_system_name'] == 'openstack'
            ):
                self.flavor_id = None
                for flavor in adptr['flavors']:
                    if flavor['name'] == 'allinone':
                        self.flavor_id = flavor['id']
                        break
                if not self.flavor_id:
                    continue
            else:
                continue
            if self.adapter_id and self.os_id and self.flavor_id:
                break

        if not self.adapter_id:
            raise Exception('adapter id not found')
        if not self.os_id:
            raise Exception('os id not found')
        if not self.flavor_id:
            raise Exception('flavor id not found')

        # add cluster
        cluster.add_cluster(
            adapter_id=self.adapter_id,
            os_id=self.os_id,
            flavor_id=self.flavor_id,
            name='test_cluster',
            user=self.user_object,
        )
        list_clusters = cluster.list_clusters(user=self.user_object)
        for list_cluster in list_clusters:
            if list_cluster['name'] == 'test_cluster':
                self.cluster_id = list_cluster['id']
                break
        for list_cluster in list_clusters:
            self.cluster_id = list_cluster['id']

        # add switch
        switch.add_switch(
            ip=SWITCH_IP,
            user=self.user_object,
        )
        list_switches = switch.list_switches(user=self.user_object)
        for list_switch in list_switches:
            self.switch_id = list_switch['id']
        switch.add_switch_machine(
            self.switch_id,
            user=self.user_object,
            mac=MACHINE_MAC,
            port='1'
        )

        # get machine information
        list_machines = machine.list_machines(user=self.user_object)
        for list_machine in list_machines:
            self.machine_id = list_machine['id']

        # add cluster host
        cluster.add_cluster_host(
            self.cluster_id,
            user=self.user_object,
            machine_id=self.machine_id,
            name='test_clusterhost'
        )
        list_clusterhosts = cluster.list_clusterhosts(user=self.user_object)
        for list_clusterhost in list_clusterhosts:
            self.host_id = list_clusterhost['host_id']
            self.clusterhost_id = list_clusterhost['clusterhost_id']

        # add subnet
        network.add_subnet(
            subnet=SUBNET,
            user=self.user_object,
        )
        list_subnets = network.list_subnets(
            user=self.user_object
        )
        for list_subnet in list_subnets:
            self.subnet_id = list_subnet['id']

        # add host network
        host.add_host_network(
            self.host_id,
            user=self.user_object,
            interface='eth0',
            ip=HOST_IP,
            subnet_id=self.subnet_id,
            is_mgmt=True
        )

        # get clusterhost
        list_clusterhosts = cluster.list_clusterhosts(
            user=self.user_object
        )
        for list_clusterhost in list_clusterhosts:
            self.clusterhost_id = list_clusterhost['id']

        # update host state
        self.list_hosts = host.list_hosts(user=self.user_object)
        for list_host in self.list_hosts:
            self.host_id = list_host['id']
        self.host_state = host.update_host_state(
            self.host_id,
            user=self.user_object,
            state='INSTALLING'
        )

        # update cluster state
        cluster.update_cluster_state(
            self.cluster_id,
            user=self.user_object,
            state='INSTALLING'
        )

        # update clusterhost state
        cluster.update_clusterhost_state(
            self.clusterhost_id,
            user=self.user_object,
            state='INSTALLING'
        )