304 lines
11 KiB
Python
304 lines
11 KiB
Python
import random
|
|
import uuid
|
|
from datetime import datetime
|
|
import logging
|
|
from sqlalchemy.orm import sessionmaker
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
from app import db, app
|
|
from app.models.models import (
|
|
User, Universe, Project, Region, VirtualDataCenter, WorkloadHost,
|
|
WorkloadHostFixedResource, WorkloadHostPooledResource, Workload, Image, Volume, Label, RegionAccess
|
|
)
|
|
from app.models.network import *
|
|
|
|
# Configure logging
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Initialize session with application context
|
|
with app.app_context():
|
|
Session = sessionmaker(bind=db.engine)
|
|
session = Session()
|
|
db.create_all()
|
|
|
|
def create_users():
|
|
try:
|
|
users = [
|
|
User(
|
|
id=uuid.uuid4(),
|
|
first_name=f"User {i}",
|
|
last_name="Doe",
|
|
email=f"user{i}@example.com",
|
|
oidc_id=str(uuid.uuid4())
|
|
)
|
|
for i in range(10) # Create 10 users
|
|
]
|
|
session.add_all(users)
|
|
session.commit()
|
|
logger.info(f"Created {len(users)} users.")
|
|
return users
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating users: {e}")
|
|
raise
|
|
|
|
def create_universes(users):
|
|
try:
|
|
universes = [
|
|
Universe(
|
|
id=uuid.uuid4(),
|
|
name=f"Universe {i}",
|
|
description=f"A test universe {i}",
|
|
created_by=users[i % len(users)].id # Assign created_by to a user
|
|
)
|
|
for i in range(10) # Create 10 universes
|
|
]
|
|
session.add_all(universes)
|
|
session.commit()
|
|
logger.info(f"Created {len(universes)} universes.")
|
|
return universes
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating universes: {e}")
|
|
raise
|
|
|
|
def create_projects(universes):
|
|
try:
|
|
projects = [
|
|
Project(
|
|
id=uuid.uuid4(),
|
|
name=f"Project {i}",
|
|
universe_id=universes[i % len(universes)].id, # Assign to a universe
|
|
created_by=universes[i % len(universes)].created_by # Assign created_by to the universe's creator
|
|
)
|
|
for i in range(10) # Create 10 projects
|
|
]
|
|
session.add_all(projects)
|
|
session.commit()
|
|
logger.info(f"Created {len(projects)} projects.")
|
|
return projects
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating projects: {e}")
|
|
raise
|
|
|
|
def create_regions(users):
|
|
try:
|
|
regions = [
|
|
Region(
|
|
id=uuid.uuid4(),
|
|
name=f"Region {i}",
|
|
country=f"Country {i}",
|
|
abbreviation=f"REG{i}",
|
|
created_by=users[i % len(users)].id # Assign created_by to a user
|
|
)
|
|
for i in range(10) # Create 10 regions
|
|
]
|
|
session.add_all(regions)
|
|
session.add_all([Region(
|
|
id=1,
|
|
enrollment_key="a",
|
|
name=f"alpha",
|
|
country=f"Country alpha",
|
|
abbreviation=f"REGalpha",
|
|
ip_address_range_northsouth="192.168.50.0/24",
|
|
ip_address_range_eastwest="192.168.60.0/24",
|
|
created_by=users[1 % len(users)].id # Assign created_by to a user
|
|
)])
|
|
session.commit()
|
|
logger.info(f"Created {len(regions)} regions.")
|
|
return regions
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating regions: {e}")
|
|
raise
|
|
|
|
def create_vdcs(projects, regions):
|
|
try:
|
|
vdcs = [
|
|
VirtualDataCenter(
|
|
id=uuid.uuid4(),
|
|
name=f"VDC {i}",
|
|
project_id=projects[i % len(projects)].id, # Assign to a project
|
|
region_id=1 if i == 0 else regions[i % len(regions)].id, # Special case for i=0, else assign to a region
|
|
created_by=projects[i % len(projects)].created_by # Assign created_by to the project's creator
|
|
)
|
|
for i in range(10) # Create 10 VDCs
|
|
]
|
|
session.add_all(vdcs)
|
|
session.commit()
|
|
logger.info(f"Created {len(vdcs)} VDCs.")
|
|
return vdcs
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating VDCs: {e}")
|
|
raise
|
|
|
|
def create_networks(vdcs):
|
|
try:
|
|
networks = [
|
|
Network(
|
|
name=f"Network {i}",
|
|
vdc_id=vdcs[i % len(vdcs)].id, # Assign to a VDC
|
|
vni=i + 1, # Unique VNI for each network
|
|
ipv4_cidr=f"192.168.{i}.0/24", # Assign a unique IPv4 subnet
|
|
ipv4_gateway=f"192.168.{i}.1" # Assign a gateway IP
|
|
)
|
|
for i in range(10) # Create 10 networks
|
|
]
|
|
session.add_all(networks)
|
|
session.commit()
|
|
logger.info(f"Created {len(networks)} networks.")
|
|
return networks
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating networks: {e}")
|
|
raise
|
|
|
|
def create_network_ports(networks: dict[Network]):
|
|
try:
|
|
ports = []
|
|
for network in networks:
|
|
for i in range(3):
|
|
ports.append(network.create_port(session))
|
|
session.commit()
|
|
logger.info(f"Created {len(ports)} network ports.")
|
|
return ports
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating network ports: {e}")
|
|
raise
|
|
|
|
def create_region_access(projects, regions):
|
|
try:
|
|
region_access_entries = [
|
|
RegionAccess(
|
|
project_id=projects[i % len(projects)].id, # Assign to a project
|
|
region_id=regions[i % len(regions)].id # Assign to a region
|
|
)
|
|
for i in range(10) # Create 10 RegionAccess entries
|
|
]
|
|
session.add_all(region_access_entries)
|
|
session.commit()
|
|
logger.info(f"Created {len(region_access_entries)} region access entries.")
|
|
return region_access_entries
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating region access entries: {e}")
|
|
raise
|
|
|
|
def create_images(users):
|
|
try:
|
|
images = []
|
|
for i in range(5): # Create 5 sample images
|
|
# Randomly decide if the image location is a URL or a local path
|
|
is_http = i % 2 == 0 # Alternate between HTTP and local paths
|
|
location = (
|
|
f"http://example.com/images/image_{i}.img" if is_http
|
|
else f"/images/image_{i}.img"
|
|
)
|
|
location_type = "HTTP" if is_http else "Local"
|
|
|
|
# Randomly assign image format (qcow2 or raw)
|
|
image_format = "qcow2" if i % 2 == 0 else "raw"
|
|
|
|
images.append(
|
|
Image(
|
|
id=uuid.uuid4(),
|
|
name=f"Image {i}",
|
|
description=f"A sample image {i}",
|
|
location=location,
|
|
location_type=location_type,
|
|
size=10.0 * (i + 1), # Size in GB
|
|
os_family="Linux",
|
|
os_version=f"20.0{i}",
|
|
checksum=f"checksum_{i}",
|
|
format=image_format, # Add image format
|
|
created_by=random.choice(users).id
|
|
)
|
|
)
|
|
|
|
session.add_all(images)
|
|
session.commit()
|
|
logger.info(f"Created {len(images)} images.")
|
|
return images
|
|
except SQLAlchemyError as e:
|
|
session.rollback()
|
|
logger.error(f"Error creating images: {e}")
|
|
raise
|
|
|
|
|
|
def bootstrap_database():
|
|
try:
|
|
logger.info("Bootstrapping database...")
|
|
|
|
# Check and create users if none exist
|
|
if session.query(User).count() == 0:
|
|
users = create_users()
|
|
else:
|
|
users = session.query(User).all()
|
|
logger.info("Users already exist, skipping creation.")
|
|
|
|
# Check and create universes if none exist
|
|
if session.query(Universe).count() == 0:
|
|
universes = create_universes(users)
|
|
else:
|
|
universes = session.query(Universe).all()
|
|
logger.info("Universes already exist, skipping creation.")
|
|
|
|
# Check and create projects if none exist
|
|
if session.query(Project).count() == 0:
|
|
projects = create_projects(universes)
|
|
else:
|
|
projects = session.query(Project).all()
|
|
logger.info("Projects already exist, skipping creation.")
|
|
|
|
# Check and create regions if none exist
|
|
if session.query(Region).count() == 0:
|
|
regions = create_regions(users)
|
|
else:
|
|
regions = session.query(Region).all()
|
|
logger.info("Regions already exist, skipping creation.")
|
|
|
|
# Check and create VDCs if none exist
|
|
if session.query(VirtualDataCenter).count() == 0:
|
|
vdcs = create_vdcs(projects, regions)
|
|
else:
|
|
vdcs = session.query(VirtualDataCenter).all()
|
|
logger.info("VDCs already exist, skipping creation.")
|
|
|
|
# Check and create networks if none exist
|
|
if session.query(Network).count() == 0:
|
|
networks = create_networks(vdcs)
|
|
else:
|
|
networks = session.query(Network).all()
|
|
logger.info("Networks already exist, skipping creation.")
|
|
|
|
# Check and create images if none exist
|
|
if session.query(Image).count() == 0:
|
|
images = create_images(users)
|
|
else:
|
|
images = session.query(Image).all()
|
|
logger.info("Images already exist, skipping creation.")
|
|
|
|
# Check and create network ports if none exist
|
|
if session.query(NetworkPort).count() == 0:
|
|
network_ports = create_network_ports(networks)
|
|
else:
|
|
network_ports = session.query(NetworkPort).all()
|
|
logger.info("Network ports already exist, skipping creation.")
|
|
|
|
# Check and create region access entries if none exist
|
|
if session.query(RegionAccess).count() == 0:
|
|
region_access_entries = create_region_access(projects, regions)
|
|
else:
|
|
region_access_entries = session.query(RegionAccess).all()
|
|
logger.info("Region access entries already exist, skipping creation.")
|
|
|
|
logger.info("Database bootstrapping completed successfully!")
|
|
except Exception as e:
|
|
logger.error(f"Error bootstrapping database: {e}")
|
|
raise
|
|
|
|
if __name__ == "__main__":
|
|
bootstrap_database() |