Beispiel #1
0
 def _create_boot_config_file(self, snapshot, password):
     """Creates a config file that gets placed in the instance
     for the Agent to configure itself"""
     
     if snapshot:
         storage_uri = snapshot['storage_uri']
         config = create_boot_config(CONFIG,
                                     models.Credential().find_by(id=snapshot['credential']),
                                     storage_uri,
                                     password)
     else:
         storage_uri = None
         config = create_boot_config(CONFIG, None, storage_uri, password)
     return { '/home/nova/agent.config': config }
 def test_boot_configuration_creation_with_swift(self):
     cm = { "rabbit_host" : "rabbit.host",
            "rabbit_port" : "1234",
            "rabbit_use_ssl" : "True",
            "rabbit_userid" : "ruser",
            "rabbit_password" : "rpassword",
            "rabbit_virtual_host" : "vhost",
            "reddwarf_proxy_swift_auth_url" : "http://127.0.0.1:5000/v2.0"
            }
     credential = { 'tenant_id' : "*****@*****.**",
                    'user_name' : "*****@*****.**",
                    'password' : "123456ABCDEF" }
     config = create_boot_config(cm, credential, "the-storage-uri", "dbpassword")
     try:
         with tempfile.NamedTemporaryFile(delete=False) as tf:
             tf.write(config)
             file_name = tf.name
         config = ConfigParser.SafeConfigParser()
         config.read(file_name)
         self.assertTrue(config.has_section("snapshot"))
         self.assertEqual("the-storage-uri", config.get("snapshot", "snapshot_uri"))
         self.assertEqual(cm["reddwarf_proxy_swift_auth_url"], config.get("snapshot", "swift_auth_url"))
         self.assertEqual("{0}:{1}".format(credential['tenant_id'], credential['user_name']), config.get("snapshot", "swift_auth_user"))
         self.assertEqual(credential["password"], config.get("snapshot", "swift_auth_key"))
         os.remove(file_name)
     except:
         self.assertTrue(False)
 def test_boot_configuration_creation_no_swift(self):
     cm = { "rabbit_host" : "rabbit.host",
            "rabbit_port" : "1234",
            "rabbit_use_ssl" : "True",
            "rabbit_userid" : "ruser",
            "rabbit_password" : "rpassword",
            "rabbit_virtual_host" : "vhost"}
     credential = { 'tenant_id' : "*****@*****.**",
                    'user_name' : "*****@*****.**",
                    'password' : "123456ABCDEF" }
     config = create_boot_config(cm, credential, None, "dbpassword")
     try:
         with tempfile.NamedTemporaryFile(delete=False) as tf:
             tf.write(config)
             file_name = tf.name
         config = ConfigParser.SafeConfigParser()
         config.read(file_name)
         self.assertTrue(config.has_section("messaging"))
         self.assertEqual(cm["rabbit_host"], config.get("messaging", "rabbit_host"))
         self.assertEqual(cm["rabbit_port"], config.get("messaging", "rabbit_port"))
         self.assertEqual(cm["rabbit_use_ssl"], config.get("messaging", "rabbit_use_ssl"))
         self.assertEqual(cm["rabbit_userid"], config.get("messaging", "rabbit_userid"))
         self.assertEqual(cm["rabbit_password"], config.get("messaging", "rabbit_password"))
         self.assertEqual(cm["rabbit_virtual_host"], config.get("messaging", "rabbit_virtual_host"))
         self.assertTrue(config.has_section("database"))
         self.assertEqual("dbpassword", config.get("database", "initial_password"))
         self.assertFalse(config.has_section("snapshot"))
         os.remove(file_name)
     except Exception, e:
         print "EXCEPTION", e
         self.assertTrue(False)
        except Exception, e:
            LOG.exception("Error creating DB Instance record")
            self.fail("Could not create a DB Instance record")
            
        LOG.debug("Wrote DB Instance: %s" % db_instance)
        
        instance_id = db_instance['id']
        
        # Add a GuestStatus record pointing to the new instance for Maxwell
        try:
            guest_status = models.GuestStatus().create(instance_id=db_instance['id'], state='building')
        except Exception, e:
            LOG.exception("Error creating GuestStatus instance %s" % db_instance.data()['id'])
            self.fail("Unable to create GuestStatus entry")
            
        file_dict = { '/home/nova/agent.config': rd_utils.create_boot_config(config.Config, None, None, 'test') }
        
        instance = { 'id' : instance_id,
                     'remote_uuid' : None,
                     'remote_hostname' : remote_hostname,
                     'tenant_id' : TENANT_ID
                    }
        
        # Invoke worker to ensure instance gets created
        worker_api.API().ensure_create_instance(None, instance, rd_utils.file_dict_as_userdata(file_dict))

        # Test getting a specific db instance.
        # ------------------------------------
        LOG.info("* Getting instance %s" % instance_id)
        resp, content = req.request(API_URL + "instances/" + instance_id, "GET", "", AUTH_HEADER)
        self.assertEqual(200, resp.status, ("Expecting 200 as response status of show instance but received %s" % resp.status))