def test_networks_update(self):
create_values = {
"network_id": self.network_id,
"gid": self.gid,
"neutron_network_id": "",
"is_admin": True,
"subnet": "10.0.0.0/24",
"ext_router": "",
"user_id": "user",
"project_id": "user",
"display_name": "net-" + self.network_id,
"status": "BUILDING",
"deleted": 0
}
create_network = db.network_create(self.ctxt, create_values)
create_network["status"] = "ACTIVE"
update_values = {
"status": "ACTIVE"
}
db.network_update(self.ctxt, self.network_id, update_values)
network = db.network_get_by_network_id(
self.ctxt, self.gid, self.network_id)
ignored_keys = ['deleted',
'deleted_at',
'updated_at',
'processes']
self.assertIsNotNone(network["updated_at"])
self._assertEqualObjects(network, create_network, ignored_keys)
def test_network_delete(self):
create_values = {
"network_id": self.network_id,
"gid": self.gid,
"neutron_network_id": "",
"is_admin": True,
"subnet": "10.0.0.0/24",
"ext_router": "",
"user_id": "user",
"project_id": "user",
"display_name": "net-" + self.network_id,
"status": "BUILDING",
"deleted": 0
}
db.network_create(self.ctxt, create_values)
deleted_network = db.network_delete(
self.ctxt, self.gid, self.network_id)
self.assertEqual(deleted_network["deleted"], 1)
network_list = db.network_get_all(self.ctxt, self.gid)
self.assertEqual(network_list, [])
def test_network_get_all(self):
values = {
"network_id": "",
"gid": self.gid,
"neutron_network_id": "",
"is_admin": True,
"subnet": "10.0.0.0/24",
"ext_router": "",
"user_id": "user",
"project_id": "user",
"display_name": "net-" + self.network_id,
"status": "BUILDING",
"deleted": 0
}
for i in range(1 - 5):
values["network_id"] = "network_id" + str(i)
db.network_create(self.ctxt, values)
network_list = db.network_get_all(self.ctxt, self.gid)
for network in network_list:
self.assertEqual(network["gid"], self.gid)
def _create_network(self, gid):
values = {
"gid": gid,
"network_id": unicode(uuid.uuid4()),
"ext_router": unicode(uuid.uuid4()),
"subnet": "10.0.0.1/24",
"user_id": self.user_ctxt.user_id,
"project_id": self.user_ctxt.project_id,
"display_name": "test_network",
"is_admin": False,
"status": "ACTIVE",
"deleted": 0
}
return db.network_create(self.user_ctxt, values)
def test_network_get_by_network_id_exception_notfound(self):
values = {
"network_id": "",
"gid": self.gid,
"neutron_network_id": "",
"is_admin": True,
"subnet": "10.0.0.0/24",
"ext_router": "",
"user_id": "user",
"project_id": "user",
"display_name": "net-" + self.network_id,
"status": "BUILDING",
"deleted": 0
}
for i in range(1 - 5):
values["network_id"] = "network_id" + str(i)
db.network_create(self.ctxt, values)
self.assertRaises(exception.NetworkNotFound,
db.network_get_by_network_id,
context=self.ctxt,
gid=self.gid,
network_id=self.network_id)
def test_networks_create(self):
values = {
"network_id": self.network_id,
"gid": self.gid,
"neutron_network_id": "",
"is_admin": True,
"subnet": "10.0.0.0/24",
"ext_router": "",
"user_id": "user",
"project_id": "user",
"display_name": "net-" + self.network_id,
"status": "BUILDING",
"deleted": 0
}
network = db.network_create(self.ctxt, values)
ignored_keys = ['deleted',
'deleted_at',
'updated_at',
'created_at']
self._assertEqualObjects(network, values, ignored_keys)
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 create(self, req, gid, body):
def _validate(context, body, gid):
# validation checks
if not self.is_valid_body(body, "network"):
msg = _("Invalid request body")
raise exception.InvalidInput(reason=msg)
values = body.get("network")
# Required item
subnet = values.get("cidr")
if subnet is None:
msg = _("Ntwork cidr is required")
raise exception.InvalidInput(reason=msg)
if not utils.is_valid_cidr(subnet):
msg = _("cidr must be a CIDR")
raise exception.InvalidInput(reason=msg)
# Non-essential items
network_id = unicode(uuid.uuid4())
name = values.get("name")
if name is None or not name:
name = "net-" + network_id
else:
name = name.strip()
utils.check_string_length(
name, 'name', min_length=1, max_length=255)
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")
if gateway is not None and not utils.is_valid_ip_address(gateway):
msg = _("Invalid gateway")
raise exception.InvalidInput(reason=msg)
dns_nameservers = values.get("dns_nameservers")
if dns_nameservers is not None:
if isinstance(dns_nameservers, list):
for dns in dns_nameservers:
if dns == "" or not utils.is_valid_ip_address(dns):
msg = _("Invalid dns_nameservers")
raise exception.InvalidInput(reason=msg)
else:
msg = _("dns_nameservers must be list format")
raise exception.InvalidInput(reason=msg)
ext_router = values.get("ext_router_id")
if ext_router is not None and not uuidutils.is_uuid_like(
ext_router):
msg = _("ext_router must be a uuid")
raise exception.InvalidInput(reason=msg)
valid_values1 = {}
valid_values1["network_id"] = network_id
valid_values1["gid"] = gid
valid_values1["neutron_network_id"] = None
valid_values1["is_admin"] = is_admin
valid_values1["subnet"] = subnet
valid_values1["ext_router"] = ext_router
valid_values1["user_id"] = context.user_id
valid_values1["project_id"] = context.project_id
valid_values1["display_name"] = name
valid_values1["status"] = "BUILDING"
valid_values1["deleted"] = 0
valid_values2 = {}
valid_values2["gateway"] = gateway
valid_values2["dns_nameservers"] = dns_nameservers
valid_values = {}
valid_values["db"] = valid_values1
valid_values["opst"] = valid_values2
return valid_values
try:
context = req.environ['rack.context']
values = _validate(context, body, gid)
except exception.InvalidInput as e:
raise webob.exc.HTTPBadRequest(explanation=e.format_message())
try:
# db access
self._check_gid(gid, is_create=True, context=context)
network = db.network_create(context, values["db"])
except exception.NotFound as e:
raise webob.exc.HTTPNotFound(explanation=e.format_message())
except Exception as e:
LOG.exception(e)
raise exception.NetworkCreateFailed()
try:
# scheduler access
resourceoperator = self._get_resorceoperator(context)
# resource operator access
for k, v in values["opst"].items():
if v is not None:
network[k] = v
self.resourceoperator_rpcapi.network_create(
context, resourceoperator["host"], network)
except Exception as e:
LOG.exception(e)
error_values = {"status": "ERROR"}
db.network_update(context, network["network_id"], error_values)
raise exception.NetworkCreateFailed()
return self._view_builder.create(network)
