def test_group_get_by_gid_not_found(self):
# test
user_id = "user_id_01"
ctext = context.RequestContext(
user_id=user_id, project_id=user_id)
gid = "00000000-0000-0000-0000-000000000010"
status_code = 200
try:
db.group_get_by_gid(ctext, gid)
except Exception as e:
status_code = e.code
self.assertEqual(status_code, 404)
def create(self, req, body, gid):
def _validate(context, body, gid):
if not self.is_valid_body(body, 'keypair'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
self._uuid_check(gid)
values = body["keypair"]
name = values.get("name")
is_default = values.get("is_default")
if is_default:
try:
is_default = strutils.bool_from_string(is_default,
strict=True)
keypairs = db.keypair_get_all(context,
gid,
filters={"is_default": True})
if keypairs:
msg = _("Default keypair already exists in the "
"group %s" % gid)
raise exception.InvalidInput(reason=msg)
except ValueError:
msg = _("is_default must be a boolean")
raise exception.InvalidInput(reason=msg)
else:
is_default = False
valid_values = {}
valid_values["gid"] = gid
valid_values["display_name"] = name
valid_values["is_default"] = is_default
return valid_values
try:
context = req.environ['rack.context']
values = _validate(context, body, gid)
db.group_get_by_gid(context, gid)
values["keypair_id"] = unicode(uuid.uuid4())
if not values["display_name"]:
values["display_name"] = "keypair-" + values["keypair_id"]
result_value = self.manager.keypair_create(context,
values["display_name"])
values.update(result_value)
values["user_id"] = context.user_id
values["project_id"] = context.project_id
keypair = db.keypair_create(context, values)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.GroupNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
return self._view_builder.create(keypair)
def test_create_exception_HTTPNotFound_gid_not_found(self):
self.mox.StubOutWithMock(db, "group_get_by_gid")
db.group_get_by_gid(IsA(context.RequestContext),
GID)\
.AndRaise(exception.GroupNotFound(gid=GID))
self.mox.ReplayAll()
name = "test_securitygroup"
request_body = {"securitygroup": {"name": name, "is_default": "true"}}
url = get_base_url(GID)
req = get_request(url, 'POST', request_body)
res = req.get_response(self.app)
self.assertEqual(res.status_code, 404)
def test_create_raise_exception_by_db_keypair_create(self):
self.mox.StubOutWithMock(db, "group_get_by_gid")
db.group_get_by_gid(IsA(context.RequestContext), GID)\
.AndRaise(exception.GroupNotFound(gid=GID))
self.mox.ReplayAll()
request_body = {
"keypair": {
"name": "test_key",
}
}
url = '/v1/groups/' + GID + '/keypairs'
req = get_request(url, 'POST', request_body)
res = req.get_response(self.app)
self.assertEqual(res.status_code, 404)
def test_create_raise_exception_by_db_keypair_create(self):
self.mox.StubOutWithMock(db, "group_get_by_gid")
db.group_get_by_gid(IsA(context.RequestContext), GID)\
.AndRaise(exception.GroupNotFound(gid=GID))
self.mox.ReplayAll()
request_body = {
"keypair": {
"name": "test_key",
}
}
url = '/v1/groups/' + GID + '/keypairs'
req = get_request(url, 'POST', request_body)
res = req.get_response(self.app)
self.assertEqual(res.status_code, 404)
def test_group_get_by_gid(self):
# set test data
groups = [
{
"display_name": "display_name_01",
"display_description": "display_description_01",
},
{
"display_name": "display_name_02",
"display_description": "display_description_02",
},
{
"display_name": "display_name_03",
"display_description": "display_description_03",
},
{
"display_name": "display_name_04",
"display_description": "display_description_04",
}
]
# create test data to group table
user_id = "user_id_01"
created_groups = [self._create_group(
group, user_id=user_id, project_id=user_id)for group in groups]
gid = created_groups[1]["gid"]
# test
ctext = context.RequestContext(
user_id=user_id, project_id=user_id)
res_group = db.group_get_by_gid(ctext, gid)
ignored_keys = ['deleted', 'deleted_at', 'updated_at',
'created_at']
self._assertEqualObjects(res_group, created_groups[1], ignored_keys)
def test_create_validate_exception_by_gid_notfound(self):
self.mox.StubOutWithMock(db, "group_get_by_gid")
db.group_get_by_gid(IsA(context.RequestContext),
GID).AndRaise(exception.GroupNotFound(gid=GID))
self.mox.ReplayAll()
request_body = {
"network": {
"name": "test_network",
"is_admin": "True",
"cidr": "10.0.0.0/24",
"gateway": "10.0.0.254",
"dns_nameservers": ["8.8.8.8", "8.8.4.4"],
"ext_router_id": "91212048-abc3-43cc-89b3-377341426aca"
}
}
url = '/v1/groups/' + GID + '/networks'
req = get_request(url, 'POST', request_body)
res = req.get_response(self.app)
self.assertEqual(res.status_code, 404)
def test_create_validate_exception_by_gid_notfound(self):
self.mox.StubOutWithMock(
db, "group_get_by_gid")
db.group_get_by_gid(
mox.IsA(context.RequestContext),
GID)\
.AndRaise(exception.GroupNotFound(gid=GID))
self.mox.ReplayAll()
request_body = {
"network": {
"name": "test_network",
"is_admin": "True",
"cidr": "10.0.0.0/24",
"gateway": "10.0.0.254",
"dns_nameservers": ["8.8.8.8", "8.8.4.4"],
"ext_router_id": "91212048-abc3-43cc-89b3-377341426aca"
}
}
url = '/v1/groups/' + GID + '/networks'
req = get_request(url, 'POST', request_body)
res = req.get_response(self.app)
self.assertEqual(res.status_code, 404)
def show(self, req, gid):
def _validate(gid):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
try:
_validate(gid)
context = req.environ['rack.context']
group = db.group_get_by_gid(context, gid)
except exception.NotFound:
msg = _("Group could not be found")
raise webob.exc.HTTPNotFound(explanation=msg)
return self._view_builder.show(group)
def show(self, req, gid):
def _validate(gid):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
try:
_validate(gid)
context = req.environ['rack.context']
group = db.group_get_by_gid(context, gid)
except exception.NotFound:
msg = _("Group could not be found")
raise webob.exc.HTTPNotFound(explanation=msg)
return self._view_builder.show(group)
def create(self, req, gid, body):
def _validate(context, body, gid):
self._uuid_check(gid)
if not self.is_valid_body(body, "network"):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body.get("network")
cidr = values.get("cidr")
name = values.get("name")
is_admin = values.get("is_admin")
if is_admin:
try:
is_admin = strutils.bool_from_string(is_admin, strict=True)
except ValueError:
msg = _("is_admin must be a boolean")
raise exception.InvalidInput(reason=msg)
else:
is_admin = False
gateway = values.get("gateway")
ext_router = values.get("ext_router_id")
dns_nameservers = values.get("dns_nameservers")
if dns_nameservers is not None and not isinstance(
dns_nameservers, list):
msg = _("dns_nameservers must be a list")
raise exception.InvalidInput(reason=msg)
valid_values = {}
valid_values["gid"] = gid
valid_values["network_id"] = unicode(uuid.uuid4())
if not name:
name = "network-" + valid_values["network_id"]
valid_values["display_name"] = name
valid_values["cidr"] = cidr
valid_values["is_admin"] = is_admin
valid_values["gateway"] = gateway
valid_values["ext_router"] = ext_router
valid_values["dns_nameservers"] = dns_nameservers
network_values = {}
network_values["name"] = name
network_values["cidr"] = cidr
network_values["gateway"] = gateway
network_values["ext_router"] = ext_router
network_values["dns_nameservers"] = dns_nameservers
return valid_values, network_values
try:
context = req.environ['rack.context']
values, network_values = _validate(context, body, gid)
db.group_get_by_gid(context, gid)
result_value = self.manager.network_create(context,
**network_values)
values.update(result_value)
values["user_id"] = context.user_id
values["project_id"] = context.project_id
network = db.network_create(context, values)
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())
return self._view_builder.create(network)
def _check_gid(self, gid, is_create=False, context=None):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
if is_create:
db.group_get_by_gid(context, gid)
def create(self, req, body, gid):
def _validate(body, gid):
if not self.is_valid_body(body, "keypair"):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
self._uuid_check(gid)
values = body["keypair"]
name = values.get("name")
is_default = values.get("is_default")
if name:
if isinstance(name, six.string_types):
name = name.strip()
utils.check_string_length(name, "name", min_length=1, max_length=255)
if is_default:
try:
is_default = strutils.bool_from_string(is_default, strict=True)
except ValueError:
msg = _("is_default must be a boolean")
raise exception.InvalidInput(reason=msg)
else:
is_default = False
valid_values = {}
valid_values["gid"] = gid
valid_values["display_name"] = name
valid_values["is_default"] = is_default
return valid_values
try:
values = _validate(body, gid)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
except exception.GroupNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
context = req.environ["rack.context"]
values["keypair_id"] = unicode(uuid.uuid4())
if not values["display_name"]:
values["display_name"] = "keypair-" + values["keypair_id"]
values["user_id"] = context.user_id
values["project_id"] = context.project_id
values["status"] = "BUILDING"
try:
db.group_get_by_gid(context, gid)
keypair = db.keypair_create(context, values)
host = self.scheduler_rpcapi.select_destinations(context, request_spec={}, filter_properties={})
self.operator_rpcapi.keypair_create(
context, host["host"], gid=gid, keypair_id=values["keypair_id"], name=values["display_name"]
)
except exception.GroupNotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
except Exception:
keypair_id = values["keypair_id"]
db.keypair_update(context, gid, keypair_id, {"status": "ERROR"})
raise exception.KeypairCreateFailed()
return self._view_builder.create(keypair)
def create(self, req, body, gid):
def _validate_securitygroup(gid, body):
if not uuidutils.is_uuid_like(gid):
raise exception.GroupNotFound(gid=gid)
if not self.is_valid_body(body, 'securitygroup'):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body["securitygroup"]
name = values.get("name")
is_default = values.get("is_default")
if isinstance(name, six.string_types):
name = name.strip()
utils.check_string_length(name, 'name', min_length=1,
max_length=255)
if is_default:
try:
is_default = strutils.bool_from_string(
is_default, strict=True)
except ValueError:
msg = _("is_default must be a boolean")
raise exception.InvalidInput(reason=msg)
else:
is_default = False
valid_values = {}
valid_values["gid"] = gid
valid_values["display_name"] = name
valid_values["is_default"] = is_default
return valid_values
def _validate_securitygrouprules(securitygrouprules):
valid_securitygrouprules = []
for securitygroup in securitygrouprules:
protocol = securitygroup.get("protocol")
port_range_max = securitygroup.get("port_range_max")
port_range_min = securitygroup.get("port_range_min")
remote_securitygroup_id = securitygroup.get(
"remote_securitygroup_id")
remote_ip_prefix = securitygroup.get("remote_ip_prefix")
if not protocol:
msg = _("SecurityGroupRule protocol is required")
raise exception.InvalidInput(reason=msg)
elif not utils.is_valid_protocol(protocol):
msg = _(
"SecurityGroupRule protocol should be tcp or udp or "
"icmp")
raise exception.InvalidInput(reason=msg)
if not remote_securitygroup_id and not remote_ip_prefix:
msg = _(
"SecurityGroupRule either remote_securitygroup_id or "
"remote_ip_prefix is required")
raise exception.InvalidInput(reason=msg)
elif remote_securitygroup_id and remote_ip_prefix:
msg = _(
"SecurityGroupRule either remote_securitygroup_id or "
"remote_ip_prefix is required")
raise exception.InvalidInput(reason=msg)
elif remote_securitygroup_id is not None:
if not uuidutils.is_uuid_like(remote_securitygroup_id):
raise exception.SecuritygroupNotFound(
securitygroup_id=remote_securitygroup_id)
elif remote_ip_prefix is not None:
if not utils.is_valid_cidr(remote_ip_prefix):
msg = _(
"SecurityGroupRule remote_ip_prefix should be "
"cidr format")
raise exception.InvalidInput(reason=msg)
if protocol in ["tcp", "udp"]:
if port_range_max is None:
msg = _("SecurityGroupRule port_range_max is "
"required")
raise exception.InvalidInput(reason=msg)
utils.validate_integer(
port_range_max, 'port_range_max', min_value=1,
max_value=65535)
if port_range_min:
utils.validate_integer(
port_range_min, 'port_range_min', min_value=1,
max_value=65535)
if port_range_min > port_range_max:
msg = _(
"SecurityGroupRule port_range_min should be "
"lower than port_range_max")
raise exception.InvalidInput(reason=msg)
elif protocol == "icmp":
port_range_max = None
port_range_min = None
valid_securitygrouprules.append({
"protocol": protocol,
"port_range_max": port_range_max,
"port_range_min": port_range_min,
"remote_securitygroup_id": remote_securitygroup_id,
"remote_ip_prefix": unicode(netaddr
.IPNetwork(remote_ip_prefix))
if remote_ip_prefix else remote_ip_prefix
})
return valid_securitygrouprules
try:
context = req.environ['rack.context']
values = _validate_securitygroup(gid, body)
if(body["securitygroup"].get("securitygrouprules")):
securitygrouprules = _validate_securitygrouprules(
body["securitygroup"].get("securitygrouprules"))
else:
securitygrouprules = []
except exception.InvalidInput as exc:
raise webob.exc.HTTPBadRequest(explanation=exc.format_message())
except exception.NotFound as exc:
raise webob.exc.HTTPNotFound(explanation=exc.format_message())
values["deleted"] = 0
values["status"] = "BUILDING"
values["securitygroup_id"] = unicode(uuid.uuid4())
values["user_id"] = context.user_id
values["project_id"] = context.project_id
values["display_name"] = values[
"display_name"] or "sec-" + values["securitygroup_id"]
try:
for i in range(len(securitygrouprules)):
if securitygrouprules[i]["remote_securitygroup_id"]:
securitygroup = db\
.securitygroup_get_by_securitygroup_id(
context, gid,
securitygrouprules[i]["remote_securitygroup_id"])
remote_neutron_securitygroup_id = securitygroup.get(
"neutron_securitygroup_id")
securitygrouprules[i][
"remote_neutron_securitygroup_id"] =\
remote_neutron_securitygroup_id
db.group_get_by_gid(context, gid)
securitygroup = db.securitygroup_create(context, values)
except exception.NotFound as exc:
raise webob.exc.HTTPNotFound(explanation=exc.format_message())
try:
host = self.scheduler_rpcapi.select_destinations(
context,
request_spec={},
filter_properties={})
self.operator_rpcapi.securitygroup_create(
context,
host["host"],
gid=gid,
securitygroup_id=values["securitygroup_id"],
name=values["display_name"],
securitygrouprules=securitygrouprules)
except Exception:
securitygroup_id = values["securitygroup_id"]
db.securitygroup_update(
context, gid, securitygroup_id, {"status": "ERROR"})
raise exception.SecuritygroupCreateFailed()
return self._view_builder.create(securitygroup)
