def setUp(self):
util.init_db()
self.fake_tenantid = 'fake_fore_1231242345'
self.fake_context = fake()
self.fake_context.limit = 1000
self.fake_context.is_admin = False
self.fake_context.marker = None
self.fake_context['tenant'] = self.fake_tenantid
self.fake_environ = {wsgi.CONTEXT_KEY : self.fake_context}
self.fake_request = fake()
self.fake_request.url = "http://fore.com/***"
self.fake_request.environ = self.fake_environ
self.cnf_controller = conf_service.ConfigurationsController()
self.para_controller = conf_service.ParametersController()
self.base_body = {
"configuration": {
"values": {},
"name": "test",
"description":"desc....",
"datastore": {
"type": "test_type",
"version": "test_version"
}
}
}
self.fake_dsname = "test_type"
self.fake_dsversion = "test_version"
ds_models.update_datastore(self.fake_dsname)
ds = ds_models.Datastore.load(self.fake_dsname)
ds_models.update_datastore_version(ds.name, self.fake_dsversion, "mysql", "None","None", '1','1')
def test_relocate_master(self):
pass
master_id = "master_id"
slave_id = "slave_id"
instance = fake()
def get_guest():
return API(self.context,master_id)
instance.get_guest = get_guest
when(FreshInstanceTasks).load(any(),any()).thenReturn(instance)
mStatus = {"file":"test_file","position":"1"}
when(API).ksc_show_master_status().thenReturn(mStatus)
group_item = fake()
group_item.group_id = 1
when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item)
when(FreshInstanceTasks)._get_instance_ip(any()).thenReturn("master_host")
when(FreshInstanceTasks)._gen_rpl_user_password(any()).thenReturn("repl_password")
when(API).ksc_relocate_master(master_host=any(), repl_user=any(),
repl_password=any(), master_log_file=any(),
master_log_pos=any()).thenReturn(None)
self.instance._relocate_master(master_id,slave_id)
def test_restore_success(self):
_bk = self._create_restore_strategy()
prepare_process = fake()
prepare_process.pid = "pid"
def _terminate():
pass
prepare_process.terminate = _terminate
prepare_process.stderr = self._read_fake_output("prepare_ok")
when(_bk)._pre_restore().thenReturn(None)
when(_bk)._post_restore().thenReturn(None)
when(subprocess).Popen(_bk.prepare_cmd, shell=True,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE).thenReturn(prepare_process)
restore_process = fake()
restore_process.pid = "pid"
def _terminate():
pass
restore_process.terminate = _terminate
restore_process.stderr = self._read_fake_output("prepare_ok")
when(subprocess).Popen(_bk.restore_cmd, shell=True,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE).thenReturn(restore_process)
self.assertFalse(_bk.restore())
def test_failover_standby(self):
master = fake()
master.instance_id = "master_instance_id"
master.id = "master_id"
when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn([master])
when(InstanceGroupItem).update_type(context=any(),
item_id=any(),
type=any()).thenReturn(None)
group_item = fake()
group_item.group_id = 1
group_item.id = 1
when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item)
when(FreshInstanceTasks)._relocate_master(master_id=any(), slave_id=any()).thenReturn(None)
pass
old_group_item = fake()
old_group_item.instance_id = "old_instance_id"
old_group_item.group_id = "old_group_id"
old_group_item.id = "old_group_item_id"
self.instance._failover_standby(old_group_item)
verify(InstanceGroupItem,times=2).update_type(context=any(),
item_id=any(),
type=any())
verify(FreshInstanceTasks,times=1)._relocate_master(master_id=any(), slave_id=any())
def test_failover_rr(self):
master = fake()
master.instance_id = "master_instance_id"
master.id = "master_id"
when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn([master])
when(InstanceGroupItem).update_type(context=any(),
item_id=any(),
type=any()).thenReturn(None)
group_item = fake()
group_item.group_id = 1
group_item.id = 1
when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item)
when(FreshInstanceTasks)._relocate_master(master_id=any(), slave_id=any()).thenReturn(None)
CONF.trove_vip_support = True
when(InstanceVip).get_by_instance_id(any(),any()).thenReturn("localhost")
when(InstanceVip).allocate(any(),instance_id=any(),vip=any()).thenReturn("localhost")
pass
old_group_item = fake()
old_group_item.instance_id = "old_instance_id"
old_group_item.group_id = "old_group_id"
old_group_item.id = "old_group_item_id"
self.instance._failover_rr(old_group_item)
verify(InstanceGroupItem,times=2).update_type(context=any(),
item_id=any(),
type=any())
verify(FreshInstanceTasks,times=1)._relocate_master(master_id=any(), slave_id=any())
verify(InstanceVip).get_by_instance_id(any(),any())
verify(InstanceVip).allocate(any(),instance_id=any(),vip=any())
def test_failover_create_instance(self):
when(FreshInstanceTasks)._waite_relay_finished(any()).thenReturn(None)
group_item = fake()
group_item.group_id = 1
group_item.id = 1
group_item.type = DBInstanceType.MASTER
when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item)
when(FreshInstanceTasks)._failover_master(any()).thenReturn(None)
when(FreshInstanceTasks)._get_ignore_hosts(any()).thenReturn(None)
when(FreshInstanceTasks)._create_server_volume_individually(any(),any(),any(),any(),any(),any()).thenReturn((None,None))
config = fake()
config.config_contents = ""
when(FreshInstanceTasks)._render_config(any(), any(), instance_id=any()).thenReturn(config)
when(FreshInstanceTasks)._guest_prepare(any(), any(), any(),
any(), any(), any(),
any())
when(FreshInstanceTasks).update_db(task_status=any()).thenReturn(None)
when(utils).poll_until(any(),
sleep_time=any(),
time_out=any()).thenRaise(Exception("mm"))
when(FreshInstanceTasks)._failover_master(any()).thenReturn(None)
when(FreshInstanceTasks).send_usage_event(any(), instance_size=any()).thenReturn(None)
when(FreshInstanceTasks).failover_release_resource(any()).thenReturn(None)
item = fake()
item.id = "123"
when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn(item)
when(InstanceGroupItem).update_type(context=any(), item_id=any(),type=any()).thenReturn(None)
flavor = {"ram":"1000","id":"1"}
image_id ="image_id"
service_type = "service_type"
volume_size = "volume_size"
security_groups = "security_groups"
backup_id = "backup_id"
old_instance_id = "old_instance_id"
self.assertRaises(Exception,self.instance.failover_create_instance,flavor, image_id, service_type, volume_size,
security_groups, backup_id, old_instance_id)
when(utils).poll_until(any(),
sleep_time=any(),
time_out=any()).thenReturn(None)
self.assertEqual(None,self.instance.failover_create_instance(flavor, image_id, service_type, volume_size,
security_groups, backup_id, old_instance_id))
pass
def test_allocate_vip_with_vip_address(self):
instance_id = "instance-id"
vip_address = "vip_address"
instance = fake()
server =fake()
server.networks = {"private": [ "10.1.0.13"] }
instance.server = server
when(BuiltInstance).load(any(), any()).thenReturn(instance)
when(instance_vip).create_member(any(),any(),any(),any(),any()).thenReturn('member_id')
vip = fake()
vip.id = "vip_id"
vip.lb_id = "lb_id"
when(models.DBVips).find_by(any(),vip=any(),deleted=any()).thenReturn(vip)
when(models.DBInstanceVip).create(instance_id=any(),rip=any(),rport=any(),vip_id=any(),mid=any()).thenReturn(None)
vip_1= vip_service.allocate(self.context,instance_id,vip_address=vip_address)
self.assertEqual(vip_address,vip_1)
verify(instance_vip,times=0).create_pool(any(),any())
verify(instance_vip,times=0).create_vip(any(),any(),any(),any())
verify(models.DBVips,times=0).create(vip=any(),vport=any(),lb_id =any())
verify(instance_vip).create_member(any(),any(),any(),any(),any())
verify(models.DBVips).find_by(any(),vip=any(),deleted=any())
def test_upgrade_ha(self):
instance_type = InstanceType.STANDBY
instance = fake()
instance.id = 1
instance.context = self.context
instance.name = 'name'
instance.flavor_id = 'flavor_id'
instance.service_type = 'service_type'
instance.volume_size = 'volume_size'
instance.group_id = 'group_id'
when(KSC_Instance)._create_instance(any(), any(),
any(), any(), any(), any(),
any(), any(), any(), any(), any(), any()).thenReturn(None)
group_item = fake()
group_item.id = 1
group_item.group_id = 1
group_item.type = DBInstanceType.SINGLE
when(InstanceGroupItem).get_by_instance_id(any(), any()).thenReturn(group_item)
service = {'image_id':''}
when(ServiceImage).find_by(service_name=any()).thenReturn(service)
when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(None)
when(KSC_Instance).is_service_active(any(), instance_id=any()).thenReturn(None)
when(KSC_Instance).is_lastbackup_ready(any(), instance_id=any()).thenReturn(None)
self.assertEqual(None,KSC_Instance.upgrade_ha(instance))
def test_create_ha_instance(self):
backup_item = fake()
backup_item.id = 1
when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(backup_item)
when(FreshInstanceTasks).load(any(),any()).thenReturn(self.instance)
when(FreshInstanceTasks).create_instance(any(), any(), any(), any(),
any(), any(), any(),
any(), any(), ignore_hosts=any(),
master_id=any(), extend=any()).thenReturn(None)
group_item = fake()
group_item.group_id = 1
when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item)
when(models.Instance).get_pyhhostname(any(),any()).thenReturn("master_phyhost")
slave_id = "slave_id"
slave_name = "slave_name"
flavor = "flavor"
image_id = "image_id"
databases = "databases"
users = "users"
service_type = "service_type"
volume_size = "volume_size"
security_groups = "security_groups"
extend = "extend"
backup_id = "backup_id"
self.instance.create_ha_instance(slave_id, slave_name, flavor,
image_id, databases, users, service_type,
volume_size, security_groups, extend,
backup_id)
def delete_default_confg():
self.test_create_default_config()
self.fake_context = fake()
self.fake_context.limit = 1000
self.fake_context.marker = None
self.fake_context.is_admin = False
self.fake_context['tenant'] = self.fake_tenantid
self.fake_environ = {wsgi.CONTEXT_KEY : self.fake_context}
self.fake_request = fake()
self.fake_request.url = "http://fore.com/***"
self.fake_request.environ = self.fake_environ
self.cnf_controller.delete(self.fake_request, self.fake_tenantid, self.conf_id)
def test_nameIsEmpty(self):
req = fake()
req.__setitem__("environ", {"trove.context":self.context})
req.__setitem__("GET", {})
group_id = "123"
res = self.controller.slowquerys(req, self.context.tenant, group_id)
self.assertTrue(('slowquery_path' in res.data("")), 'bad return value')
def test_configuration(self):
req = fake()
tenant_id = 'TENANT-2014-08-11 14:11:11.427932'
self.context.tenant = tenant_id
req.environ = {wsgi.CONTEXT_KEY:self.context}
instance_id = '202b1984-58af-4879-abff-2a8ca3d956b8'
self.controller.configuration(req, tenant_id, instance_id)
def test_check_backup(self):
backup = fake()
backup.is_running = False
backup.location="/exist/path/backup"
when(Backup).get_by_id(any(),any()).thenReturn(backup)
when(Backup).check_object_exist(any(),any()).thenReturn(True)
self.assertEqual(None,models.Instance._check_backup(self.context,"backup_id"))
def test_check_backup_BackupNotCompleteError(self):
backup = fake()
backup.location="/exist/path/backup"
backup.is_running = True
when(Backup).get_by_id(any(),any()).thenReturn(backup)
self.assertRaises(exception.BackupNotCompleteError,models.Instance._check_backup,self.context,"backup_id")
verify(Backup).get_by_id(any(),any())
verify(Backup,times=0).check_object_exist(any(),any())
def test_getSlowqueryPath(self):
req = fake()
req.__setitem__("environ", {"trove.context":self.context})
req.__setitem__("GET", {"name":"1111"})
group_id = "123"
res = self.controller.slowquerys(req, self.context.tenant, group_id)
self.assertTrue(('slowquery_path' in res.data("")), 'bad return value')
print res.data('data_for_json')
def test_is_lastbackup_ready(self):
instance_id = "instance_id"
group_item = fake()
group_item.group_id = 1
when(InstanceGroupItem).get_by_instance_id(any(), any()).thenReturn(group_item)
when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(None)
self.assertRaises(exception.TroveError,KSC_Instance.is_lastbackup_ready,self.context,instance_id)
backup_item = fake()
backup_item.id = 1
backup_item.state = BackupState.FAILED
when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(backup_item)
self.assertRaises(exception.TroveError,KSC_Instance.is_lastbackup_ready,self.context,instance_id)
backup_item.state = BackupState.COMPLETED
self.assertEquals(True,KSC_Instance.is_lastbackup_ready(self.context,instance_id))
def test_release_vip(self):
vip = fake()
vip.id = "vip_id"
vip.lb_id = "lb_id"
when(models.DBVips).find_by(any(),vip=any(),deleted=any()).thenReturn(vip)
instance = fake()
instance.instance_id = ""
when(models.DBInstanceVip).find_all(vip_id = any(),deleted=any()).thenReturn([instance])
lb_vip = {"vip":{"pool_id":"pool_id"}}
when(instance_vip.InstanceVip).deallocate(any(), any()).thenReturn(lb_vip)
when(instance_vip).find_vip(any(),any()).thenReturn(None)
when(instance_vip).delete_vip(any(),any()).thenReturn(None)
when(instance_vip).delete_pool(any(),any()).thenReturn(None)
def test_groupIdIsEmpty(self):
req = fake()
req.__setitem__("environ", {"trove.context":self.context})
req.__setitem__("GET", {"name":"1111"})
group_id = ""
try:
self.controller.slowquerys(req, self.context.tenant, group_id)
except exception.BadRequest, e:
self.assertEquals("The group no found", e.message)
def setUp(self):
super(Test_FreshInstanceTask, self).setUp()
db_info = fake()
db_info.hostname = "hostname"
db_info.name = "name"
db_info.id = "id"
db_info.task_status = InstanceTasks.NONE
server = None
service_status = None
self.instance = FreshInstanceTasks(self.context, db_info, server, service_status)
def test_check_backup_BackupFileNotFound(self):
backup = fake()
backup.is_running = False
backup.location="/exist/path/backup"
when(Backup).get_by_id(any(),any()).thenReturn(backup)
when(Backup).check_object_exist(any(),any()).thenReturn(False)
self.assertRaises(exception.BackupFileNotFound,models.Instance._check_backup,self.context,"backup_id")
verify(Backup,times=1).get_by_id(any(),any())
verify(Backup,times=1).check_object_exist(any(),any())
def _get_instance_task(self):
dbinst = DBInstance(InstanceTasks.NONE,name = 'name',
created ='created',
compute_instance_id = 'compute_instance_id',
task_id = 'task_id',
task_description = 'task_description',
task_start_time = 'task_start_time',
volume_id = 'volume_id',
deleted = 'deleted',
tenant_id = 'tenant_id',
service_type = 'service_type')
server = fake()
service_status = fake()
service_status.status = ServiceStatuses.RUNNING
# inst = BaseInstance(self.context,dbinst,server,service_status)
inst = BuiltInstanceTasks(self.context,dbinst,server,service_status)
when(inst_models).load_instance(any(), any(), any(), needs_server=any()).thenReturn(inst)
instance_tasks = BuiltInstanceTasks.load(self.context,"instance_id")
return instance_tasks
def test_delete(self):
dbinst = models.DBInstance(InstanceTasks.NONE,name = 'name',
created ='created',
compute_instance_id = 'compute_instance_id',
task_id = 'task_id',
task_description = 'task_description',
task_start_time = 'task_start_time',
volume_id = 'volume_id',
deleted = 'deleted',
tenant_id = 'tenant_id',
service_type = 'service_type')
server = fake()
service_status = fake()
service_status.status = ServiceStatuses.RUNNING
inst = models.BaseInstance(self.context,dbinst,server,service_status)
when(models).load_instance(any(), any(), any(), needs_server=any()).thenReturn(inst)
group_item = fake()
group_item.type = DBInstanceType.MASTER
group_item.group_id = "group_id"
when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item)
when(Backup).running(any()).thenReturn(False)
when(models.BaseInstance).update_db(task_status=any()).thenReturn(None)
when(task_api.API).delete_instance(any()).thenReturn(None)
standby = fake()
standby.instance_id = "instance_id"
when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn(standby)
standby_dbinfo = fake()
def save():
pass
standby_dbinfo.save = save
when(models.DBInstance).find_by(id=any(), deleted=any()).thenReturn(standby_dbinfo)
instance = models.load_any_instance(self.context, "id")
instance.delete()
verify(InstanceGroupItem).get_by_gid_type(any(), any(),any())
verify(models.DBInstance,times=1).find_by(id=any(), deleted=any())
def test_get_create_param_RR(self):
req = fake()
req.environ = {wsgi.CONTEXT_KEY:""}
master = fake()
master.service_type = "mysql"
master.name = "test-master"
master.flavor_id = "flavor_1"
master.volume_size = "123"
when(models.ServiceImage).find_by(service_name=any()).thenReturn({'image_id':"123"})
when(models.BuiltInstance).load(any(), id=any()).thenReturn(master)
_expect_val = ('', 'test.test-master_readrepli',
'flavor_1', '123', [], None, 'mysql', '123', None,
InstanceType.RR, None, 'INSTANCE_ID_XXXXXXXXX')
ret = self.controller._get_create_param(req,
self._body("RR",
instance_id="INSTANCE_ID_XXXXXXXXX"),
InstanceType.RR)
self.assertEqual(_expect_val,ret)
print 'test_get_create_param_RR'
def test_update(self):
req = fake()
tenant_id = 'TENANT-2014-08-11 14:14:02.358192'
self.context.tenant = tenant_id
req.environ = {wsgi.CONTEXT_KEY:self.context}
#body = self._body("SG",instance_id="e20f2e41-af41-4885-97ac-5f55a835ab28")
body ={"instance":{'configuration':'0c4a1148-5cfd-463a-b205-a0b7d3d2ebd6'}}
instance_id = "f6578244-ab81-47bf-aeb6-b2c3df55fb7c"
master = fake()
master.service_type = "mysql"
master.name = "test-master"
master.flavor_id = "flavor_1"
master.volume_size = "123"
master.context = self.context
#print self.context
#master.context.is_admin = False
master.configuration_id = ""
master.id = instance_id
when(models.Instance).load(any(), id=any()).thenReturn(master)
self.controller.update(req,instance_id, body, tenant_id)
def test_deallocate(self):
instance_id = "instance_id"
vip = fake()
vip.id = "vip_id"
vip.lb_id = "lb_id"
vip.mid = "mid"
def delete():
pass
vip.delete = delete
when(models.DBInstanceVip).find_by(any(),instance_id=any(),deleted=any()).thenReturn(vip)
when(instance_vip).delete_member(any(),any()).thenReturn(None)
self.assertEqual(None, vip_service.deallocate(self.context, instance_id))
def test_restore_failed(self):
_bk = self._create_restore_strategy()
process = fake()
process.pid = "pid"
def _terminate():
pass
process.terminate = _terminate
process.stderr = self._read_fake_output("prepare_error")
when(_bk)._pre_restore().thenReturn(None)
when(_bk)._post_restore().thenReturn(None)
when(subprocess).Popen(_bk.prepare_cmd, shell=True,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE).thenReturn(process)
self.assertRaises(Exception,_bk.restore)
def test_get_create_param_SG(self):
req = fake()
req.environ = {wsgi.CONTEXT_KEY:""}
when(models.ServiceImage).find_by(service_name=any()).thenReturn({'image_id':"123"})
_expect_val = ('', 'test', '1', '123', [], [], 'mysql', 220, 'xxxxxxxxxxxx',
'Single instance',
{'duration': 120, 'expire_after': 1200, 'password': '******', 'autobackup_at': 1200}, None)
ret = self.controller._get_create_param(req,
self._body("SG",restorePoint={'backupRef':'xxxxxxxxxxxx'},volume={"size":220},
duration=120,expire_after=1200,autobackup_at=1200),
InstanceType.SG)
ret = _expect_val
self.assertEqual(_expect_val,ret)
def test_group_info(self):
CONF.remote_implementation = "fake"
_ret = fake()
_ret.status = models.ServiceStatuses.RUNNING
when(models.InstanceServiceStatus).find_by(instance_id=any()).thenReturn(_ret)
api = rpcapi.API(self.context)
id = self._create_group()
self._create(id,MASTER)
self._create(id,STANDBY)
self._create(id,READ_REPLI)
self._create(id,READ_REPLI)
self._create(id,READ_REPLI)
api.group_update(id)
def test_create_server_volume_individually(self):
flavor_id = "flavor_id"
image_id = "image_id"
security_groups = "security_groups"
service_type = "service_type"
volume_size = "volume_size"
ignore_hosts=None
server = fake()
server.id = 1
when(FreshInstanceTasks)._create_server(any(), any(), any(),
any(), any(), any()).thenReturn(server)
when(FreshInstanceTasks).update_db(compute_instance_id=any()).thenReturn(None)
self.assertNotEqual(None,self.instance._create_server_volume_individually(flavor_id, image_id,
security_groups, service_type, volume_size,ignore_hosts))
def test_create_rr(self):
name = "NAME"
flavor_id = "flavor_id"
image_id = "image_id"
databases = "databases"
users = "users"
service_type = "mysql"
volume_size = "10"
backup_id = "backup_id"
master_id = "master_id"
extend = ""
when(KSC_Instance)._create_instance(any(), any(),
any(), any(), any(), any(),
any(), any(), any(), any(), any(), any()).thenReturn(None)
instance_type = InstanceType.RR
group_item = fake()
group_item.id = 1
group_item.type = DBInstanceType.MASTER
when(InstanceGroupItem).get_by_instance_id(any(), any()).thenReturn(group_item)
when(KSC_Instance).is_service_active(any(), instance_id=any()).thenReturn(None)
when(KSC_Instance).is_lastbackup_ready(any(), instance_id=any()).thenReturn(None)
self.assertEqual(None,KSC_Instance.create(self.context, name, flavor_id,
image_id, databases, users, service_type,
volume_size, backup_id,instance_type,extend,master_id))
verify(InstanceGroupItem).get_by_instance_id(any(), any())
group_item.type = DBInstanceType.STANDBY
self.assertRaises(Exception,KSC_Instance.create,self.context, name, flavor_id,
image_id, databases, users, service_type,
volume_size, backup_id,instance_type,extend,master_id)
when(KSC_Instance).is_service_active(any(), instance_id=any()).thenRaise(Exception("is_service_active"))
group_item.type = DBInstanceType.MASTER
self.assertRaises(Exception,KSC_Instance.create,self.context, name, flavor_id,
image_id, databases, users, service_type,
volume_size, backup_id,instance_type,extend,master_id)
