def detach_network_from_router(network_id):
network = Network.objects.get(pk=network_id)
subnet = network.subnet_set.filter(deleted=False)[0]
rc = create_rc_by_network(network)
interface_set = RouterInterface.objects.filter(network_id=network.id,
subnet=subnet, deleted=False)
LOG.info("Start to detach network[%s]", network.name)
try:
for router_interface in interface_set:
LOG.info("Start to delete router interface, router:[%s], "
"subnet[%s], id:[%s], port_id:[%s]",
router_interface.router.name, router_interface.subnet.name,
router_interface.id, router_interface.os_port_id)
neutron.router_remove_interface(rc,
router_interface.router.router_id,
subnet.subnet_id,
router_interface.os_port_id)
router_interface.fake_delete()
except Exception as e:
LOG.exception("Failed to delete router interface, router:[%s], "
"subnet[%s], id:[%s], port_id:[%s], exception:%s",
router_interface.router.name,
router_interface.subnet.name,
router_interface.id, router_interface.os_port_id, e)
network.change_status(NETWORK_STATE_ERROR)
raise e
else:
network.change_status(NETWORK_STATE_ACTIVE)
def create_network(network):
rc = create_rc_by_network(network)
network_params = {'name': "network-%s" % network.id, "admin_state_up": True}
LOG.info("Start to create network, id:[%s], name[%s]",
network.id, network.name)
begin = datetime.datetime.now()
try:
net = neutron.network_create(rc, **network_params)
end = datetime.datetime.now()
LOG.info("Create network api apply [%s] seconds", \
(end-begin).seconds)
network.network_id = net.id
network.status = NETWORK_STATE_ACTIVE
network.save()
except Exception as ex:
end = datetime.datetime.now()
LOG.info("Create network api apply [%s] seconds", \
(end-begin).seconds)
network.status = NETWORK_STATE_ERROR
network.save()
LOG.exception("Failed to create network, id:[%s], name[%s], "
"exception:[%s]",
network.id, network.name, ex)
raise ex
return network
def network_and_subnet_create_task(network,subnet):
rc = create_rc_by_network(network)
LOG.info("Begin create network,id[%s], name[%s]" % (network.id, network.name))
try:
net = network_create_task(network)
LOG.info("Begin create subnet,id[%s], name[%s]" % (subnet.id, subnet.name))
subnet_create_task(subnet)
except Exception as e:
raise e
def network_delete_task(network=None):
rc = create_rc_by_network(network)
LOG.info("delete network,id:[%s],name[%s]" % (network.id, network.name))
try:
net = neutron.network_delete(rc, network.network_id)
network.network_id = None
network.deleted = True
network.save()
except Exception as ex:
network.status = NETWORK_STATE_ERROR
network.save()
LOG.info("delete network error,id:[%s],name[%s]" % (network.id, network.name))
raise ex
return network
def network_create_task(network):
rc = create_rc_by_network(network)
network_params = {'name': "network-%s" % network.id, "admin_state_up": True}
LOG.info("start create network,id:[%s],name[%s]" % (network.id, network.name))
try:
net = neutron.network_create(rc, **network_params)
network.network_id = net.id
network.status = NETWORK_STATE_ACTIVE
network.save()
except Exception as ex:
network.status = NETWORK_STATE_ERROR
network.save()
LOG.info("create network error,id:[%s],name[%s],msg:[%s]" % (network.id, network.name, ex))
raise ex
return network
def create_network(network):
rc = create_rc_by_network(network)
network_params = {'name': "network-%s" % network.id, "admin_state_up": True}
LOG.info("Start to create network, id:[%s], name[%s]",
network.id, network.name)
try:
net = neutron.network_create(rc, **network_params)
network.network_id = net.id
network.status = NETWORK_STATE_ACTIVE
network.save()
except Exception as ex:
network.status = NETWORK_STATE_ERROR
network.save()
LOG.exception("Failed to create network, id:[%s], name[%s], "
"exception:[%s]",
network.id, network.name, ex)
raise ex
return network
def network_delete_task(network):
rc = create_rc_by_network(network)
LOG.info("delete network,id:[%s],name[%s]" % (network.id, network.name))
try:
# delete all subnet
LOG.info("delete all subnet, network id [%s] name[%s]" % (network.id, network.name))
subnet_set = Subnet.objects.filter(network_id=network.id, deleted=False)
for subnet in subnet_set:
subnet_delete_task(subnet)
# delete network
net = neutron.network_delete(rc, network.network_id)
network.network_id = None
network.deleted = True
network.save()
except Exception as ex:
network.status = NETWORK_STATE_ERROR
network.save()
LOG.info("delete network error,id:[%s],name[%s],msg:[%s]" % (network.id, network.name, ex))
raise ex
return network
def delete_network(network):
rc = create_rc_by_network(network)
LOG.info("Start to delete network, id:[%s], name[%s]",
network.id, network.name)
try:
subnet_set = Subnet.objects.filter(network_id=network.id, deleted=False)
for subnet in subnet_set:
delete_subnet(subnet)
neutron.network_delete(rc, network.network_id)
network.network_id = None
network.deleted = True
network.save()
except Exception as ex:
network.status = NETWORK_STATE_ERROR
network.save()
LOG.exception("Failed to delete network, id:[%s], name[%s], msg:[%s]",
network.id, network.name, ex)
raise ex
return network
def create_network(network):
rc = create_rc_by_network(network)
network_params = {
'name': "network-%s" % network.id,
"admin_state_up": True
}
LOG.info("Start to create network, id:[%s], name[%s]", network.id,
network.name)
try:
net = neutron.network_create(rc, **network_params)
network.network_id = net.id
network.status = NETWORK_STATE_ACTIVE
network.save()
except Exception as ex:
network.status = NETWORK_STATE_ERROR
network.save()
LOG.exception(
"Failed to create network, id:[%s], name[%s], "
"exception:[%s]", network.id, network.name, ex)
raise ex
return network
def make_sure_default_private_network(instance):
network = None
try:
network = Network.objects.get(pk=instance.network_id)
except Network.DoesNotExist:
pass
default_private_networks = Network.objects.filter(deleted=False,
is_default=True, status__in=[NETWORK_STATE_BUILD, NETWORK_STATE_ACTIVE],
user=instance.user, user_data_center=instance.user_data_center)
if not default_private_networks.exists():
sleeping = random.uniform(0.4, 5.5)
time.sleep(sleeping)
LOG.info("No default network [%s][%s], sleep [%s] seconds",
instance.user_data_center.tenant_name, instance.name, sleeping)
default_private_networks = Network.objects.filter(deleted=False,
is_default=True, status__in=[NETWORK_STATE_BUILD, NETWORK_STATE_ACTIVE],
user=instance.user, user_data_center=instance.user_data_center)
if not default_private_networks.exists():
LOG.info("Double check no default network [%s][%s].",
instance.user_data_center.tenant_name, instance.name)
begin = datetime.datetime.now()
default_private_network = Network.objects.create(
name=settings.DEFAULT_NETWORK_NAME, status=NETWORK_STATE_BUILD,
is_default=True, user=instance.user,
user_data_center=instance.user_data_center)
address = None
for i in xrange(255):
tmp_address = "172.31.%s.0/24" % i
if not Subnet.objects.filter(user=instance.user,
deleted=False, address=tmp_address,
user_data_center=instance.user_data_center).exists():
address = tmp_address
break
if not address:
address = "172.30.0.0/24"
default_private_subnet = Subnet.objects.create(
name=settings.DEFAULT_SUBNET_NAME, network=default_private_network,
address=address, ip_version=4, status=0, user=instance.user,
user_data_center=instance.user_data_center)
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME, status=0, is_default=True,
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
end = datetime.datetime.now()
LOG.info("Create network db record apply [%s] seconds.",
(end-begin).seconds)
begin = datetime.datetime.now()
create_network(default_private_network)
create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(default_private_network.id,
default_router.id, default_private_subnet.id)
end = datetime.datetime.now()
LOG.info("Prepare private network api apply [%s] seconds.",
(end-begin).seconds)
else:
LOG.info("Double check instance has default network [%s].", instance.name)
default_private_network = default_private_networks[0]
else:
default_private_network = default_private_networks[0]
LOG.info("Instance has default network, [%s][%s].",
instance, default_private_network)
if not network:
network = default_private_network
count = 1
while True:
if count > settings.MAX_COUNT_SYNC:
LOG.info("Network not active, instance:[%s] netowk:[%s]." %(
instance.name, network.name))
break
count = count + 1
rc = create_rc_by_network(network)
try:
network = Network.objects.get(pk=network.id)
if not network.network_id:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
continue
net = neutron.network_get(rc, network.network_id)
if net.status.upper() not in ["ACTIVE", ]:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
continue
if net.subnets:
break
else:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
except:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
return network
def make_sure_default_private_network(instance, rc, user_tenant_uuid):
network = None
try:
network = Network.objects.get(pk=instance.network_id)
except Network.DoesNotExist:
LOG.info("network not exist")
pass
default_private_network = None
default_private_subnet = None
default_router = None
# Try to get default network
default_private_networks = Network.objects.filter(deleted=False,
is_default=True, status__in=[NETWORK_STATE_BUILD, NETWORK_STATE_ACTIVE],
user=instance.user, user_data_center=instance.user_data_center)
if not default_private_networks.exists():
LOG.info("*** default private network not exists in initcloud. Going to confirm if it exists in neutron***")
sleeping = random.uniform(0.4, 5.5)
time.sleep(sleeping)
LOG.info("No default network [%s][%s], sleep [%s] seconds",
instance.user_data_center.tenant_name, instance.name, sleeping)
default_private_networks = Network.objects.filter(deleted=False,
is_default=True, status__in=[NETWORK_STATE_BUILD, NETWORK_STATE_ACTIVE],
user=instance.user, user_data_center=instance.user_data_center)
# No default network exists, create a new one.
if not default_private_networks.exists():
LOG.info("*** no default network in initcloud. GOing to confirm if it exists in neutron ***")
LOG.info("*** vlan enabled or not ***" + str(settings.VLAN_ENABLED))
if settings.VLAN_ENABLED == True:
LOG.info("*** vlan enabled ***")
LOG.info("Double check no default vlan network [%s][%s].",
instance.user_data_center.tenant_name, instance.name)
begin = datetime.datetime.now()
network_ = neutron.network_list_for_tenant(rc, tenant_id=user_tenant_uuid)
LOG.info("********** network is ******************" + str(network_))
network_id = None
network_name = None
network_status = None
subnet_id = None
subnet_name = None
subnet_addr = None
for net in network_:
LOG.info("***** net is *******" + str(net))
network_id = net.id
network_name = net.name
network_status = net.admin_state_up
subnet = net.subnets
for s in subnet:
subnet_name = s.name
subnet_id = s.id
subnet_addr = s.cidr
LOG.info("********* network_id is *********" + str(network_id))
LOG.info("********* network_name is *********" + str(network_name))
LOG.info("********* network_status is *********" + str(network_status))
LOG.info("********* subnet_id is *********" + str(subnet_id))
LOG.info("********* subnet_name is *********" + str(subnet_name))
LOG.info("********* subnet_addr is *********" + str(subnet_addr))
# Create Default network to initcloud
default_private_network = Network.objects.create(
name=network_name, network_id=network_id, status=network_status,
is_default=True, user=instance.user,
user_data_center=instance.user_data_center)
LOG.info("*** default private network create success ***")
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(user=instance.user,
deleted=False, address=tmp_address,
user_data_center=instance.user_data_center).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=subnet_name, network=default_private_network,
address=subnet_addr, ip_version=4, status=0, user=instance.user,
user_data_center=instance.user_data_center)
LOG.info("*** default_private_subnet create success ***")
end = datetime.datetime.now()
LOG.info("Create vlan network db record apply [%s] seconds.",
(end-begin).seconds)
# User has not default network for vxlan.
if settings.VLAN_ENABLED == False:
LOG.info("*** vxlan mode is enabled ***")
# Start check if network exists in neutron.
network_ = neutron.network_list_for_tenant(rc, tenant_id=user_tenant_uuid)
LOG.info("********** network is ******************" + str(network_))
network_id = None
network_name = None
network_status = None
subnet_id = None
subnet_name = None
subnet_addr = None
for net in network_:
LOG.info("***** net is *******" + str(net))
network_id = net.id
network_name = net.name
network_status = net.admin_state_up
subnet = net.subnets
for s in subnet:
subnet_name = s.name
subnet_id = s.id
subnet_addr = s.cidr
begin = datetime.datetime.now()
LOG.info("********* network_status is *********" + str(network_status))
# User has network in neutron
if network_name and network_id:
LOG.info("*** vxlan user has network in neutron ***")
default_private_network = Network.objects.create(
name=network_name, network_id=network_id, status=network_status,
is_default=True, user=instance.user,
user_data_center=instance.user_data_center)
# If network exists, check subnet exists or not.
# If subnet exists, store data in initcloud.
if subnet_id and subnet_name:
LOG.info("*** vxlan user has subnet in neutron ***")
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(user=instance.user,
deleted=False, address=tmp_address,
user_data_center=instance.user_data_center).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=subnet_name, network=default_private_network, subnet_id=subnet_id,
address=subnet_addr, ip_version=4, status=1, user=instance.user,
user_data_center=instance.user_data_center)
# Check if router exists.
neutron_subnets = neutron.subnet_list(rc, network_id=network_id)
for n in neutron_subnets:
LOG.info("*** n is ***" + str(n))
routers = neutron.router_list(rc, tenant_id=user_tenant_uuid)
neutron_subnet_id = None
neutron_router_id = None
neutron_router_name = None
external_gateway_info = None
external_fixed_ips = None
is_router = False
gateway_ip = None
for r in routers:
is_router = True
neutron_router_id = r.id
neutron_router_name = r.name
LOG.info("*** router is ***" + str(r))
external_gateway_info = r.external_gateway_info
LOG.info("*** external_gateway_info is ***" + str(external_gateway_info))
if external_gateway_info:
external_fixed_ips = external_gateway_info['external_fixed_ips']
if external_fixed_ips:
for fip in external_fixed_ips:
neutron_subnet_id = fip['subnet_id']
gateway_ip = fip['ip_address']
ports = neutron.port_list(rc, network_id=network_id)
p_network_id = None
p_subnet_id = None
p_fixed_ips = None
os_port_id = None
for p in ports:
LOG.info("*** p is ***" + str(p))
os_port_id = p.id
if p.device_owner == "network:router_interface":
p_network_id = p.network_id
p_fixed_ips = p.fixed_ips
for f in p_fixed_ips:
p_subnet_id = f['subnet_id']
LOG.info("*** gateway_ip is ***" + str(gateway_ip))
LOG.info("*** neutron_subnet_id is ***" + str(neutron_subnet_id))
LOG.info("*** subnet_id is ***" + str(subnet_id))
LOG.info("external_gateway_info is" + str(external_gateway_info))
LOG.info("external_fixed_ips is " + str(external_fixed_ips))
# router exists
if is_router and str(p_subnet_id) == str(subnet_id):
LOG.info("*** vxlan user has router exists ***")
# external_gateway exists
if external_gateway_info:
# external_fixed_ips exists, save router info to initcloud
if external_fixed_ips:
LOG.info("***** ****************************** ***********")
LOG.info("*** neutron_router_name ***" + str(neutron_router_name))
LOG.info("*** neutron_router_id ***" + str(neutron_router_id))
LOG.info("*** gateway_ip ***" + str(gateway_ip))
default_router = Router.objects.create(
name=str(neutron_router_name), status=1,
is_default=True,router_id=str(neutron_router_id), gateway=str(gateway_ip),
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
LOG.info("*** router create success ***")
RouterInterface.objects.create(
network_id=default_private_network.id, router_id=default_router.id,
subnet_id=default_private_subnet.id,
user=instance.user, user_data_center=instance.user_data_center,
os_port_id=str(os_port_id))
# external_fixed_ips does not exist
else:
router_add_interface(rc, router_id=neutron_router_id, subnet_id=neutron_subnet_id)
default_router = Router.objects.create(
name=str(neutron_router_name), status=1,
is_default=True,router_id=str(neutron_router_id), gateway=str(gateway_ip),
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
# external_gateway does not exist
else:
router_gateway = neutron.router_add_gateway(rc, router_id=neutron_router_id, network_id=network_id)
router_add_interface(rc, router_id=neutron_router_id, subnet_id=neutron_subnet_id)
default_router = Router.objects.create(
name=str(neutron_router_name), status=1,
is_default=True,router_id=str(neutron_router_id), gateway=str(gateway_ip),
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
# Router does not exist
else:
LOG.info("*** router does not exist ***")
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME, status=1, is_default=True,
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
# Start to create real network in neutron
#begin = datetime.datetime.now()
#create_network(default_private_network)
#create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(default_private_network.id,
default_router.id, default_private_subnet.id)
# Subnet not exists in neutron, create a subnet in neutron and store in the initcloud.
else:
LOG.info("*** vxlan subnet does not exists ***")
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(user=instance.user,
deleted=False, address=tmp_address,
user_data_center=instance.user_data_center).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=settings.DEFAULT_SUBNET_NAME, network=default_private_network,
address=address, ip_version=4, status=0, user=instance.user,
user_data_center=instance.user_data_center)
"""
create_subnet(default_private_subnet)
routers = neutron.router_list(rc, tenant_id=user_tenant_uuid)
neutron_subnet_id = None
for r in routers:
LOG.info("*** router is ***" + str(r))
external_gateway_info = r.external_gateway_info
LOG.info("*** external_gateway_info is ***" + str(external_gateway_info))
if external_gateway_info:
external_fixed_ips = external_gateway_info['external_fixed_ips']
if external_fixed_ips:
for fip in external_fixed_ips:
neutron_subnet_id = fip['subnet_id']
LOG.info("*** neutron_subnet_id is ***" + str(neutron_subnet_id))
"""
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME, status=0, is_default=True,
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
# Start to create real network in neutron
begin = datetime.datetime.now()
#create_network(default_private_network)
create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(default_private_network.id,
default_router.id, default_private_subnet.id)
# User has not network in neutron and initcloud.
else:
LOG.info("*** vxlan user network does not exist ***")
default_private_network = Network.objects.create(
name=settings.DEFAULT_NETWORK_NAME, status=NETWORK_STATE_BUILD,
is_default=True, user=instance.user,
user_data_center=instance.user_data_center)
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(user=instance.user,
deleted=False, address=tmp_address,
user_data_center=instance.user_data_center).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=settings.DEFAULT_SUBNET_NAME, network=default_private_network,
address=address, ip_version=4, status=0, user=instance.user,
user_data_center=instance.user_data_center)
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME, status=0, is_default=True,
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY, user=instance.user,
user_data_center=instance.user_data_center)
# Start to create real network in neutron
begin = datetime.datetime.now()
create_network(default_private_network)
create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(default_private_network.id,
default_router.id, default_private_subnet.id)
end = datetime.datetime.now()
LOG.info("Prepare private network api apply [%s] seconds.",
(end-begin).seconds)
else:
LOG.info("Double check instance has default network [%s].", instance.name)
default_private_network = default_private_networks[0]
else:
default_private_network = default_private_networks[0]
LOG.info("Instance has default network, [%s][%s].",
instance, default_private_network)
LOG.info(" *** i am two ***")
if not network:
network = default_private_network
# Wait for network creation complete
count = 1
while True:
if count > settings.MAX_COUNT_SYNC:
LOG.info("Network not active, instance:[%s] netowk:[%s]." %(
instance.name, network.name))
break
count = count + 1
rc = create_rc_by_network(network)
try:
network = Network.objects.get(pk=network.id)
if not network.network_id:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
continue
net = neutron.network_get(rc, network.network_id)
if net.status.upper() not in ["ACTIVE", ]:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
continue
if net.subnets:
break
else:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
except:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
LOG.info("*** network is ***" + str(network))
return network
def make_sure_default_private_network(instance, rc, user_tenant_uuid):
network = None
try:
network = Network.objects.get(pk=instance.network_id)
except Network.DoesNotExist:
LOG.info("network not exist")
pass
default_private_network = None
default_private_subnet = None
default_router = None
# Try to get default network
default_private_networks = Network.objects.filter(
deleted=False,
is_default=True,
status__in=[NETWORK_STATE_BUILD, NETWORK_STATE_ACTIVE],
user=instance.user,
user_data_center=instance.user_data_center)
if not default_private_networks.exists():
LOG.info(
"*** default private network not exists in initcloud. Going to confirm if it exists in neutron***"
)
sleeping = random.uniform(0.4, 5.5)
time.sleep(sleeping)
LOG.info("No default network [%s][%s], sleep [%s] seconds",
instance.user_data_center.tenant_name, instance.name,
sleeping)
default_private_networks = Network.objects.filter(
deleted=False,
is_default=True,
status__in=[NETWORK_STATE_BUILD, NETWORK_STATE_ACTIVE],
user=instance.user,
user_data_center=instance.user_data_center)
# No default network exists, create a new one.
if not default_private_networks.exists():
LOG.info(
"*** no default network in initcloud. GOing to confirm if it exists in neutron ***"
)
LOG.info("*** vlan enabled or not ***" +
str(settings.VLAN_ENABLED))
if settings.VLAN_ENABLED == True:
LOG.info("*** vlan enabled ***")
LOG.info("Double check no default vlan network [%s][%s].",
instance.user_data_center.tenant_name, instance.name)
begin = datetime.datetime.now()
network_ = neutron.network_list_for_tenant(
rc, tenant_id=user_tenant_uuid)
LOG.info("********** network is ******************" +
str(network_))
network_id = None
network_name = None
network_status = None
subnet_id = None
subnet_name = None
subnet_addr = None
for net in network_:
LOG.info("***** net is *******" + str(net))
network_id = net.id
network_name = net.name
network_status = net.admin_state_up
subnet = net.subnets
for s in subnet:
subnet_name = s.name
subnet_id = s.id
subnet_addr = s.cidr
LOG.info("********* network_id is *********" + str(network_id))
LOG.info("********* network_name is *********" +
str(network_name))
LOG.info("********* network_status is *********" +
str(network_status))
LOG.info("********* subnet_id is *********" + str(subnet_id))
LOG.info("********* subnet_name is *********" +
str(subnet_name))
LOG.info("********* subnet_addr is *********" +
str(subnet_addr))
# Create Default network to initcloud
default_private_network = Network.objects.create(
name=network_name,
network_id=network_id,
status=network_status,
is_default=True,
user=instance.user,
user_data_center=instance.user_data_center)
LOG.info("*** default private network create success ***")
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(user=instance.user,
deleted=False,
address=tmp_address,
user_data_center=instance.
user_data_center).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=subnet_name,
network=default_private_network,
address=subnet_addr,
ip_version=4,
status=0,
user=instance.user,
user_data_center=instance.user_data_center)
LOG.info("*** default_private_subnet create success ***")
end = datetime.datetime.now()
LOG.info("Create vlan network db record apply [%s] seconds.",
(end - begin).seconds)
# User has not default network for vxlan.
if settings.VLAN_ENABLED == False:
LOG.info("*** vxlan mode is enabled ***")
# Start check if network exists in neutron.
network_ = neutron.network_list_for_tenant(
rc, tenant_id=user_tenant_uuid)
LOG.info("********** network is ******************" +
str(network_))
network_id = None
network_name = None
network_status = None
subnet_id = None
subnet_name = None
subnet_addr = None
for net in network_:
LOG.info("***** net is *******" + str(net))
network_id = net.id
network_name = net.name
network_status = net.admin_state_up
subnet = net.subnets
for s in subnet:
subnet_name = s.name
subnet_id = s.id
subnet_addr = s.cidr
begin = datetime.datetime.now()
LOG.info("********* network_status is *********" +
str(network_status))
# User has network in neutron
if network_name and network_id:
LOG.info("*** vxlan user has network in neutron ***")
default_private_network = Network.objects.create(
name=network_name,
network_id=network_id,
status=network_status,
is_default=True,
user=instance.user,
user_data_center=instance.user_data_center)
# If network exists, check subnet exists or not.
# If subnet exists, store data in initcloud.
if subnet_id and subnet_name:
LOG.info("*** vxlan user has subnet in neutron ***")
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(
user=instance.user,
deleted=False,
address=tmp_address,
user_data_center=instance.user_data_center
).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=subnet_name,
network=default_private_network,
subnet_id=subnet_id,
address=subnet_addr,
ip_version=4,
status=1,
user=instance.user,
user_data_center=instance.user_data_center)
# Check if router exists.
neutron_subnets = neutron.subnet_list(
rc, network_id=network_id)
for n in neutron_subnets:
LOG.info("*** n is ***" + str(n))
routers = neutron.router_list(
rc, tenant_id=user_tenant_uuid)
neutron_subnet_id = None
neutron_router_id = None
neutron_router_name = None
external_gateway_info = None
external_fixed_ips = None
is_router = False
gateway_ip = None
for r in routers:
is_router = True
neutron_router_id = r.id
neutron_router_name = r.name
LOG.info("*** router is ***" + str(r))
external_gateway_info = r.external_gateway_info
LOG.info("*** external_gateway_info is ***" +
str(external_gateway_info))
if external_gateway_info:
external_fixed_ips = external_gateway_info[
'external_fixed_ips']
if external_fixed_ips:
for fip in external_fixed_ips:
neutron_subnet_id = fip['subnet_id']
gateway_ip = fip['ip_address']
ports = neutron.port_list(rc, network_id=network_id)
p_network_id = None
p_subnet_id = None
p_fixed_ips = None
os_port_id = None
for p in ports:
LOG.info("*** p is ***" + str(p))
os_port_id = p.id
if p.device_owner == "network:router_interface":
p_network_id = p.network_id
p_fixed_ips = p.fixed_ips
for f in p_fixed_ips:
p_subnet_id = f['subnet_id']
LOG.info("*** gateway_ip is ***" + str(gateway_ip))
LOG.info("*** neutron_subnet_id is ***" +
str(neutron_subnet_id))
LOG.info("*** subnet_id is ***" + str(subnet_id))
LOG.info("external_gateway_info is" +
str(external_gateway_info))
LOG.info("external_fixed_ips is " +
str(external_fixed_ips))
# router exists
if is_router and str(p_subnet_id) == str(subnet_id):
LOG.info("*** vxlan user has router exists ***")
# external_gateway exists
if external_gateway_info:
# external_fixed_ips exists, save router info to initcloud
if external_fixed_ips:
LOG.info(
"***** ****************************** ***********"
)
LOG.info("*** neutron_router_name ***" +
str(neutron_router_name))
LOG.info("*** neutron_router_id ***" +
str(neutron_router_id))
LOG.info("*** gateway_ip ***" +
str(gateway_ip))
default_router = Router.objects.create(
name=str(neutron_router_name),
status=1,
is_default=True,
router_id=str(neutron_router_id),
gateway=str(gateway_ip),
is_gateway=settings.
DEFAULT_ROUTER_AUTO_SET_GATEWAY,
user=instance.user,
user_data_center=instance.
user_data_center)
LOG.info("*** router create success ***")
RouterInterface.objects.create(
network_id=default_private_network.id,
router_id=default_router.id,
subnet_id=default_private_subnet.id,
user=instance.user,
user_data_center=instance.
user_data_center,
os_port_id=str(os_port_id))
# external_fixed_ips does not exist
else:
router_add_interface(
rc,
router_id=neutron_router_id,
subnet_id=neutron_subnet_id)
default_router = Router.objects.create(
name=str(neutron_router_name),
status=1,
is_default=True,
router_id=str(neutron_router_id),
gateway=str(gateway_ip),
is_gateway=settings.
DEFAULT_ROUTER_AUTO_SET_GATEWAY,
user=instance.user,
user_data_center=instance.
user_data_center)
# external_gateway does not exist
else:
router_gateway = neutron.router_add_gateway(
rc,
router_id=neutron_router_id,
network_id=network_id)
router_add_interface(
rc,
router_id=neutron_router_id,
subnet_id=neutron_subnet_id)
default_router = Router.objects.create(
name=str(neutron_router_name),
status=1,
is_default=True,
router_id=str(neutron_router_id),
gateway=str(gateway_ip),
is_gateway=settings.
DEFAULT_ROUTER_AUTO_SET_GATEWAY,
user=instance.user,
user_data_center=instance.user_data_center)
# Router does not exist
else:
LOG.info("*** router does not exist ***")
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME,
status=1,
is_default=True,
is_gateway=settings.
DEFAULT_ROUTER_AUTO_SET_GATEWAY,
user=instance.user,
user_data_center=instance.user_data_center)
# Start to create real network in neutron
#begin = datetime.datetime.now()
#create_network(default_private_network)
#create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(
default_private_network.id, default_router.id,
default_private_subnet.id)
# Subnet not exists in neutron, create a subnet in neutron and store in the initcloud.
else:
LOG.info("*** vxlan subnet does not exists ***")
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(
user=instance.user,
deleted=False,
address=tmp_address,
user_data_center=instance.user_data_center
).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=settings.DEFAULT_SUBNET_NAME,
network=default_private_network,
address=address,
ip_version=4,
status=0,
user=instance.user,
user_data_center=instance.user_data_center)
"""
create_subnet(default_private_subnet)
routers = neutron.router_list(rc, tenant_id=user_tenant_uuid)
neutron_subnet_id = None
for r in routers:
LOG.info("*** router is ***" + str(r))
external_gateway_info = r.external_gateway_info
LOG.info("*** external_gateway_info is ***" + str(external_gateway_info))
if external_gateway_info:
external_fixed_ips = external_gateway_info['external_fixed_ips']
if external_fixed_ips:
for fip in external_fixed_ips:
neutron_subnet_id = fip['subnet_id']
LOG.info("*** neutron_subnet_id is ***" + str(neutron_subnet_id))
"""
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME,
status=0,
is_default=True,
is_gateway=settings.
DEFAULT_ROUTER_AUTO_SET_GATEWAY,
user=instance.user,
user_data_center=instance.user_data_center)
# Start to create real network in neutron
begin = datetime.datetime.now()
#create_network(default_private_network)
create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(default_private_network.id,
default_router.id,
default_private_subnet.id)
# User has not network in neutron and initcloud.
else:
LOG.info("*** vxlan user network does not exist ***")
default_private_network = Network.objects.create(
name=settings.DEFAULT_NETWORK_NAME,
status=NETWORK_STATE_BUILD,
is_default=True,
user=instance.user,
user_data_center=instance.user_data_center)
address = None
for i in xrange(255):
tmp_address = settings.TENANT_DEFAULT_NETWORK
if not Subnet.objects.filter(
user=instance.user,
deleted=False,
address=tmp_address,
user_data_center=instance.user_data_center
).exists():
address = tmp_address
break
if not address:
address = settings.TENANT_DEFAULT_NETWORK
# Create default private subnet to initcloud
default_private_subnet = Subnet.objects.create(
name=settings.DEFAULT_SUBNET_NAME,
network=default_private_network,
address=address,
ip_version=4,
status=0,
user=instance.user,
user_data_center=instance.user_data_center)
default_router = Router.objects.create(
name=settings.DEFAULT_ROUTER_NAME,
status=0,
is_default=True,
is_gateway=settings.DEFAULT_ROUTER_AUTO_SET_GATEWAY,
user=instance.user,
user_data_center=instance.user_data_center)
# Start to create real network in neutron
begin = datetime.datetime.now()
create_network(default_private_network)
create_subnet(default_private_subnet)
router_create_task(default_router)
attach_network_to_router(default_private_network.id,
default_router.id,
default_private_subnet.id)
end = datetime.datetime.now()
LOG.info("Prepare private network api apply [%s] seconds.",
(end - begin).seconds)
else:
LOG.info("Double check instance has default network [%s].",
instance.name)
default_private_network = default_private_networks[0]
else:
default_private_network = default_private_networks[0]
LOG.info("Instance has default network, [%s][%s].", instance,
default_private_network)
LOG.info(" *** i am two ***")
if not network:
network = default_private_network
# Wait for network creation complete
count = 1
while True:
if count > settings.MAX_COUNT_SYNC:
LOG.info("Network not active, instance:[%s] netowk:[%s]." %
(instance.name, network.name))
break
count = count + 1
rc = create_rc_by_network(network)
try:
network = Network.objects.get(pk=network.id)
if not network.network_id:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
continue
net = neutron.network_get(rc, network.network_id)
if net.status.upper() not in [
"ACTIVE",
]:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
continue
if net.subnets:
break
else:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
except:
time.sleep(settings.INSTANCE_SYNC_INTERVAL_SECOND)
LOG.info("*** network is ***" + str(network))
return network
