def orderServer(hostname, domain, datacenter, cpus, memory, hourly, os_code,
image_id, local_disk, disks, nic_speed, post_uri, ssh_keys,
private, dedicated, private_vlan, tags):
vsManager = VSManager(client)
instance = vsManager.create_instance(
hostname=hostname,
domain=domain,
datacenter=datacenter,
cpus=cpus,
memory=memory,
hourly=hourly,
os_code=os_code,
image_id=image_id,
local_disk=local_disk,
disks=disks, # [] if image
nic_speed=nic_speed,
post_uri=post_uri,
ssh_keys=ssh_keys,
private=private,
dedicated=dedicated,
private_vlan=private_vlan,
tags=tags)
#print simplejson.dumps(instance, sort_keys=True, indent=4 * ' ')
return instance
def getInstance(id):
try:
vsManager = VSManager(client)
instance = vsManager.get_instance(id)
return instance
except:
return None
def createImage(id, name, notes):
vsManager = VSManager(client)
image = vsManager.capture(instance_id=id,
name=name,
additional_disks=True,
notes=notes)
return image
def task_add_content_migration_meta_data(self, user_id, data):
user = User.query.get(user_id)
softlayer_clouds = user.project.softlayer_clouds.filter_by(
status=VALID).all()
for cloud in softlayer_clouds:
client = create_client_from_env(cloud.username,
decrypt_api_key(cloud.api_key))
vs_manger = VSManager(client)
try:
vsi_id = vs_manger.list_instances(public_ip=data["ip"])[0]["id"]
break
except (KeyError, IndexError):
vsi_id = None
if not vsi_id:
LOGGER.info(
f"VSI Not Found for public IP: {data['ip']} against user: {user_id}"
)
return
cm_object = CMModels.query.filter_by(softlayer_vsi_id=vsi_id).first()
if cm_object:
cm_object.cm_meta_data = data
else:
cm_object = CMModels(softlayer_vsi_id=vsi_id, cm_meta_data=data)
doosradb.session.add(cm_object)
doosradb.session.commit()
cm_object = CMModels.query.filter_by(softlayer_vsi_id=vsi_id).first()
if cm_object:
cm_object.cm_meta_data = data
else:
cm_object = CMModels(softlayer_vsi_id=vsi_id, cm_meta_data=data)
doosradb.session.add(cm_object)
doosradb.session.commit()
LOGGER.info(f"VSI: {vsi_id} meta data saved for user: {user_id}")
def orderServer(counter):
uniqueHostname = ''
if (args.uniqueId != ''):
uniqueHostname = args.uniqueId + "-"
uniqueHostname += args.hostname + "-" + str(counter)
if (args.verbose):
print 'Building: ' + uniqueHostname
disks = []
if (args.localDisk):
disks.append(args.localDisk1Size)
if (args.localDisk and args.localDisk2Size != None):
disks.append(args.localDisk2Size)
else:
disks.append(args.sanDisk1Size)
if (args.sanDisk2Size != None):
disks.append(args.sanDisk2Size)
if (args.sanDisk3Size != None):
disks.append(args.sanDisk3Size)
if (args.sanDisk4Size != None):
disks.append(args.sanDisk4Size)
if (args.sanDisk5Size != None):
disks.append(args.sanDisk5Size)
osCode = ''
templateGuid = ''
if (args.osCode != None and args.osCode != ''):
osCode = args.osCode
templateGuid = ''
else:
osCode = ''
templateGuid = args.templateGuid
disks = [] # Blank out disks since it will use the template
sshKeys = []
if (args.sshKey != None and args.sshKey != ''):
sshKeys.append(args.sshKey)
vsManager = VSManager(client)
instance = vsManager.create_instance(hostname=uniqueHostname,
domain=args.domain,
cpus=args.cpus,
memory=args.memory,
hourly=args.hourly,
datacenter=args.datacenter,
os_code=osCode,
image_id=templateGuid,
local_disk=args.localDisk,
disks=disks,
ssh_keys=sshKeys,
nic_speed=args.nicSpeed,
private=args.private,
private_vlan=args.privateVlan,
dedicated=args.dedicated,
post_uri=args.postInstallUrl,
tags=args.tag)
return instance
def orderServer(self, counter, hostname, domain, cpus, memory, localDisk, private, hourly, datacenter, osCode, privateVlan, nicSpeed, dedicated, templateGuid, postInstallUrl, tag):
uniqueHostname = hostname + "-" + str(counter)
sshKeys = []
disks = [100]
if (osCode != None and osCode != ''):
templateGuid = ''
else:
osCode = ''
disks = [] # Blank out disks since it will use the template
vsManager = VSManager(self.Client)
instance = vsManager.create_instance(
hostname = uniqueHostname,
domain = domain,
cpus = cpus,
memory = memory,
hourly = hourly,
datacenter = datacenter,
os_code = osCode,
image_id = templateGuid,
local_disk = localDisk,
disks = disks,
ssh_keys = sshKeys,
nic_speed = nicSpeed,
private = private,
private_vlan = privateVlan,
dedicated = dedicated,
post_uri = postInstallUrl,
tags = tag)
return instance
def provisionServers(self, quantity, hostname, domain, cpus, memory, localDisk, private, hourly, datacenter, osCode, privateVlan, nicSpeed, dedicated, templateGuid, postInstallUrl, tag):
print 'Begin Provisioning: ' + time.strftime('%Y-%m-%d %I:%M:%S %Z')
startTime = datetime.now()
serverIds = []
counter = 1
completed = False
if ',' in tag:
tag = tag.split(',')[0]
while counter <= quantity:
createdInstance = self.orderServer(counter, hostname, domain, cpus, memory, localDisk, private, hourly, datacenter, osCode, privateVlan, nicSpeed, dedicated, templateGuid, postInstallUrl, tag)
createdId = createdInstance['id']
print 'Built Server: ' + str(createdId)
serverIds.append(createdId)
counter += 1
vsManager = VSManager(self.Client)
print 'Waiting for provisioning completion'
while completed == False:
time.sleep(10)
exit = True
for serverId in serverIds:
time.sleep(1)
instance = vsManager.get_instance(serverId)
if 'activeTransaction' in instance.keys():
activeTransaction = instance['activeTransaction']['transactionStatus']['name']
if activeTransaction != 'SERVICE_SETUP':
exit = False
if exit == True:
completed = True
print 'Sleeping for 1 minute before power off'
time.sleep(60)
# Power Off servers
for serverId in serverIds:
print 'Powering off: ' + str(serverId)
time.sleep(1)
self.Client['Virtual_Guest'].powerOff(id=serverId)
time.sleep(60)
print 'Completed Provisioning: ' + time.strftime('%Y-%m-%d %I:%M:%S %Z')
def orderServer(hostname, domain, cpus, memory, disk, osCode, templateGuid,
useLocalDisk, datacenter, private, dedicated, hourly, tag,
privateVlan, nicSpeed, sshKey, userData, postInstallUrl):
disks = []
disks.append(disk)
if (osCode != None and osCode != ''):
templateGuid = ''
else:
osCode = ''
disks = [] # Blank out disks since it will use the template
sshKeys = []
if (sshKey != None and sshKey != ''):
sshKeys.append(sshKey)
vsManager = VSManager(client)
instance = vsManager.create_instance(hostname=hostname,
domain=domain,
cpus=cpus,
memory=memory,
hourly=hourly,
datacenter=datacenter,
os_code=osCode,
image_id=templateGuid,
local_disk=useLocalDisk,
disks=disks,
ssh_keys=sshKeys,
nic_speed=nicSpeed,
private=private,
private_vlan=privateVlan,
dedicated=dedicated,
post_uri=postInstallUrl,
userdata=userData,
tags=tag)
return instance
def captureImage(instanceId, name, additional_disks, notes):
vsManager = VSManager(client)
image = vsManager.capture(instanceId, name, additional_disks, notes)
print 'Creating Image: ' + name
return image.id # Returns just a transaction Id / Not the actual Image Id ??
def cancelInstance(id):
vsManager = VSManager(client)
vsManager.cancel_instance(id)
print 'Canceling: ' + str(id)
def getInstances(tag):
vsManager = VSManager(client)
instances = vsManager.list_instances(tags=[tag])
return instances
def getInstance(id):
vsManager = VSManager(client)
instance = vsManager.get_instance(id)
return instance
def getCreateOptions():
vsManager = VSManager(client)
options = vsManager.get_create_options()
return options
def getInstance(id):
vsManager = VSManager(client)
instance = vsManager.get_instance(id)
print json.dumps(instance, sort_keys=True, indent=4)
return instance
def getInstances():
vsManager = VSManager(client)
instances = vsManager.list_instances(tags=tags, datacenter=datacenter)
return instances
parser.add_option("-z", "--disks", dest="custom_disk", default=None)
parser.add_option("-n", "--network", dest="network", default='1Gb')
parser.add_option("-q", "--quantity", dest="quantity", default=1)
parser.add_option("-i", "--image", dest="image", default='CentOS-7')
parser.add_option("-r", "--region", dest="datacenter", default='sao01')
parser.add_option("-l", "--local-only", dest="local_only", default=False)
(opt, args) = parser.parse_args()
sl_user = '******'
sl_apikey = 'YOUR_SOFTLAYER_AKEY'
image_regex = r'[a-zA-Z0-9]{8}(-[a-zA-Z0-9]{4}){3}-[a-zA-Z0-9]{12}'
client = Client(username=sl_user,api_key=sl_apikey)
vs = VSManager(client)
def _str_to_bool(s):
if s in ['True', 'true', 't', 1]:
return True
return False
config = {
'domain': 'mydomain.com',
'cpu': int(opt.cpu),
'memory': str(opt.memory),
'network': str(opt.network),
'name': str(opt.server_name),
'billing': str(opt.billing),
'environment': str(opt.environment),
247808
]
INITIALDISK_SIZES = [25, 100]
LOCALDISK_SIZES = [25, 100, 150, 200, 300]
SANDISK_SIZES = [
10, 20, 25, 30, 40, 50, 75, 100, 125, 150, 175, 200, 250, 300, 350, 400,
500, 750, 1000, 1500, 2000
]
NIC_SPEEDS = [10, 100, 1000]
try:
import SoftLayer
from SoftLayer import VSManager
HAS_SL = True
vsManager = VSManager(SoftLayer.create_client_from_env())
except ImportError:
HAS_SL = False
def create_virtual_instance(module):
instances = vsManager.list_instances(
hostname=module.params.get('hostname'),
domain=module.params.get('domain'),
datacenter=module.params.get('datacenter'))
if instances:
return False, None
# Check if OS or Image Template is provided (Can't be both, defaults to OS)
def getInstances(tag):
vsManager = VSManager(client)
instances = vsManager.list_instances(tags=[tag])
print json.dumps(instances, sort_keys=True, indent=4)
return instances
