class ResponseZone(Model):
name = KubeName(required=True, min_length=3)
region_name = KubeName()
vm_cluster = StringType(required=True)
vm_datastore = StringType(required=True)
vm_folder = StringType()
core_provision_percent = IntType(required=True)
ram_provision_percent = IntType(required=True)
schedulable = BooleanType(required=True)
state = EnumType(ResourceState, required=True)
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, zone: Zone):
zone_model = cls()
zone_model.name = zone.name
zone_model.region_name = zone.region_name
zone_model.vm_cluster = zone.vm_cluster
zone_model.vm_datastore = zone.vm_datastore
zone_model.vm_folder = zone.vm_folder
zone_model.core_provision_percent = zone.core_provision_percent
zone_model.ram_provision_percent = zone.ram_provision_percent
zone_model.schedulable = zone.schedulable
zone_model.state = zone.state
if zone.error_message != "":
zone_model.error_message = zone.error_message
zone_model.created_at = zone.created_at
zone_model.updated_at = zone.updated_at
return zone_model
class ResponseNetwork(Model):
name = KubeName(required=True, min_length=3)
port_group = StringType(required=True)
cidr = IPv4NetworkType(required=True)
gateway = IPv4AddressType(required=True)
dns_servers = ListType(IPv4AddressType, min_size=1, required=True)
pool_start = IPv4AddressType(required=True)
pool_end = IPv4AddressType(required=True)
region_name = KubeName()
state = EnumType(ResourceState, required=True)
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, network: Network):
network_model = cls()
network_model.name = network.name
network_model.port_group = network.port_group
network_model.cidr = network.cidr
network_model.gateway = network.gateway
network_model.dns_servers = network.dns_servers
network_model.pool_start = network.pool_start
network_model.pool_end = network.pool_end
network_model.region_name = network.region_name
network_model.state = network.state
if network.error_message != "":
network_model.error_message = network.error_message
network_model.created_at = network.created_at
network_model.updated_at = network.updated_at
return network_model
class RequestCreateZone(Model):
name = KubeName(required=True, min_length=3)
region_name = KubeName(required=True)
vm_cluster = StringType(required=True)
vm_datastore = StringType(required=True)
vm_folder = StringType()
core_provision_percent = IntType(min_value=0, required=True)
ram_provision_percent = IntType(min_value=0, required=True)
class ResponseImage(Model):
project_name = StringType(required=True)
name = KubeName(required=True, min_length=3)
file_name = StringType()
region_name = StringType(required=True)
state = EnumType(ResourceState, required=True)
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, image: Image):
image_model = cls()
image_model.project_name = image.project_name
image_model.name = image.name
image_model.file_name = image.file_name
image_model.region_name = image.region_name
image_model.state = image.state
if image.error_message != "":
image_model.error_message = image.error_message
image_model.created_at = image.created_at
image_model.updated_at = image.updated_at
return image_model
class ResponseRegion(Model):
name = KubeName(required=True, min_length=3)
datacenter = StringType(required=True, )
image_datastore = StringType(required=True)
image_folder = StringType()
schedulable = BooleanType(required=True)
state = EnumType(ResourceState, required=True)
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, region: Region):
region_model = cls()
region_model.name = region.name
region_model.datacenter = region.datacenter
region_model.image_datastore = region.image_datastore
region_model.image_folder = region.image_folder
region_model.schedulable = region.schedulable
region_model.state = region.state
if region.error_message != "":
region_model.error_message = region.error_message
region_model.created_at = region.created_at
region_model.updated_at = region.updated_at
return region_model
class ResponseVolume(Model):
name = KubeName(required=True, min_length=3)
zone_name = UUIDType(required=True)
size = IntType(required=True)
attached_to = UUIDType()
state = EnumType(ResourceState, required=True)
task = EnumType(VolumeTask)
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, volume: Volume):
model = cls()
model.name = volume.name
model.zone_name = volume.zone_name
model.size = volume.size
model.state = volume.state
model.attached_to = volume.attached_to_name
model.task = volume.task
model.error_message = volume.error_message
model.created_at = volume.created_at
model.updated_at = volume.updated_at
return model
class ResponseInstance(Model):
name = KubeName(required=True, min_length=3)
image_name = KubeName()
network_port_id = KubeName(required=True)
region_name = KubeName(required=True)
zone_name = KubeName()
service_account_name = KubeName()
keypair_names = ListType(KubeName, default=list)
state = EnumType(ResourceState, required=True)
power_state = EnumType(VMPowerState, required=True)
flavor_name = KubeName(required=True)
vcpus = IntType(required=True)
ram = IntType(required=True)
disk = IntType(required=True)
task = EnumType(VMTask)
tags = DictType(KubeString, default=dict)
user_data = StringType()
error_message = StringType()
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, instance: Instance):
instance_model = cls()
instance_model.name = instance.name
instance_model.image_name = instance.image_name
instance_model.network_port_id = instance.network_port_id
instance_model.service_account_name = instance.service_account_name
instance_model.region_name = instance.region_name
if instance.zone_name is not None:
instance_model.zone_name = instance.zone_name
for keypair_name in instance.keypair_names:
instance_model.keypair_names.append(keypair_name)
instance_model.state = instance.state
if instance.error_message != "":
instance_model.error_message = instance.error_message
instance_model.power_state = instance.power_state
if instance.flavor_name is not None:
instance_model.flavor_name = instance.flavor_name
instance_model.vcpus = instance.vcpus
instance_model.ram = instance.ram
instance_model.disk = instance.disk
instance_model.task = instance.task
instance_model.tags = instance.tags
instance_model.user_data = instance.user_data
instance_model.created_at = instance.created_at
instance_model.updated_at = instance.updated_at
return instance_model
class PolicyBinding(Model):
role = KubeName(required=True)
members = ListType(BindingMemberType, required=True)
def validate_members(self, data, value):
for member in value:
if value.count(member) > 1:
raise ValidationError(member + " appears multiple times in the binding")
return value
class ResponseRole(Model):
name = KubeName(required=True, min_length=3)
permissions = ListType(StringType, default=list)
state = EnumType(ResourceState, required=True)
created_at = ArrowType(required=True)
@classmethod
def from_database(cls, role):
model = cls()
model.name = role.name
model.permissions = role.permissions
model.state = role.state
model.created_at = role.created_at
return model
class ResponseKeypair(Model):
name = KubeName(required=True, min_length=3)
public_key = StringType(required=True)
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, keypair: Keypair):
model = cls()
model.name = keypair.name
model.public_key = keypair.public_key
model.created_at = keypair.created_at
model.updated_at = keypair.updated_at
return model
class RequestCreateNetwork(Model):
name = KubeName(required=True, min_length=3)
port_group = StringType(required=True)
cidr = IPv4NetworkType(required=True)
gateway = IPv4AddressType(required=True)
dns_servers = ListType(IPv4AddressType, min_size=1, required=True)
pool_start = IPv4AddressType(required=True)
pool_end = IPv4AddressType(required=True)
region_name = KubeName(required=True)
def validate_gateway(self, data, value):
cidr: ipaddress.IPv4Network = data['cidr']
if value not in cidr:
raise ValidationError('is not an address within ' + str(cidr))
return value
def validate_pool_start(self, data, value):
cidr: ipaddress.IPv4Network = data['cidr']
if value not in cidr:
raise ValidationError('is not an address within ' + str(cidr))
return value
def validate_pool_end(self, data, value):
cidr: ipaddress.IPv4Network = data['cidr']
if value not in cidr:
raise ValidationError('is not an address within ' + str(cidr))
if value < self.pool_start:
raise ValidationError('needs to be larger than pool_start')
return value
class RequestCreateKeypair(Model):
name = KubeName(required=True, min_length=3)
public_key = StringType(required=True)
def validate_public_key(self, data, value):
try:
load_ssh_public_key(value.encode(), default_backend())
except ValueError:
raise ValidationError(
"public_key could not be decoded or is not in the proper format"
)
except UnsupportedAlgorithm:
raise ValidationError(
"public_key serialization type is not supported")
return value
class ResponseServiceAccount(Model):
name = KubeName(required=True, min_length=3)
email = EmailType(required=True)
keys = DictType(ArrowType, required=True)
state = EnumType(ResourceState, required=True)
created_at = ArrowType(required=True)
@classmethod
def from_database(cls, service_account):
model = cls()
model.name = service_account.name
model.email = service_account.email
model.keys = service_account.keys
model.state = service_account.state
model.created_at = service_account.created_at
return model
class ResponseFlavor(Model):
name = KubeName(required=True, min_length=3)
vcpus = IntType(required=True)
ram = IntType(required=True)
disk = IntType(required=True)
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, flavor: Flavor):
model = cls()
model.name = flavor.name
model.vcpus = flavor.vcpus
model.ram = flavor.ram
model.disk = flavor.disk
model.created_at = flavor.created_at
model.updated_at = flavor.updated_at
return model
class ResponseNetworkPort(Model):
id = UUIDType(required=True)
network_name = KubeName(required=True)
ip_address = IPv4AddressType(required=True)
state = EnumType(ResourceState, required=True)
created_at = ArrowType(required=True)
updated_at = ArrowType(required=True)
@classmethod
def from_database(cls, network_port: NetworkPort):
model = cls()
model.id = network_port.name
model.network_name = network_port.network_name
model.ip_address = network_port.ip_address
model.state = network_port.state
model.created_at = network_port.created_at
model.updated_at = network_port.updated_at
return model
class RequestCreateInstance(Model):
name = KubeName(required=True, min_length=3)
image_name = KubeName(required=True)
service_account_name = KubeName()
network_name = KubeName(required=True)
region_name = KubeName(required=True)
zone_name = KubeName()
keypair_names = ListType(KubeName, default=list)
tags = DictType(KubeString, default=dict)
user_data = StringType()
flavor_name = KubeName(required=True)
disk = IntType()
initial_volumes = ListType(ModelType(RequestInitialVolumes), default=list)
def validate_disk(self, data, value):
if value is not None and value != 0:
IntType(min_value=5).validate_range(value)
class RequestCreateRole(Model):
name = KubeName(required=True, min_length=3)
permissions = ListType(StringType, default=list)
class ParamsZone(Model):
zone_name = KubeName(required=True)
class ParamsListZone(Model):
region_name = KubeName()
limit = IntType(default=100, max_value=100, min_value=1)
marker = UUIDType()
class RequestInstanceImage(Model):
name = KubeName(required=True)
class RequestCreateRegion(Model):
name = KubeName(required=True, min_length=3)
datacenter = StringType(required=True)
image_datastore = StringType(required=True)
image_folder = StringType()
class ParamsListNetwork(Model):
name = KubeName()
region = KubeName()
limit = IntType(default=100, max_value=100, min_value=1)
marker = UUIDType()
class ParamsRegion(Model):
region_name = KubeName(required=True)
class RequestCloneVolume(Model):
name = KubeName(required=True, min_length=3)
class ParamsListInstance(Model):
image_name = KubeName()
zone_name = KubeName()
region_name = KubeName()
limit = IntType(default=100, max_value=100, min_value=1)
marker = UUIDType()
class ParamsKeypair(Model):
keypair_name = KubeName(required=True)
class ParamsInstance(Model):
instance_name = KubeName(required=True)
class RequestCreateImage(Model):
name = KubeName(required=True, min_length=3)
file_name = StringType(required=True)
region_name = KubeName(required=True)
class ParamsNetwork(Model):
network_name = KubeName(required=True)
class RequestCreateVolume(Model):
name = KubeName(required=True, min_length=3)
zone_name = UUIDType(required=True)
size = IntType(required=True, min_value=5)
