def _create_server(self,
name=None,
network=None,
wait_on_boot=True,
wait_on_delete=True):
region = CONF.compute.region
image = CONF.compute.image_ref
flavor = CONF.compute.flavor_ref
rs_client = rest_client.RestClient(self.auth_provider, 'compute',
region)
data = {
'server': {
'name': name,
'imageRef': image,
'flavorRef': flavor,
'max_count': 1,
'min_count': 1,
'networks': [{
'uuid': network
}]
}
}
data = json.dumps(data)
(
resp,
body,
) = rs_client.post('/servers', data)
rs_client.expected_success(202, resp.status)
body = json.loads(body)
server_id = body['server']['id']
self.wait_for_server_status(server_id, 'ACTIVE')
return server_id
def setUp(self):
super(BaseRestClientTestClass, self).setUp()
self.rest_client = rest_client.RestClient(
fake_auth_provider.FakeAuthProvider(), None, None)
self.stubs.Set(httplib2.Http, 'request', self.fake_http.request)
self.useFixture(mockpatch.PatchObject(self.rest_client,
'_log_request'))
def _delete_server(self, server=None):
rs_client = rest_client.RestClient(self.auth_provider, 'compute',
'RegionOne')
(
resp,
body,
) = rs_client.delete('servers/%s' % str(server))
self.wait_for_server_termination(server)
rest_client.ResponseBody(resp, body)
def setUp(self):
self.fake_http = fake_http.fake_httplib2()
super(TestProperties, self).setUp()
creds_dict = {
'username': '******',
'user_id': 'test-user_id',
'tenant_name': 'test-tenant_name',
'tenant_id': 'test-tenant_id',
'password': '******'
}
self.rest_client = rest_client.RestClient(
fake_auth_provider.FakeAuthProvider(creds_dict=creds_dict), None,
None)
def wait_for_server_termination(self, server_id, ignore_error=False):
"""Waits for server to reach termination."""
build_interval = CONF.boto.build_interval
while True:
try:
rs = rest_client.RestClient(self.auth_provider, 'compute',
'RegionOne')
(
resp,
body,
) = rs.get('servers/%s' % str(server_id))
body = json.loads(body)
except lib_exc.NotFound:
return
server_status = body['server']['status']
if server_status == 'ERROR' and not ignore_error:
raise exceptions.BuildErrorException(server_id=server_id)
time.sleep(build_interval)
def wait_for_server_status(self,
server_id,
status,
ready_wait=True,
extra_timeout=0,
raise_on_error=True):
"""Waits for a server to reach a given status."""
build_timeout = CONF.compute.build_timeout
build_interval = CONF.boto.build_interval
def _get_task_state(body):
return body.get('OS-EXT-STS:task_state', None)
rs = rest_client.RestClient(self.auth_provider, "compute", "RegionOne")
resp, body = rs.get("servers/%s" % str(server_id))
body = json.loads(body)
old_status = server_status = body['server']['status']
old_task_state = task_state = _get_task_state(body)
start_time = int(time.time())
timeout = build_timeout + extra_timeout
while True:
if status == 'BUILD' and server_status != 'UNKNOWN':
return
if server_status == status:
if ready_wait:
if status == 'BUILD':
return
if str(task_state) == "None":
time.sleep(CONF.compute.ready_wait)
return
else:
return
time.sleep(build_interval)
resp, body = rs.get("servers/%s" % str(server_id))
body = json.loads(body)
server_status = body['server']['status']
task_state = _get_task_state(body)
if (server_status != old_status) or (task_state != old_task_state):
oldstatus = '/'.join((old_status, str(old_task_state)))
serverstatus = '/'.join((server_status, str(task_state)))
waitsec = (time.time() - start_time)
LOG.info(
_LI('State transtion %(oldstatus)s => %(serverstatus)s'
'after %(waitsec)d second wait') % {
'oldstatus': oldstatus,
'serverstatus': serverstatus,
'waitsec': waitsec
})
if (server_status == 'ERROR') and raise_on_error:
if 'fault' in body:
raise exceptions.BuildErrorException(body['fault'],
server_id=server_id)
else:
raise exceptions.BuildErrorException(server_id=server_id)
timed_out = int(time.time()) - start_time >= timeout
if timed_out:
expected_task_state = 'None' if ready_wait else 'n/a'
message = ('Server %(server_id)s failed to reach %(status)s '
'status and task state "%(expected_task_state)s" '
'within the required time (%(timeout)s s).' % {
'server_id': server_id,
'status': status,
'expected_task_state': expected_task_state,
'timeout': timeout
})
message += ' Current status: %s.' % server_status
message += ' Current task state: %s.' % task_state
caller = misc_utils.find_test_caller()
if caller:
message = '(%s) %s' % (caller, message)
raise exceptions.TimeoutException(message)
old_status = server_status
old_task_state = task_state
def setUp(self):
super(TestJSONSchemaValidationBase, self).setUp()
self.fake_auth_provider = fake_auth_provider.FakeAuthProvider()
self.rest_client = rest_client.RestClient(self.fake_auth_provider,
None, None)
def setUp(self):
super(TestRestClientErrorCheckerJSON, self).setUp()
self.rest_client = rest_client.RestClient(
fake_auth_provider.FakeAuthProvider(), None, None)