def test_create_instance(self):
remote_uuid = utils.generate_uuid()
kwargs = {"remote_uuid": remote_uuid,
"name": "dbapi_test",
"availability_zone": "az1"}
instance = factory_models.DBInstance().create(**kwargs).data()
self.assertEqual(instance['name'], "dbapi_test")
self.assertEqual(instance['deleted'], False)
self.assertNotEqual(instance['created_at'], None)
self.assertEqual(len(instance['id']), len(utils.generate_uuid()))
self.assertEqual(instance['remote_uuid'], remote_uuid)
def mock_out_client_create(self):
"""Stubs out a fake server returned from novaclient.
This is akin to calling Client.servers.get(uuid)
and getting the server object back."""
self.FAKE_SERVER = self.mock.CreateMock(object)
self.FAKE_SERVER.name = 'my_name'
self.FAKE_SERVER.status = 'ACTIVE'
self.FAKE_SERVER.updated = utils.utcnow()
self.FAKE_SERVER.created = utils.utcnow()
self.FAKE_SERVER.id = utils.generate_uuid()
self.FAKE_SERVER.flavor = 'http://localhost/1234/flavors/1234'
self.FAKE_SERVER.links = [{
"href": "http://localhost/1234/instances/123",
"rel": "self",
}, {
"href": "http://localhost/1234/instances/123",
"rel": "bookmark",
}]
self.FAKE_SERVER.addresses = {
"private": [
{
"addr": "10.0.0.4",
"version": 4,
},
],
}
client = self.mock.CreateMock(novaclient.v1_1.Client)
servers = self.mock.CreateMock(novaclient.v1_1.servers.ServerManager)
servers.create(mox.IgnoreArg(), mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(self.FAKE_SERVER)
client.servers = servers
self.mock.StubOutWithMock(models.NovaRemoteModelBase, 'get_client')
models.NovaRemoteModelBase.get_client(mox.IgnoreArg()). \
AndReturn(client)
def create(cls, **values):
values['id'] = utils.generate_uuid()
print values
# values['created_at'] = utils.utcnow()
instance = cls(**values).save()
# instance._notify_fields("create")
return instance
def create(cls, **values):
values['id'] = utils.generate_uuid()
values['created'] = utils.utcnow()
instance = cls(**values).save()
if not instance.is_valid():
raise exception.InvalidModelError(errors=instance.errors)
return instance
def create(cls, **values):
values['id'] = utils.generate_uuid()
values['created'] = utils.utcnow()
instance = cls(**values).save()
if not instance.is_valid():
raise exception.InvalidModelError(errors=instance.errors)
return instance
def __init__(self, tenant_id, resource, hard_limit,
id=utils.generate_uuid(), created=utils.utcnow(),
update=utils.utcnow()):
self.tenant_id = tenant_id
self.resource = resource
self.hard_limit = hard_limit
self.id = id
self.created = created
self.update = update
def test_create_snapshot(self):
kwargs = {}
instance = factory_models.Snapshot().create(**kwargs).data()
print instance
self.assertEqual(instance['deleted'], False)
self.assertNotEqual(instance['created_at'], None)
self.assertEqual(len(instance['id']), len(utils.generate_uuid()))
def test_retrieve_snapshot(self):
name = utils.generate_uuid()
kwargs = {"name": name}
snapshot = factory_models.Snapshot().create(**kwargs)
data = snapshot.data()
self.assertEqual(data['name'], name)
found_snapshot = snapshot.find_by(name=name)
data = found_snapshot.data()
self.assertEqual(data['name'], name)
def create(cls, **values):
if 'id' not in values:
values['id'] = utils.generate_uuid()
if hasattr(cls, 'deleted') and 'deleted' not in values:
values['deleted'] = False
values['created'] = utils.utcnow()
instance = cls(**values).save()
if not instance.is_valid():
raise exception.InvalidModelError(errors=instance.errors)
return instance
def create(cls, **values):
if 'id' not in values:
values['id'] = utils.generate_uuid()
if hasattr(cls, 'deleted') and 'deleted' not in values:
values['deleted'] = False
values['created'] = utils.utcnow()
instance = cls(**values).save()
if not instance.is_valid():
raise exception.InvalidModelError(errors=instance.errors)
return instance
def create(cls, **values):
values['id'] = utils.generate_uuid()
values['created_at'] = mysql_func.now()
# values['remote_hostname'] = None
# values['tenant_id'] = "12345"
# values['availability_zone'] = "1"
values['deleted'] = False
# values['updated_at'] = "1"
instance = cls(**values).save()
# instance._notify_fields("create")
return instance
def test_retrieve_instance(self):
name = utils.generate_uuid()
kwargs = {"name": name,
"availability_zone": "az1"}
instance = factory_models.DBInstance().create(**kwargs)
data = instance.data()
self.assertEqual(data['name'], name)
found_instance = instance.find_by(name=name)
data = found_instance.data()
self.assertEqual(data['name'], name)
def create(cls, credential, region, body, image_id, flavor_id, security_groups, key_name, userdata, files ):
# self.is_valid()
instance_name = utils.generate_uuid()
srv = cls.get_client(credential, region).servers.create(instance_name,
image_id,
flavor_id,
files=files,
key_name=key_name,
security_groups=security_groups,
userdata=userdata)
return Instance(server=srv)
def __init__(self,
tenant_id,
resource,
hard_limit,
id=utils.generate_uuid(),
created=utils.utcnow(),
update=utils.utcnow()):
self.tenant_id = tenant_id
self.resource = resource
self.hard_limit = hard_limit
self.id = id
self.created = created
self.update = update
def disabled_teardown_recreate_instance(self):
image_id, flavor_id, keypair_name, region_az, credential = self._load_boot_params(TENANT_ID, 103)
remote_hostname = utils.generate_uuid()
try:
db_instance = models.DBInstance().create(name=INSTANCE_NAME,
status='building',
remote_hostname=remote_hostname,
tenant_id=TENANT_ID,
credential=credential['id'],
port='3306',
flavor=103,
availability_zone=region_az)
except Exception, e:
LOG.exception("Error creating DB Instance record")
self.fail("Could not create a DB Instance record")
def mock_out_client_create(self):
"""Stubs out a fake server returned from novaclient.
This is akin to calling Client.servers.get(uuid)
and getting the server object back."""
self.FAKE_SERVER = self.mock.CreateMock(object)
self.FAKE_SERVER.name = 'my_name'
self.FAKE_SERVER.status = 'ACTIVE'
self.FAKE_SERVER.updated = utils.utcnow()
self.FAKE_SERVER.created = utils.utcnow()
self.FAKE_SERVER.id = utils.generate_uuid()
self.FAKE_SERVER.flavor = 'http://localhost/1234/flavors/1234'
self.FAKE_SERVER.links = [
{
"href": "http://localhost/1234/instances/123",
"rel": "self",
},
{
"href": "http://localhost/1234/instances/123",
"rel": "bookmark",
}
]
self.FAKE_SERVER.addresses = {
"private": [
{
"addr": "10.0.0.4",
"version": 4,
},
],
}
client = self.mock.CreateMock(novaclient.v1_1.Client)
servers = self.mock.CreateMock(novaclient.v1_1.servers.ServerManager)
servers.create(mox.IgnoreArg(),
mox.IgnoreArg(),
mox.IgnoreArg()).AndReturn(self.FAKE_SERVER)
client.servers = servers
self.mock.StubOutWithMock(models.NovaRemoteModelBase, 'get_client')
models.NovaRemoteModelBase.get_client(mox.IgnoreArg()). \
AndReturn(client)
def _try_create_secgroup(self, context, credential, region, name, description):
remote_name = 'dbaas-' + utils.generate_uuid()
try:
remote_sec_group = models.RemoteSecurityGroup.create(credential=credential,
region=region,
name=remote_name,
description=description)
if not remote_sec_group:
raise exception.SecurityGroupCreationFailure("Failed to create Security Group")
else:
# Create db record
sec_group = models.SecurityGroup.create(name=name,
description=description,
remote_secgroup_id=remote_sec_group.data()['id'],
remote_secgroup_name=remote_name,
user_id=context.user,
tenant_id=context.tenant,
credential=credential['id'],
availability_zone=region)
return sec_group
except exception.SecurityGroupCreationFailure, e:
LOG.exception("Failed to create remote security group")
raise e
def create(cls, **values):
values["id"] = utils.generate_uuid()
heartbeat = cls(**values).save()
if not heartbeat.is_valid():
raise exception.InvalidModelError(errors=heartbeat.errors)
return heartbeat
def test_create(self):
self.ServiceImage = {"image_id": "1240"}
self.ServiceFlavor = {"id": "1", "flavor_id": "100"}
self.ServiceKeypair = {"key_name": "dbas-dev"}
self.ServiceZone = {"availability_zone": "az2"}
self.Credential = {'id': '1'}
body = {
"instance": {
"name": "json_rack_instance",
"flavorRef": "104"
}
}
flavor = self.DUMMY_SERVER['flavor']
mock_flip_data = {"ip": "blah"}
default_quotas = [{ "tenant_id": self.tenant, "hard_limit": 3, "resource":"instances"},
{ "tenant_id": self.tenant, "hard_limit": 10, "resource":"snapshots"},
{ "tenant_id": self.tenant, "hard_limit": 20, "resource":"volume_space"}]
default_secgroup_api_response = { 'security_group' : { 'id' : '123' } }
dummy_db_secgroup = { 'id': '123', 'remote_secgroup_name': 'test' }
self.mock.StubOutWithMock(models.Quota, 'find_all')
models.Quota.find_all(tenant_id=self.tenant, deleted=False).AndReturn(default_quotas)
models.Quota.find_all(tenant_id=self.tenant, deleted=False).AndReturn(default_quotas)
self.mock.StubOutWithMock(models.ServiceZone, 'find_by')
models.ServiceZone.find_by(service_name="database", tenant_id='123', deleted=False).AndReturn(self.ServiceZone)
self.mock.StubOutWithMock(models.ServiceImage, 'find_by')
models.ServiceImage.find_by(service_name="database", tenant_id='123', availability_zone=self.ServiceZone["availability_zone"], deleted=False).AndReturn(self.ServiceImage)
self.mock.StubOutWithMock(models.ServiceFlavor, 'find_by')
models.ServiceFlavor.find_by(service_name="database", flavor_id='104', deleted=False).AndReturn(self.ServiceFlavor)
self.mock.StubOutWithMock(models.ServiceKeypair, 'find_by')
models.ServiceKeypair.find_by(service_name="database", deleted=False).AndReturn(self.ServiceKeypair)
self.mock.StubOutWithMock(models.Credential, 'find_by')
models.Credential.find_by(type="compute", deleted=False).AndReturn(self.Credential)
mock_server = self.mock.CreateMock(models.Instance(server="server", uuid=utils.generate_uuid()))
#mock_dbinstance = self.mock.CreateMock(models.DBInstance())
mock_dbinstance = {'id': 'id', 'name': 'name', 'created_at': 'created_at', 'address': 'address'}
# mock_flip = self.mock.CreateMock(models.FloatingIP(floating_ip="flip", id=123))
self.mock.StubOutWithMock(service.InstanceController, '_try_create_security_group')
service.InstanceController._try_create_security_group(mox.IgnoreArg(), mox.IgnoreArg(),
mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(default_secgroup_api_response)
self.mock.StubOutWithMock(secgroup_models.SecurityGroup, 'find_by')
secgroup_models.SecurityGroup.find_by(id='123', deleted=False).AndReturn(dummy_db_secgroup)
self.mock.StubOutWithMock(service.InstanceController, '_try_create_server')
service.InstanceController._try_create_server(mox.IgnoreArg(), mox.IgnoreArg(),
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(),
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn((self.DUMMY_SERVER, self.DUMMY_GUEST_STATUS, {'/home/nova/agent.config':'blah'}))
self.mock.StubOutWithMock(service.InstanceController, '_try_assign_floating_ip')
service.InstanceController._try_assign_floating_ip(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(self.DUMMY_FLOATING_IP)
self.mock.StubOutWithMock(service.InstanceController, '_try_attach_volume')
service.InstanceController._try_attach_volume(mox.IgnoreArg(),
mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(None)
#volume = models.Volume.create(credential, region, volume_size, 'mysql-%s' % instance['remote_id']).data()
self.mock.StubOutWithMock(worker_api.API, 'ensure_create_instance')
worker_api.API.ensure_create_instance(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(None)
#self.mock_out_client_create()
self.mock.ReplayAll()
response = self.app.post_json("%s" % (self.instances_path), body=body,
headers=self.headers,
)
self.assertEqual(response.status_int, 201)
self.mock.UnsetStubs()
LOG.debug("Using Auth-Header %s" % AUTH_HEADER)
from reddwarf.db import db_api
from reddwarf.common import config
from reddwarf.common import utils
from reddwarf.database import utils as rd_utils
from reddwarf.database import models
from reddwarf.database import worker_api
SQL_CONNECTION = os.environ['SQL_CONNECTION']
RABBIT_HOST = os.environ['RABBIT_HOST']
RABBIT_USER = os.environ['RABBIT_USER']
RABBIT_PASSWORD = os.environ['RABBIT_PASSWORD']
INSTANCE_NAME = 'dbapi_dist_health_' + utils.generate_uuid()
TIMEOUTS = {
'http': 270,
'boot': 900,
'mysql_connect': 90
}
class DistributedCreateTest(unittest.TestCase):
def setUp(self):
options = { 'sql_connection' : SQL_CONNECTION }
db_api.configure_db(options)
config.Config.instance = { "rabbit_host" : RABBIT_HOST,
"rabbit_userid" : RABBIT_USER,
class Instance(factory.Factory):
FACTORY_FOR = models.Instance
context = context.ReddwarfContext()
uuid = utils.generate_uuid()
def setUp(self):
super(TestInstance, self).setUp()
self.expected_name = 'my_name'
self.expected_id = utils.generate_uuid()
def setup_uuid_with(self, fake_uuid):
self.mock.StubOutWithMock(utils, "generate_uuid")
utils.generate_uuid().MultipleTimes().AndReturn(fake_uuid)
def setup_uuid_with(self, fake_uuid):
self.mock.StubOutWithMock(utils, "generate_uuid")
utils.generate_uuid().MultipleTimes().AndReturn(fake_uuid)
def create(cls, **values):
values['id'] = utils.generate_uuid()
heartbeat = cls(**values).save()
if not heartbeat.is_valid():
raise exception.InvalidModelError(errors=heartbeat.errors)
return heartbeat
'X-Auth-Project-Id': '%s' % TENANT_NAME}
TENANT_ID = content['access']['token']['tenant']['id']
API_URL = API_ENDPOINT + "/v1.0/" + TENANT_ID + "/"
logging.basicConfig(format='%(levelname)-8s [%(asctime)s] %(name)s: %(message)s', level=logging.DEBUG)
LOG = logging.getLogger(__name__)
LOG.debug("Response from Keystone: %s" % content)
LOG.debug("Using Auth-Token %s" % AUTH_TOKEN)
LOG.debug("Using Auth-Header %s" % AUTH_HEADER)
UUID_PATTERN = '[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'
BUILD_NUMBER = os.environ.get('BUILD_NUMBER', '')
INSTANCE_NAME = 'dbapi_health_%s_%s' % (BUILD_NUMBER, utils.generate_uuid())
TIMEOUTS = {
'https': 270,
'http': 270,
'boot': 900,
'mysql_connect': 300
}
POLL_INTERVALS = {
'boot': 10,
'snapshot': 10,
'mysql_connect': 10,
'ssh': 4
}
