def test_saas_server_create(self):
"""Test if we can create a VM using an live endpoint object and shut it down"""
# This cli command would make a server similar to below
# dcm-create-server --machineimage 29710 --datacenter 1273 \
# --name igable-terminateme --productid t1.micro --budgetid 1512 --description longstring
self.server = Server(endpoint=self.endpoint)
self.server.set_from_file("../../secret-test-data/ubuntu-trusty-14.04-amd64-server-20150629.json")
# override the server name loaded from the json
self.server.name = "mixcoatl-qa-%s" % str(uuid.uuid4())[:8]
self.job_id = self.server.launch()
Job.wait_for(self.job_id, endpoint=self.endpoint)
self.job = Job(job_id=str(self.job_id), endpoint=self.endpoint)
self.running_server = Server(self.job.message, endpoint=self.endpoint)
self.running_server.wait_for(status="RUNNING")
assert self.server.provider_product_id == self.running_server.provider_product_id
assert self.server.machine_image["machine_image_id"] == self.running_server.machine_image["machine_image_id"]
assert self.server.data_center == self.running_server.data_center
assert self.server.description == self.running_server.description
assert self.server.name == self.running_server.name
assert self.server.budget == self.running_server.budget
def test_saas_server_create(self):
"""Test if we can create a VM using an live endpoint object and shut it down"""
# This cli command would make a server similar to below
# dcm-create-server --machineimage 29710 --datacenter 1273 \
# --name igable-terminateme --productid t1.micro --budgetid 1512 --description longstring
self.server = Server(endpoint=self.endpoint)
self.server.set_from_file(
"../../secret-test-data/ubuntu-trusty-14.04-amd64-server-20150629.json"
)
# override the server name loaded from the json
self.server.name = "mixcoatl-qa-%s" % str(uuid.uuid4())[:8]
self.job_id = self.server.launch()
Job.wait_for(self.job_id, endpoint=self.endpoint)
self.job = Job(job_id=str(self.job_id), endpoint=self.endpoint)
self.running_server = Server(self.job.message, endpoint=self.endpoint)
self.running_server.wait_for(status='RUNNING')
assert self.server.provider_product_id == self.running_server.provider_product_id
assert self.server.machine_image[
'machine_image_id'] == self.running_server.machine_image[
'machine_image_id']
assert self.server.data_center == self.running_server.data_center
assert self.server.description == self.running_server.description
assert self.server.name == self.running_server.name
assert self.server.budget == self.running_server.budget
def create(self, callback=None):
"""Creates a new volume
:param callback: Optional callback to send the resulting :class:`Job`
:type callback: func.
:returns: :class:`Job`
:raises: :class:`VolumeCreationException`
"""
optional_attrs = ['label']
if self.volume_id is not None:
raise VolumeCreationException(
'Cannot create an already created volume: %s' % self.volume_id)
parms = {'name': self.name, 'description': self.description, 'data_center': self.data_center,
'size_in_gb': self.size_in_gb, 'budget': self.budget}
for oa in optional_attrs:
try:
if getattr(self, oa) is not None:
parms[0].update({oa: getattr(self, oa)})
except AttributeError:
pass
payload = {'addVolume': [camel_keys(parms)]}
self.post(data=json.dumps(payload))
if self.last_error is None:
j = Job(self.current_job, endpoint=self.endpoint)
j.load()
if callback is not None:
callback(j)
else:
return j
else:
raise VolumeCreationException(self.last_error)
def reload(self):
"""Reload resource data from API calls"""
if self.relational_database_id is not None:
self.load()
elif self.current_job is None:
self.load()
else:
if Job.wait_for(self.current_job):
job = Job(self.current_job)
self.__relational_database_id = job.message
self.load()
else:
return self.last_error
def reload(self):
"""Reload resource data from API calls"""
if self.storage_object_id is not None:
self.load()
elif self.current_job is None:
self.load()
else:
if Job.wait_for(self.current_job):
job = Job(self.current_job)
self.__storage_object_id = job.message
self.load()
else:
return self.last_error
def reload(self):
"""Reload resource data from API calls"""
if self.server_id is not None:
self.load()
elif self.current_job is None:
self.load()
else:
if Job.wait_for(self.current_job):
job = Job(self.current_job, endpoint=self.endpoint)
self.__server_id = job.message
self.load()
else:
return self.last_error
def add_snapshot(cls,
volume_id,
name,
description,
budget,
callback=None,
endpoint=None):
"""Creates a snapshot from `volume_id`
.. warning::
Snapshot creation is an asynchronous task.
Specifying a callback will cause a blocking operation while the snapshot completes.
When using the callback, execution could block for a **VERY** long time depending on the time it takes to make the snapshot.
:param volume_id: The volume to snapshot
:type volume_id: int.
:param name: The name for the snapshot
:type name: str.
:param description: Description of the snapshot
:type description: str.
:param budget: The billing code for the snapshot
:type budget: int.
:param callback: An optional callback to send the final :class:`Snapshot`.
:type callback: func.
:returns: :class:`Snapshot`
:raises: :class:`SnapshotException`
"""
s = cls()
s.volume = volume_id
s.name = name
s.budget = budget
s.description = description
s.create()
if s.current_job is None:
raise SnapshotException('No job found. This is...odd')
else:
if callback is not None:
job = Job.wait_for(s.current_job)
if job is True:
try:
j = Job(s.current_job, endpoint=endpoint)
snapshot = cls(j.message)
snapshot.load()
callback(snapshot)
except:
raise SnapshotException("Unhandled error in callback")
else:
return s
def watch_jobs():
job_averages = []
print("Processing jobs... Please hold.")
job_table = PrettyTable(["ID", "Status", "Description", "Minutes to Complete"])
while len(jobs) > 0:
for i in jobs:
if Job.wait_for(i) == True:
the_job = Job(i)
start = datetime.strptime(the_job.start_date.split("+")[0], '%Y-%m-%dT%H:%M:%S.%f')
end = datetime.strptime(the_job.end_date.split("+")[0], '%Y-%m-%dT%H:%M:%S.%f')
min_to_comp = (end - start).seconds
job_averages.append(min_to_comp)
job_table.add_row([the_job.job_id, the_job.status, the_job.description, round((min_to_comp/60),3)])
if 'Launch Server' in the_job.description:
servers_launched.append(int(the_job.message))
elif 'CREATE VOLUME' in the_job.description:
volumes_created.append(int(the_job.message))
elif 'Snapshot of' in the_job.description:
snapshots_created.append(int(the_job.message))
elif 'Create Image' in the_job.description:
images_created.append(int(the_job.message))
jobs.remove(i)
#print "Averages:",job_averages
average = round((sum(job_averages)/60)/len(job_averages),3)
averages.append(average)
job_table.add_row(["--","--","--",average])
print job_table
def create(self, **kwargs):
"""Create a new network
:param callback: Optional callback to call with resulting :class:`Network`
:type callback: func.
:returns: :class:`Job`
:raises: :class:`NetworkException`
"""
optional_attrs = [
'owning_groups', 'ntp_servers', 'dns_servers', 'label'
]
payload = {
'add_network': [{
'budget': self.budget,
'name': self.name,
'network_address': self.network_address,
'description': self.description,
'region': self.region
}]
}
if 'label' in kwargs:
payload['add_network'][0]['label'] = kwargs['label']
callback = kwargs.get('callback', None)
for oa in optional_attrs:
try:
if getattr(self, oa) is not None:
payload['add_network'][0].update({oa: getattr(self, oa)})
except AttributeError:
pass
self.post(self.PATH, data=json.dumps(camel_keys(payload)))
if self.last_error is None:
j = Job(self.current_job, endpoint=self.endpoint)
j.load()
if callback is not None:
callback(j)
else:
return j
else:
raise NetworkException(self.last_error)
def create(self, **kwargs):
"""Create a new network
:param callback: Optional callback to call with resulting :class:`Network`
:type callback: func.
:returns: :class:`Job`
:raises: :class:`NetworkException`
"""
optional_attrs = [
'owning_groups', 'ntp_servers', 'dns_servers', 'label']
payload = {'add_network': [{
'budget': self.budget,
'name': self.name,
'network_address': self.network_address,
'description': self.description,
'region': self.region}]}
if 'label' in kwargs:
payload['add_network'][0]['label'] = kwargs['label']
callback = kwargs.get('callback', None)
for oa in optional_attrs:
try:
if getattr(self, oa) is not None:
payload['add_network'][0].update({oa: getattr(self, oa)})
except AttributeError:
pass
self.post(self.PATH, data=json.dumps(camel_keys(payload)))
if self.last_error is None:
j = Job(self.current_job)
j.load()
if callback is not None:
callback(j)
else:
return j
else:
raise NetworkException(self.last_error)
def test_volume_creation(self):
"""Test the creating of a dummy volume against a live endpoint"""
# This command would create a volume similar to below
# dcm-create-volume --budgetid 1512 --datacenter 1273 --size 1 --name mixcoatl-qa --description junk
self.volume = Volume(endpoint=self.endpoint)
self.volume.set_from_file("../../secret-test-data/vagrant-volume.json")
self.volume.name = "mixcoatl-qa-%s" % str(uuid.uuid4())[:8]
self.job = self.volume.create()
Job.wait_for(self.job.job_id, endpoint=self.endpoint)
# force reload of job attributed from DCM API
self.job.load()
self.live_volume = Volume(volume_id=self.job.message, endpoint=self.endpoint)
assert self.volume.data_center == self.live_volume.data_center
assert self.volume.budget == self.live_volume.budget
assert self.volume.size_in_gb == self.live_volume.size_in_gb
assert self.volume.description == self.live_volume.description
assert self.volume.name == self.live_volume.name
def create(self, **kwargs):
"""Create a new firewall
:param label: Optional label to assign the firewall
:type label: str.
:param callback: Optional callback to call with resulting :class:`Firewall`
:type callback: func.
:returns: :class:`Firewall`
:raises: :class:`FirewallException`
"""
payload = {
'add_firewall': [{
'budget': self.budget,
'region': self.region,
'name': self.name,
'description': self.description
}]
}
if 'label' in kwargs:
payload['add_firewall'][0]['label'] = kwargs['label']
callback = kwargs.get('callback', None)
self.post(self.PATH, data=json.dumps(camel_keys(payload)))
if self.last_error is None:
if callback is None:
return self
else:
if Job.wait_for(self.current_job) is True:
j = Job(self.current_job, endpoint=self.endpoint)
self.__firewall_id = j.message
self.load()
return self
else:
raise FirewallException(j.last_error)
else:
raise FirewallException(self.last_error)
def reload(self):
"""Reload resource data from API calls"""
if self.server_id is not None:
self.load()
elif self.current_job is None:
self.load()
else:
if Job.wait_for(self.current_job):
job = Job(self.current_job)
self.__server_id = job.message
self.load()
else:
return self.last_error
def reload(self):
"""Reload resource data from API calls"""
if self.product_id is not None:
self.load()
elif self.current_job is None:
self.load()
else:
if Job.wait_for(self.current_job):
job = Job(self.current_job)
self.__relational_database_id = job.message
self.load()
else:
return self.last_error
def test_volume_creation(self):
"""Test the creating of a dummy volume against a live endpoint"""
# This command would create a volume similar to below
# dcm-create-volume --budgetid 1512 --datacenter 1273 --size 1 --name mixcoatl-qa --description junk
self.volume = Volume(endpoint=self.endpoint)
self.volume.set_from_file("../../secret-test-data/vagrant-volume.json")
self.volume.name = "mixcoatl-qa-%s" % str(uuid.uuid4())[:8]
self.job = self.volume.create()
Job.wait_for(self.job.job_id, endpoint=self.endpoint)
# force reload of job attributed from DCM API
self.job.load()
self.live_volume = Volume(volume_id=self.job.message,
endpoint=self.endpoint)
assert self.volume.data_center == self.live_volume.data_center
assert self.volume.budget == self.live_volume.budget
assert self.volume.size_in_gb == self.live_volume.size_in_gb
assert self.volume.description == self.live_volume.description
assert self.volume.name == self.live_volume.name
def add_snapshot(cls, volume_id, name, description, budget, callback=None):
"""Creates a snapshot from `volume_id`
.. warning::
Snapshot creation is an asynchronous task.
Specifying a callback will cause a blocking operation while the snapshot completes.
When using the callback, execution could block for a **VERY** long time depending on the time it takes to make the snapshot.
:param volume_id: The volume to snapshot
:type volume_id: int.
:param name: The name for the snapshot
:type name: str.
:param description: Description of the snapshot
:type description: str.
:param budget: The billing code for the snapshot
:type budget: int.
:param callback: An optional callback to send the final :class:`Snapshot`.
:type callback: func.
:returns: :class:`Snapshot`
:raises: :class:`SnapshotException`
"""
s = cls()
s.volume = volume_id
s.name = name
s.budget = budget
s.description = description
s.create()
if s.current_job is None:
raise SnapshotException('No job found. This is...odd')
else:
if callback is not None:
job = Job.wait_for(s.current_job)
if job is True:
try:
j = Job(s.current_job)
snapshot = cls(j.message)
snapshot.load()
callback(snapshot)
except:
raise SnapshotException("Unhandled error in callback")
else:
return s
def create(self, **kwargs):
"""Create a new firewall
:param label: Optional label to assign the firewall
:type label: str.
:param callback: Optional callback to call with resulting :class:`Firewall`
:type callback: func.
:returns: :class:`Firewall`
:raises: :class:`FirewallException`
"""
payload = {'add_firewall': [{
'budget': self.budget,
'region': self.region,
'name': self.name,
'description': self.description
}]}
if 'label' in kwargs:
payload['add_firewall'][0]['label'] = kwargs['label']
callback = kwargs.get('callback', None)
self.post(self.PATH, data=json.dumps(camel_keys(payload)))
if self.last_error is None:
if callback is None:
return self
else:
if Job.wait_for(self.current_job) is True:
j = Job(self.current_job, endpoint=self.endpoint)
self.__firewall_id = j.message
self.load()
return self
else:
raise FirewallException(j.last_error)
else:
raise FirewallException(self.last_error)
