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_create_network(self):
self.stubs.Set(
self.manager.network_client, "network_create", fake_network_create)
self.mox.StubOutWithMock(db, "network_update")
expected_values = {"neutron_network_id": NEUTRON_NETWORK_ID,
"status": "ACTIVE"}
db.network_update(self.context, NETWORK_ID, expected_values)
self.mox.ReplayAll()
network = {}
network["network_id"] = NETWORK_ID
self.manager.network_create(self.context, network)
def network_create(self, context, network):
update_values = {}
try:
neutron_network_id = self.network_client.network_create(
network.get("display_name"),
network.get("subnet"),
network.get("gateway"),
network.get("dns_nameservers"),
network.get("ext_router"))
update_values["neutron_network_id"] = neutron_network_id
update_values["status"] = "ACTIVE"
except Exception as e:
LOG.exception(e)
update_values["status"] = "ERROR"
try:
db.network_update(context, network["network_id"], update_values)
except Exception as e:
LOG.exception(e)
def test_create_network_exception_create_faild(self):
self.mox.StubOutWithMock(self.manager.network_client, "network_create")
self.manager.network_client.network_create(
mox.IsA(str), mox.IsA(str), mox.IsA(str), mox.IsA(str),
mox.IsA(str),)\
.AndRaise(Exception())
self.mox.StubOutWithMock(db, "network_update")
expected_values = {"status": "ERROR"}
db.network_update(self.context, NETWORK_ID, expected_values)
self.mox.ReplayAll()
network = {
"network_id": NETWORK_ID,
"display_name": "fake_name",
"subnet": "10.0.0.0/24",
"gateway": "fake_gateway",
"dns_nameservers": "fake_dns_nameservers",
"ext_router": "fake_router"}
self.manager.network_create(self.context, network)
def test_create_exception_resorceoperator_rpcapi(self):
self.stubs.Set(db, "network_create", fake_create_db)
self.stubs.Set(db, "group_get_by_gid", fake_group_get_by_gid)
self.stubs.Set(resourceoperator_rpcapi.ResourceOperatorAPI,
"network_create",
fake_raise_exception)
request_spec = {}
filter_properties = {}
self.mox.StubOutWithMock(
scheduler_rpcapi.SchedulerAPI, "select_destinations")
scheduler_rpcapi.SchedulerAPI.select_destinations(
mox.IsA(context.RequestContext),
request_spec,
filter_properties)\
.AndReturn({"host": RO_HOST_NAME})
self.mox.StubOutWithMock(db, "network_update")
error_values = {"status": "ERROR"}
db.network_update(mox.IsA(context.RequestContext),
NETWORK_ID1,
error_values)
self.mox.ReplayAll()
request_body = {
"network": {
"is_admin": "True",
"name": "network-test",
"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, 500)
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)
