def populateState(self, statepath):
ser = StackOps.service()
ser.set_type('state')
driver = StackOps.property()
driver.set_name('path')
driver.set_value(statepath)
ser.add_property(driver)
return ser
def populateMomHost(self, controller_host):
mom_host = StackOps.service()
mom_host.set_type('rabbitmq')
host = StackOps.property()
host.set_name('hostname')
host.set_value(controller_host)
mom_host.add_property(host)
return mom_host
def populateLogs(self, logdir):
ser = StackOps.service()
ser.set_type('logs')
driver = StackOps.property()
driver.set_name('dir')
driver.set_value(logdir)
ser.add_property(driver)
return ser
def populateControllerHost(self, controller_host):
cc_host = StackOps.service()
cc_host.set_type('cc_host')
host = StackOps.property()
host.set_name('hostname')
host.set_value(controller_host)
cc_host.add_property(host)
return cc_host
def populateFakeSubdomain(self, fakesubdomain):
ser = StackOps.service()
ser.set_type('FAKE_subdomain')
driver = StackOps.property()
driver.set_name('value')
driver.set_value(fakesubdomain)
ser.add_property(driver)
return ser
def populateLibvirt(self, libvirt_type):
ser = StackOps.service()
ser.set_type('libvirt')
driver = StackOps.property()
driver.set_name('type')
driver.set_value(libvirt_type)
ser.add_property(driver)
return ser
def populateAuthentication(self, authdriver, use_project_ca):
ser = StackOps.service()
ser.set_type('authentication')
driver = StackOps.property()
driver.set_name('driver')
driver.set_value(authdriver)
ser.add_property(driver)
ca = StackOps.property()
ca.set_name('use_project_ca')
ca.set_value(use_project_ca)
ser.add_property(ca)
return ser
def populateS3(self, hostname, dmz):
s3_host = StackOps.service()
s3_host.set_type('s3')
host = StackOps.property()
host.set_name('hostname')
host.set_value(hostname)
s3_host.add_property(host)
d = StackOps.property()
d.set_name('dmz')
d.set_value(dmz)
s3_host.add_property(d)
return s3_host
def populateGeneric(self,verbose_value,nodaemon_value):
generic = StackOps.service()
generic.set_type('generic')
verbose = StackOps.property()
verbose.set_name('verbose')
verbose.set_value(verbose_value)
generic.add_property(verbose)
nodaemon = StackOps.property()
nodaemon.set_name('nodaemon')
nodaemon.set_value(nodaemon_value)
generic.add_property(nodaemon)
return generic
def populateEc2(self, hostname, hostname_dmz):
ec2url = StackOps.service()
ec2url.set_type('ec2')
ec2url_host = StackOps.property()
ec2url_host.set_name('hostname')
ec2url_host.set_value(hostname)
ec2url.add_property(ec2url_host)
ec2url_dmz = StackOps.property()
ec2url_dmz.set_name('dmz')
ec2url_dmz.set_value(hostname_dmz)
ec2url.add_property(ec2url_dmz)
return ec2url
def populateDhcpbridge(self, dhcpbridge_process, dhcpbridge_flagfile):
dhcpbridge = StackOps.service()
dhcpbridge.set_type('dhcpbridge')
process = StackOps.property()
process.set_name('process')
process.set_value(dhcpbridge_process)
file = StackOps.property()
file.set_name('file')
file.set_value(dhcpbridge_flagfile)
dhcpbridge.add_property(process)
dhcpbridge.add_property(file)
return dhcpbridge
def populatePartition(self, mountpoint, device, size, used):
partition = StackOps.partition()
partition.set_mountpoint(mountpoint)
partition.set_device(device)
partition.set_size(size)
partition.set_used(used)
return partition
def populateHardware(self, cpus, memory, nics, virtualization, partitions):
hardware = StackOps.hardware()
hardware.set_memory(memory)
hardware.set_cpus(cpus)
hardware.set_virtualization(virtualization)
hardware.set_nics(nics)
hardware.set_partitions(partitions)
return hardware
def populateCloud(self, cloud, component, topology):
if (cloud is None):
cloud = StackOps.cloud()
if (component is not None):
cloud.add_component(component)
if (topology is not None):
cloud.set_topology(topology)
return cloud
def createNode(self,cloud):
machine = Machine()
operatingsystem = OperatingSystem()
# CPU Info
type_list = machine.getCPUType()
speed_list = machine.getCPUSpeed()
cpu_list = []
for name, speed in map(None, type_list, speed_list):
cpu_list.append(self.populateCPU(name, int(speed.split(".")[0]), 1))
cpus = self.populateCPUs(cpu_list)
# Memory
memory = machine.getMemoryAvailable()
# Network
nic_list = []
iface_list = machine.getIfaceList()
for iface in iface_list:
nic_list.append(self.populateNIC(iface, "", machine.getIfaceVendorList(iface)))
nics = self.populateNICs(nic_list)
# Partitions
partition_list = []
blockdev_list = machine.getBlockDeviceList()
for blockdev in blockdev_list:
partition_list.append(self.populatePartition(blockdev["mountpoint"], blockdev["device"], blockdev["size"], blockdev["used"]))
partitions = self.populatePartitions(partition_list)
# Hardware information
hardware = self.populateHardware(cpus, memory, nics, machine.getVirtualization(), partitions)
# OS information
# uname description
uname = operatingsystem.getUname()
# network configuration
hostname = operatingsystem.getHostname()
nameserver_list = operatingsystem.getNameservers()
iface_list = operatingsystem.getNetworkConfiguration()
network = self.populateNetwork(hostname, nameserver_list, iface_list)
os = self.populateOS(uname, network)
# Software information
software = self.populateSoftware(os)
# Cloud components
if (cloud is None):
cloud = StackOps.cloud()
# Node information
node = self.populateNode(hardware, software, cloud)
node.export(sys.stdout, 0)
return node
def populateInterfaces(self, flat_interface,public_interface):
rs = StackOps.service()
rs.set_type('interfaces')
# if (rsip!=None):
# ip = StackOps.property()
# ip.set_name('routing_source_ip')
# ip.set_value(rsip)
# rs.add_property(ip)
if (flat_interface!=None):
flat = StackOps.property()
flat.set_name('flat_interface')
flat.set_value(flat_interface)
rs.add_property(flat)
if (public_interface!=None):
public = StackOps.property()
public.set_name('public_interface')
public.set_value(public_interface)
rs.add_property(public)
return rs
def populateIface(self, address, default, dhcp, gateway, name, netmask,virtual):
iface = StackOps.iface()
iface.set_address(address)
iface.set_default(default)
iface.set_dhcp(dhcp)
iface.set_gateway(gateway)
iface.set_name(name)
iface.set_netmask(netmask)
iface.set_virtual(virtual)
return iface
def populateNetworkManager(self,type,fixed_range,network_size):
network = StackOps.service()
network.set_type('network')
type_network = StackOps.property()
type_network.set_name('type')
type_network.set_value(type)
network.add_property(type_network)
fixed_range_network = StackOps.property()
fixed_range_network.set_name('fixed_range')
fixed_range_network.set_value(fixed_range)
network.add_property(fixed_range_network)
network_size_network = StackOps.property()
network_size_network.set_name('network_size')
network_size_network.set_value(network_size)
network.add_property(network_size_network)
return network
def populateController(self,
verbose,
nodaemon,
mysql_username,
mysql_password,
mysql_hostname,
mysql_port,
mysql_schema,
auth_driver,
logdir,
state_path,
s3_host,
s3_dmz,
rabbit_host,
ec2_host,
ec2_dmz_host,
network_manager,
network_fixed_range,
network_size,
use_project_ca):
controller = StackOps.component()
controller.set_name('controller')
generic = self.populateGeneric(verbose,nodaemon)
controller.add_service(generic)
sql_connection = self.populateSqlConnection(mysql_username, mysql_password, mysql_hostname, mysql_port, mysql_schema)
controller.add_service(sql_connection)
auth = self.populateAuthentication(auth_driver,use_project_ca)
controller.add_service(auth)
logs = self.populateLogs(logdir)
controller.add_service(logs)
state = self.populateState(state_path)
controller.add_service(state)
s3 = self.populateS3(s3_host, s3_dmz)
controller.add_service(s3)
mom = self.populateMomHost(rabbit_host)
controller.add_service(mom)
ec2= self.populateEc2(ec2_host,ec2_dmz_host)
controller.add_service(ec2)
network_manager = self.populateNetworkManager(network_manager,network_fixed_range,network_size)
controller.add_service(network_manager)
return controller
def populateISCSI(self,iscsi_ip_prefix,num_targets,use_local_volumes):
iscsi = StackOps.service()
iscsi.set_type('iscsi')
if (iscsi_ip_prefix!=None):
ip_prefix = StackOps.property()
ip_prefix.set_name('ip_prefix')
ip_prefix.set_value(iscsi_ip_prefix)
iscsi.add_property(ip_prefix)
if (num_targets!=None):
n_targets = StackOps.property()
n_targets.set_name('num_targets')
n_targets.set_value(num_targets)
iscsi.add_property(n_targets)
if (use_local_volumes!=None):
local_volumes = StackOps.property()
local_volumes.set_name('use_local_volumes')
local_volumes.set_value(use_local_volumes)
iscsi.add_property(local_volumes)
return iscsi
def populateNetwork(self, hostname, nameserver_list, iface_list):
network = StackOps.network()
network.set_hostname(hostname)
print nameserver_list
for nameserver in nameserver_list:
network.add_nameserver(nameserver)
for iface in iface_list:
address = iface["address"]
default = iface["default"]
dhcp = iface["dhcp"]
gateway = iface["gateway"]
name = iface["name"]
netmask = iface["netmask"]
virtual = iface["virtual"]
network.add_iface(self.populateIface(address, default, dhcp, gateway, name, netmask,virtual))
return network
def populateSqlConnection(self, username, password, hostname, port, schema):
sql_connection = StackOps.service()
sql_connection.set_type('database')
mysql_username = StackOps.property()
mysql_username.set_name('username')
mysql_username.set_value(username)
sql_connection.add_property(mysql_username)
mysql_pass = StackOps.property()
mysql_pass.set_name('password')
mysql_pass.set_value(password)
sql_connection.add_property(mysql_pass)
mysql_host = StackOps.property()
mysql_host.set_name('host')
mysql_host.set_value(hostname)
sql_connection.add_property(mysql_host)
mysql_port = StackOps.property()
mysql_port.set_name('port')
mysql_port.set_value(port)
sql_connection.add_property(mysql_port)
mysql_schema = StackOps.property()
mysql_schema.set_name('schema')
mysql_schema.set_value(schema)
sql_connection.add_property(mysql_schema)
return sql_connection
def populateCPUs(self, cpu_list):
cpus = StackOps.cpus()
for cpu in cpu_list:
cpus.add_cpu(cpu)
return cpus
def populateNode(self, hardware, software,cloud):
node = StackOps.node()
node.set_hardware(hardware)
node.set_software(software)
node.set_cloud(cloud)
return node
def populateNICs(self, nic_list):
nics = StackOps.nics()
for nic in nic_list:
nics.add_nic(nic)
return nics
def populatePartitions(self, partition_list):
partitions = StackOps.partitions()
for partition in partition_list:
partitions.add_partition(partition)
return partitions
def populateNodaemon(self):
verbose = StackOps.service()
verbose.set_type('nodaemon')
return verbose
def populateOS(self, uname, network):
os = StackOps.os()
os.set_uname(uname)
os.set_network(network)
return os
def populateSoftware(self, os):
software = StackOps.software()
software.set_os(os)
return software
def populateNIC(self, interface, type_, name):
nic = StackOps.nic()
nic.set_interface(interface)
nic.set_type(type_)
nic.set_name(name)
return nic