def process_create(self,
context,
pid,
ppid,
gid,
name,
glance_image_id,
nova_flavor_id,
nova_keypair_id,
neutron_securitygroup_ids,
neutron_network_ids,
metadata,
userdata
):
update_values = {}
try:
metadata["pid"] = pid
metadata["ppid"] = ppid
metadata["gid"] = gid
nova_instance_id = self.process_client.process_create(
name,
glance_image_id,
nova_flavor_id,
nova_keypair_id,
neutron_securitygroup_ids,
neutron_network_ids,
metadata,
userdata)
update_values["nova_instance_id"] = nova_instance_id
update_values["status"] = "ACTIVE"
db.process_update(context, gid, pid, update_values)
except Exception as e:
update_values["status"] = "ERROR"
db.process_update(context, gid, pid, update_values)
LOG.exception(e)
def test_processes_create(self):
self.mox.StubOutWithMock(self.manager.process_client,
"process_create")
pid = "pida309f-9638-44de-827d-5125ff7e9865"
ppid = "ppid309f-9638-44de-827d-5125ff7e1968"
gid = "gida309f-9638-44de-827d-5125ff7e1246"
display_name = "display_name"
glance_image_id = "5aea309f-9638-44de-827d-5125ff7e4689"
nova_flavor_id = "3"
nova_keypair_id = "test"
neutron_securitygroup_ids = [
"947dc616-e737-4cb9-b816-52ad80cb9e37",
"1892987f-3874-46ef-a487-fb8e925210ce"]
neutron_network_ids = [
"a3c6488a-a236-46f7-aab6-8f1fe91ad9ef",
"43015163-babe-4bee-8fe8-38470d28b2a2"]
metadata = {"metadata": "metadata"}
userdata = "userdata"
self.manager.process_client.process_create(display_name,
glance_image_id,
nova_flavor_id,
nova_keypair_id,
neutron_securitygroup_ids,
neutron_network_ids,
metadata,
userdata)\
.AndReturn(self.nova_instance_id)
self.mox.StubOutWithMock(db, "process_update")
db.process_update(self.context,
gid,
pid,
{"nova_instance_id": self.nova_instance_id,
"status": "ACTIVE"})
self.mox.ReplayAll()
self.manager.process_create(self.context,
pid,
ppid,
gid,
display_name,
glance_image_id,
nova_flavor_id,
nova_keypair_id,
neutron_securitygroup_ids,
neutron_network_ids,
metadata,
userdata)
def update(self, req, body, gid, pid):
def _validate(body, gid, pid):
self._uuid_check(gid, pid)
if not self.is_valid_body(body, 'process'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body["process"]
app_status = values.get("app_status")
if not app_status:
msg = _("app_status is required")
raise exception.InvalidInput(reason=msg)
valid_values = {"app_status": app_status}
return valid_values
try:
values = _validate(body, gid, pid)
context = req.environ['rack.context']
process = db.process_update(context, gid, pid, values)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.ProcessNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
return self._view_builder.update(process)
def update(self, req, body, gid):
def _validate(body, gid):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
if not self.is_valid_body(body, 'proxy'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
proxy = db.process_get_all(
context, gid, {"is_proxy": True, "status": "ACTIVE"})
if len(proxy) == 0:
msg = _("Proxy instance not exists in this group")
raise exception.ProxyNotFound(msg)
values = body["proxy"]
app_status = values.get("app_status")
if not app_status:
msg = _("app_status is required")
raise exception.InvalidInput(reason=msg)
valid_values = {}
if values.get("shm_endpoint"):
valid_values["shm_endpoint"] = values.get("shm_endpoint")
if values.get("ipc_endpoint"):
valid_values["ipc_endpoint"] = values.get("ipc_endpoint")
if values.get("fs_endpoint"):
valid_values["fs_endpoint"] = values.get("fs_endpoint")
valid_values["app_status"] = app_status
valid_values["pid"] = proxy[0]["pid"]
valid_values
return valid_values
context = req.environ['rack.context']
try:
values = _validate(body, gid)
proxy = db.process_update(context, gid, values["pid"], values)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.ProxyNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
return self._view_builder.update(proxy)
def test_process_update(self):
values_before = self._get_base_values()
process = db.process_create(self.user_ctxt,
values_before,
[self.network["network_id"]],
[self.securitygroup["securitygroup_id"]])
values = {
"display_name": "test",
"status": "ACTIVE",
"fs_endpoint": "fs_data_update"
}
process_after = db.process_update(
self.user_ctxt, self.gid, process["pid"], values)
self.assertEqual(process_after["display_name"], "test")
self.assertEqual(process_after["status"], "ACTIVE")
self.assertEqual(process_after["fs_endpoint"], "fs_data_update")
self.assertEqual(process_after["shm_endpoint"], "shm_data_original")
self.assertEqual(process_after["ipc_endpoint"], "ipc_data_original")
def update(self, req, body, gid, pid):
def _validate(body, gid, pid):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
if not uuidutils.is_uuid_like(pid):
raise exception.ProcessNotFound(pid=pid)
if not self.is_valid_body(body, 'process'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
db.process_get_by_pid(context, gid, pid)
values = body["process"]
app_status = values.get("app_status")
if not app_status:
msg = _("app_status is required")
raise exception.InvalidInput(reason=msg)
valid_values = {}
valid_values["app_status"] = app_status
return valid_values
context = req.environ['rack.context']
try:
values = _validate(body, gid, pid)
process = db.process_update(context, gid, pid, values)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.ProcessNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
return self._view_builder.update(process)
def _set_mox_db_process_update_on_error(self):
self.mox.StubOutWithMock(db, "process_update")
db.process_update(IsA(context.RequestContext), IsA(
unicode), IsA(unicode), {"status": "ERROR"})
def update_proxy(self, req, body, gid):
def _validate(context, body, gid):
self._uuid_check(gid)
process = db.process_get_all(context,
gid,
filters={"is_proxy": True})
if not process:
msg = _("Proxy process does not exist in the group %s" % gid)
raise exception.InvalidInput(reason=msg)
if not self.is_valid_body(body, 'proxy'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body["proxy"]
app_status = values.get("app_status")
ipc_endpoint = values.get("ipc_endpoint")
shm_endpoint = values.get("shm_endpoint")
fs_endpoint = values.get("fs_endpoint")
valid_values = {}
if app_status:
utils.check_string_length(app_status,
'app_status',
min_length=1,
max_length=255)
valid_values["app_status"] = app_status
if ipc_endpoint:
utils.check_string_length(ipc_endpoint,
'ipc_endpoint',
min_length=1,
max_length=255)
valid_values["ipc_endpoint"] = ipc_endpoint
if shm_endpoint:
utils.check_string_length(shm_endpoint,
'shm_endpoint',
min_length=1,
max_length=255)
valid_values["shm_endpoint"] = shm_endpoint
if fs_endpoint:
utils.check_string_length(fs_endpoint,
'fs_endpoint',
min_length=1,
max_length=255)
valid_values["fs_endpoint"] = fs_endpoint
if not valid_values:
msg = _("No keyword is provided.")
raise exception.InvalidInput(reason=msg)
return process[0]["pid"], valid_values
try:
context = req.environ['rack.context']
pid, values = _validate(context, body, gid)
process = db.process_update(context, gid, pid, values)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.ProcessNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
return self._view_builder.update(process)
def create(self, req, body, gid):
def _validate_process(context, gid, body):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
if not self.is_valid_body(body, 'process'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body["process"]
ppid = values.get("ppid")
keypair_id = values.get("keypair_id")
name = values.get("name")
glance_image_id = values.get("glance_image_id")
nova_flavor_id = values.get("nova_flavor_id")
securitygroup_ids = values.get("securitygroup_ids")
userdata = values.get("userdata")
if ppid is not None:
if not uuidutils.is_uuid_like(ppid):
raise exception.ProcessNotFound(pid=ppid)
p_process = db.process_get_by_pid(context, gid, ppid)
if keypair_id is not None:
if not uuidutils.is_uuid_like(keypair_id):
raise exception.KeypairNotFound(keypair_id=keypair_id)
elif ppid is not None:
keypair_id = p_process.get("keypair_id")
if isinstance(name, six.string_types):
name = name.strip()
utils.check_string_length(name, 'name', min_length=1,
max_length=255)
elif name is not None:
msg = _("name must be a String")
raise exception.InvalidInput(reason=msg)
if glance_image_id is None:
if ppid is not None:
glance_image_id = p_process.get("glance_image_id")
elif not uuidutils.is_uuid_like(glance_image_id):
msg = _("glance_image_id is invalid format")
raise exception.InvalidInput(reason=msg)
if nova_flavor_id is None and ppid is not None:
nova_flavor_id = p_process.get("nova_flavor_id")
utils.validate_integer(nova_flavor_id, 'nova_flavor_id')
if not securitygroup_ids:
if ppid is not None:
securitygroup_ids = [securitygroup.get("securitygroup_id")
for securitygroup in p_process.get(
"securitygroups")]
else:
msg = _("securitygroup_ids is required")
raise exception.InvalidInput(reason=msg)
if isinstance(securitygroup_ids, list):
for securitygroup_id in securitygroup_ids:
if securitygroup_id is not None and not uuidutils\
.is_uuid_like(securitygroup_id):
raise exception.SecuritygroupNotFound(
securitygroup_id=securitygroup_id)
else:
msg = _("securitygroup_ids must be list")
raise exception.InvalidInput(reason=msg)
if userdata:
try:
userdata = base64.b64decode(userdata)
except TypeError as e:
raise webob.exc.HTTPBadRequest(
explanation=e.format_message())
valid_values = {}
valid_values_process = {}
valid_values_process["gid"] = gid
valid_values_process["keypair_id"] = keypair_id
valid_values_process["ppid"] = ppid
valid_values_process["display_name"] = name
valid_values_process["glance_image_id"] = glance_image_id
valid_values_process["nova_flavor_id"] = nova_flavor_id
valid_values_process["is_proxy"] = False
valid_values_process["app_status"] = "BUILDING"
valid_values_userdata = {}
valid_values_userdata["userdata"] = userdata
valid_values_securitygroup = {}
valid_values_securitygroup["securitygroup_ids"] = securitygroup_ids
valid_values["process"] = valid_values_process
valid_values["userdata"] = valid_values_userdata
valid_values["securitygroup"] = valid_values_securitygroup
return valid_values
def _validate_metadata(metadata):
if metadata is None:
return {}
if not isinstance(metadata, dict):
msg = _("metadata must be a dict")
raise exception.InvalidInput(reason=msg)
return metadata
try:
context = req.environ['rack.context']
valid_values = _validate_process(context, gid, body)
values = valid_values.get("process")
securitygroup_ids = valid_values.get(
"securitygroup").get("securitygroup_ids")
metadata = _validate_metadata(metadata=body["process"]
.get("args"))
metadata.update({"proxy_ip": cfg.CONF.my_ip})
userdata = valid_values.get("userdata")
values["deleted"] = 0
values["status"] = "BUILDING"
values["pid"] = unicode(uuid.uuid4())
values["user_id"] = context.user_id
values["project_id"] = context.project_id
values["display_name"] = values[
"display_name"] or "pro-" + values["pid"]
values["userdata"] = userdata.get("userdata")
if values["ppid"]:
db.process_get_by_pid(context, gid, values["ppid"])
if values["keypair_id"]:
nova_keypair_id = db.keypair_get_by_keypair_id(
context, gid, values["keypair_id"]).get("nova_keypair_id")
else:
nova_keypair_id = None
networks = db.network_get_all(context, gid, {"status": "ACTIVE"})
if not networks:
raise exception.NoNetworksFound(gid=values["gid"])
network_ids = [network["network_id"] for network in networks]
process = db.process_create(
context, values, network_ids, securitygroup_ids)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.NotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
try:
host = self.scheduler_rpcapi.select_destinations(
context,
request_spec={},
filter_properties={})
self.operator_rpcapi.process_create(
context,
host["host"],
pid=values["pid"],
ppid=values["ppid"] or values["pid"],
gid=gid,
name=values["display_name"],
glance_image_id=values["glance_image_id"],
nova_flavor_id=values["nova_flavor_id"],
nova_keypair_id=nova_keypair_id,
neutron_securitygroup_ids=[securitygroup[
"neutron_securitygroup_id"]
for securitygroup in process["securitygroups"]],
neutron_network_ids=[network["neutron_network_id"]
for network in process["networks"]],
metadata=metadata,
userdata=userdata.get("userdata"))
except Exception as e:
LOG.exception(e)
pid = values["pid"]
db.process_update(context, gid, pid, {"status": "ERROR"})
raise exception.ProcessCreateFailed()
return self._view_builder.create(process)
def create(self, req, body, gid):
def _validate_proxy(context, gid, body):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
proxy = db.process_get_not_error_status_for_proxy(context, gid)
if len(proxy) > 0:
msg = _("Proxy instance already exists in this group")
raise exception.ProxyCreateFailed(msg)
if not self.is_valid_body(body, 'proxy'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body["proxy"]
keypair_id = values.get("keypair_id")
name = values.get("name")
glance_image_id = values.get("glance_image_id")
nova_flavor_id = values.get("nova_flavor_id")
securitygroup_ids = values.get("securitygroup_ids")
userdata = values.get("userdata")
if keypair_id is not None:
if not uuidutils.is_uuid_like(keypair_id):
raise exception.KeypairNotFound(keypair_id=keypair_id)
if isinstance(name, six.string_types):
name = name.strip()
utils.check_string_length(name, 'name', min_length=1,
max_length=255)
elif name is not None:
msg = _("name must be a String")
raise exception.InvalidInput(reason=msg)
if not uuidutils.is_uuid_like(glance_image_id):
msg = _("glance_image_id is invalid format")
raise exception.InvalidInput(reason=msg)
utils.validate_integer(nova_flavor_id, 'nova_flavor_id')
if not securitygroup_ids:
msg = _("securitygroup_ids is required")
raise exception.InvalidInput(reason=msg)
if isinstance(securitygroup_ids, list):
for securitygroup_id in securitygroup_ids:
if securitygroup_id is not None and not uuidutils\
.is_uuid_like(securitygroup_id):
raise exception.SecuritygroupNotFound(
securitygroup_id=securitygroup_id)
else:
msg = _("securitygroup_ids must be list")
raise exception.InvalidInput(reason=msg)
if userdata:
try:
userdata = base64.b64decode(userdata)
except TypeError as e:
raise webob.exc.HTTPBadRequest(
explanation=e.format_message())
valid_values = {}
valid_values_proxy = {}
valid_values_proxy["gid"] = gid
valid_values_proxy["keypair_id"] = keypair_id
valid_values_proxy["display_name"] = name
valid_values_proxy["glance_image_id"] = glance_image_id
valid_values_proxy["nova_flavor_id"] = nova_flavor_id
valid_values_proxy["is_proxy"] = True
valid_values_proxy["app_status"] = "BUILDING"
valid_values_userdata = {}
valid_values_userdata["userdata"] = userdata
valid_values_securitygroup = {}
valid_values_securitygroup["securitygroup_ids"] = securitygroup_ids
valid_values["proxy"] = valid_values_proxy
valid_values["userdata"] = valid_values_userdata
valid_values["securitygroup"] = valid_values_securitygroup
return valid_values
def _validate_metadata(args):
if args is None:
return dict(roles="ipc/shm/api/proxy")
else:
if not isinstance(args, dict):
msg = _("args must be a dict")
raise exception.InvalidInput(reason=msg)
if args.get("roles"):
args["roles"] = args.get("roles") + "/proxy"
else:
args["roles"] = "ipc/shm/api/proxy"
return args
def _get_proxy_conf():
conf = {}
expr = "(127.0.0.1|localhost)"
conf.update(dict(rabbit_userid=cfg.CONF.rabbit_userid))
conf.update(dict(rabbit_password=cfg.CONF.rabbit_password))
conf.update(
dict(rabbit_host=re.sub(expr, cfg.CONF.my_ip,
cfg.CONF.rabbit_host)))
conf.update(
dict(sql_connection=re.sub(expr, cfg.CONF.my_ip,
cfg.CONF.sql_connection)))
return conf
try:
context = req.environ['rack.context']
valid_values = _validate_proxy(context, gid, body)
values = valid_values.get("proxy")
securitygroup_ids = valid_values.get(
"securitygroup").get("securitygroup_ids")
userdata = valid_values.get("userdata")
args = _validate_metadata(body["proxy"].get("args"))
metadata = dict(args)
metadata.update(_get_proxy_conf())
values["deleted"] = 0
values["status"] = "BUILDING"
values["pid"] = unicode(uuid.uuid4())
values["user_id"] = context.user_id
values["project_id"] = context.project_id
values["display_name"] = values[
"display_name"] or "pro-" + values["pid"]
values["userdata"] = userdata.get("userdata")
values["args"] = json.dumps(args)
if values["keypair_id"]:
nova_keypair_id = db.keypair_get_by_keypair_id(
context, gid, values["keypair_id"]).get("nova_keypair_id")
else:
nova_keypair_id = None
networks = db.network_get_all(context, gid, {"status": "ACTIVE"})
if not networks:
raise exception.NoNetworksFound(gid=values["gid"])
network_ids = [network["network_id"] for network in networks]
proxy = db.process_create(
context, values, network_ids, securitygroup_ids)
except exception.ProxyCreateFailed as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
try:
host = self.scheduler_rpcapi.select_destinations(
context,
request_spec={},
filter_properties={})
self.operator_rpcapi.process_create(
context,
host["host"],
pid=values["pid"],
ppid="",
gid=gid,
name=values["display_name"],
glance_image_id=values["glance_image_id"],
nova_flavor_id=values["nova_flavor_id"],
nova_keypair_id=nova_keypair_id,
neutron_securitygroup_ids=[securitygroup[
"neutron_securitygroup_id"]
for securitygroup in proxy["securitygroups"]],
neutron_network_ids=[network["neutron_network_id"]
for network in proxy["networks"]],
metadata=metadata,
userdata=userdata.get("userdata"))
except Exception as e:
LOG.exception(e)
pid = values["pid"]
db.process_update(context, gid, pid, {"status": "ERROR"})
raise exception.ProcessCreateFailed()
return self._view_builder.create(proxy)
