def set_current_server_networks(self): cs_dfw = pyrax.connect_to_cloudservers(region="ORD") cs_ord = pyrax.connect_to_cloudservers(region="DFW") dfw_servers = cs_dfw.servers.list() ord_servers = cs_ord.servers.list() self.servers = dfw_servers + ord_servers for server in self.servers: if server.name == self.server_name: self.network = server.networks
def get_servers(location = 'all'):
region_list = {}
if location == 'all':
for temp_reg in pyrax.regions:
for server in pyrax.connect_to_cloudservers(region=temp_reg).servers.list():
region_list[server.name] = [ server.name, server.id, server.status, temp_reg ]
else:
for server in pyrax.connect_to_cloudservers(region=location).servers.list():
region_list[server.name] = [ server.name, server.id, server.status, location ]
return region_list
def build_server(build_queue):
# create list of server information to keep each build contained to it's own thread
build_details = []
try:
print "Getting job from queue..."
server_name = build_queue.get()
if ssh_auth == "y":
print "Connecting to cloud to build server %s" % server_name
server = pyrax.connect_to_cloudservers(region=region).servers.create(server_name, server_id, server_flv_id, ssh_auth)
print "%s has started building" % server_name
#pass
else:
server = pyrax.connect_to_cloudservers(region=region).servers.create(server_name, server_id, server_flv_id)
#pass
build_details.append(breakpoint)
build_details.append("Name: " + server.name)
build_details.append("ID: " + server.id)
build_details.append("Region: " + region)
build_details.append("Admin Password: "******"status", ["ACTIVE", "ERROR"], interval=5, callback=None, attempts=0, verbose=False, verbose_atts="progress")
pyrax.utils.wait_until(server, 'status', ('ACTIVE', 'ERROR'), interval=5, attempts=wait_timeout/5)
build_details.append("Network information:")
for i in server.networks.get(u'public'):
build_details.append("Public IP: " + i)
#build_details.append("Public IP: " + server.networks.get(u'public')[0])
build_details.append("Private IP: " + server.networks.get(u'private')[0])
except:
print "Pyrax wait for build unsuccessful. Please reference your cloud panel for server IP's"
print breakpoint
server_info.write(breakpoint)
for info in build_details:
print info
server_info.write(info + "\n")
print breakpoint
server_info.write(breakpoint)
#server_info.write(build_details)
#print build_details
build_queue.task_done()
print "%s has finished, ending thread" % server_name
except nexc.BadRequest as e:
print "Bad image/flavor combination. Please try again. (wah wah wah)\n"
exit()
def listservers():
'''Print out servers in account'''
auth()
fields = ['Name', 'DC', 'Status', 'Date Created', 'Server ID']
servdata = []
dfwservers = pyrax.connect_to_cloudservers(region='DFW')
ordservers = pyrax.connect_to_cloudservers(region='ORD')
for server in dfwservers.servers.list():
servdata.append((server.name, 'DFW', server.status, server.created,
server.id))
for server in ordservers.servers.list():
servdata.append((server.name, 'ORD', server.status, server.created,
server.id))
printhortable(fields, servdata)
def master_up(key_name, credential_file="~/.rackspace_cloud_credentials",
image=default_layout["master"]["image"],
flavor=default_layout["master"]["flavor"],
name=default_layout["master"]["hostname"],
region="IAD"):
'''
Create a salt-master on Rackspace
Alternatively create the master using nova
'''
# Authenticate with Rackspace, use credential file
pyrax.set_setting("identity_type", "rackspace")
pyrax.set_credential_file(os.path.expanduser(credential_file))
# Shorthand
cs = pyrax.connect_to_cloudservers(region=region)
master = cs.servers.create(name, image, flavor, key_name=key_name)
master = pyrax.utils.wait_for_build(master, verbose=True)
env.hosts = [master.accessIPv4]
print(master.networks)
print("Master IP: {}".format(master.accessIPv4))
return master.accessIPv4
def minions_up(key_name, credential_file="~/.rackspace_cloud_credentials",
layout=default_layout, region="IAD"):
'''
Creates a specific build of machines and bootstraps salt.
The credential file can be set via keyword credential_file, and defaults
to ~/.rackspace_cloud_credentials
'''
# Authenticate with Rackspace, use credential file
pyrax.set_setting("identity_type", "rackspace")
pyrax.set_credential_file(os.path.expanduser(credential_file))
# Shorthand
cs = pyrax.connect_to_cloudservers(region=region)
minions = []
for minion in layout["minions"]:
minions.append(cs.servers.create(minion["hostname"],
minion["image"],
minion["flavor"],
key_name=key_name))
# Make sure all the minions are done before we move on to fabric runs
minions = [pyrax.utils.wait_for_build(minion, verbose=True)
for minion in minions]
env.hosts = [str(minion.accessIPv4) for minion in minions]
print(env.hosts)
def main():
pyrax.set_setting("identity_type", "rackspace")
creds_file = os.path.expanduser('~/.rackspace_cloud_credentials')
pyrax.set_credential_file(creds_file)
available_regions = pyrax.regions
print "Regions Available:", " ".join(list(available_regions))
region = ""
while region not in available_regions:
region = raw_input("Select Region: ")
cs = pyrax.connect_to_cloudservers(region)
available_images = cs.images.list()
available_flavors = cs.flavors.list()
image = make_choice(images, "Select an image: ")
flavor = make_choice(flavors, "Select a flavor: ")
base_name = raw_input('Base server name': )
server_count = int(raw_input('Number of servers to build: '))
print "Building {} servers with base name '{}', flavor '{}', and image "
"'{}'.".format(server_count, base_name, flavor.name, image.name)
def test_connect_to_cloudservers(self):
pyrax.cloudservers = None
sav = pyrax.connect_to_cloudservers
pyrax.connect_to_cloudservers = self.orig_connect_to_cloudservers
pyrax.cloudservers = pyrax.connect_to_cloudservers()
self.assertIsNotNone(pyrax.cloudservers)
pyrax.connect_to_cloudservers = sav
def check_region_pings(pool, region):
"""Check pings for all servers in a given region"""
cs = pyrax.connect_to_cloudservers(region=region)
log.debug("Checking pings for %s", region)
servers = cs.servers.findall()
log.debug("%3i servers in Region %s", len(servers), region)
list(pool.map(check_ping, servers))
def server_info(id, dc):
cs = pyrax.connect_to_cloudservers(region=dc)
server = cs.servers.get(id)
print "Server Name: ", server.name
print "Server ID: ", server.id
print "Public IP: ", server.accessIPv4
print "Private IP :", server.addresses['private'][0]['addr']
def __init__(self, task_kwargs=None, json_config_file=None):
json_config_file = json_config_file or './deploy_settings.json'
self.cloudservers = None
self.settings = AttributeDict({})
self.fabric_env_servers = []
self.created_servers = []
task_kwargs = task_kwargs or {}
settings = self.read_settings_file(json_config_file)
for key in self.SETTINGS_KEYS:
try:
self.settings[key] = task_kwargs[key]
except KeyError:
try:
self.settings[key] = environ[key]
except KeyError:
try:
self.settings[key] = settings[key]
except KeyError:
pass
self.settings.server_count = int(self.settings.server_count)
self.settings.setdefault('ssh_user', 'root')
self.settings.setdefault('git_branch', 'master')
self.ensure_settings('rackspace_username', 'rackspace_apikey')
pyrax.set_setting('identity_type', 'rackspace')
pyrax.set_credentials(
self.settings.rackspace_username,
self.settings.rackspace_apikey)
self.cloudservers = pyrax.connect_to_cloudservers()
self.loadbalancers = pyrax.connect_to_cloud_loadbalancers()
def test_connect_to_cloudservers(self):
pyrax.cloudservers = None
sav = pyrax.connect_to_cloudservers
pyrax.connect_to_cloudservers = self.orig_connect_to_cloudservers
pyrax.cloudservers = pyrax.connect_to_cloudservers()
self.assertIsNotNone(pyrax.cloudservers)
pyrax.connect_to_cloudservers = sav
def main():
pyrax.set_setting("identity_type", "rackspace")
creds_file = os.path.expanduser('~/.rackspace_cloud_credentials')
pyrax.set_credential_file(creds_file)
available_regions = pyrax.regions
print "Regions Available:", " ".join(list(available_regions))
region = ""
while region not in pyrax.regions:
region = raw_input("Select region: ")
cs = pyrax.connect_to_cloudservers(region)
servers = cs.servers.list()
srv_dict = {}
print "Select a server from which an image will be created."
for pos, srv in enumerate(servers):
print "%s: %s" % (pos, srv.name)
srv_dict[str(pos)] = srv.id
selection = None
while selection not in srv_dict:
if selection is not None:
print " -- Invalid choice"
selection = raw_input("Enter the number for your choice: ")
server_id = srv_dict[selection]
print
nm = raw_input("Enter a name for the image: ")
img_id = cs.servers.create_image(server_id, nm)
print "Image '%s' is being created. Its ID is: %s" % (nm, img_id)
def server_selection():
#Displays a list of all available images, allows the user to select one, and performs input validation.
imgs = pyrax.connect_to_cloudservers(region=region).images.list()
count = 1
for img in imgs:
print count, ")", img.name
count += 1
total_count = len(imgs)
while True:
server = raw_input("\nSelect the server that you want to create by entering a number between 1 and %s.%s" % (total_count, prompt))
try:
server = int(server)
if server < 1 or server > total_count:
print "Selection out of range."
else:
break
except ValueError:
print "Not a valid selection."
count = 1
for img in imgs:
if count != server:
count += 1
else:
server_type = img.name
server_id = img.id
break
return (server_type, server_id)
def flv_selection():
#Displays a list of all available flavors, allows the user to select one, and performs input validation.
flvs = pyrax.connect_to_cloudservers(region=region).list_flavors()
count = 1
for flv in flvs:
print count, ")", flv.name
count += 1
total_count = len(flvs)
while True:
server_flv = raw_input("\nSelect the server that you want to create by entering a number between 1 and %s.%s" % (total_count, prompt))
try:
server_flv = int(server_flv)
if server_flv < 1 or server_flv > total_count:
print "Selection out of range."
else:
break
except ValueError:
print "Not a valid selection."
count = 1
for flv in flvs:
if count != server_flv:
count += 1
else:
server_flv_type = flv.name
server_flv_id = flv.id
break
return (server_flv_type, server_flv_id)
def connect_to_rackspace(region, access_key_id, secret_access_key):
""" returns a connection object to Rackspace """
pyrax.set_setting('identity_type', 'rackspace')
pyrax.set_default_region(region)
pyrax.set_credentials(access_key_id, secret_access_key)
nova = pyrax.connect_to_cloudservers(region=region)
return nova
def sync_vagrant_rackspace_environment():
pyrax_login()
# iterate over all of the cloud servers to identify those that are
# already running.
# https://github.com/rackspace/pyrax/blob/master/docs/cloud_servers.md
cs = pyrax.connect_to_cloudservers(region="ORD")
for server in cs.servers.list():
# if the cloud server is already running and managed by
# vagrant (in env.hosts), then let's make sure the id file is
# set correctly
server_configured = False
filename = vagrant_id_filename(server.name, "rackspace")
if server.name in env.hosts:
if os.path.exists(filename):
with open(filename, 'r') as stream:
if server.id == stream.read():
server_configured = True
# if the server is not configured on the local machine, just
# need to create the file with the server.id in it
if server.name in env.hosts and not server_configured:
if not os.path.exists(os.path.dirname(filename)):
local("mkdir -p %s" % os.path.dirname(filename))
with open(filename, 'w') as stream:
stream.write(server.id)
def delete_rax(args):
"""Function for deleting CloudServers"""
for region in pyrax.identity.services.compute.regions:
cs = pyrax.connect_to_cloudservers(region=region)
servers = cs.servers.list(search_opts=dict(name='^%s' % args.match_re))
for server in servers:
prompt_and_delete(server, 'Delete matching %s? [y/n]: ' % server,
args.assumeyes)
def list_servers(dc):
cs = pyrax.connect_to_cloudservers(region=dc)
for server in cs.servers.list():
print "Server Name: ", server.name
print "Server Status: ", server.status
print "Server ID: ", server.id
print "Public IP: ", server.accessIPv4
print "Private IP: ", server.addresses['private'][0]['addr']
def _connect_to_rackspace(self):
""" returns a connection object to Rackspace """
pyrax.set_setting('identity_type', 'rackspace')
pyrax.set_default_region(self.state.region)
pyrax.set_credentials(self.config.access_key_id,
self.config.secret_access_key)
nova = pyrax.connect_to_cloudservers(region=self.state.region)
return nova
def _connect_to_rackspace(self):
""" returns a connection object to Rackspace """
pyrax.set_setting('identity_type', 'rackspace')
pyrax.set_default_region(self.state.region)
pyrax.set_credentials(self.config.access_key_id,
self.config.secret_access_key)
nova = pyrax.connect_to_cloudservers(region=self.state.region)
return nova
def raxCreateServer(dc, imgIDToUse, flvrIDToUse, svrBaseName, numServers):
raxCldSvr = pyrax.connect_to_cloudservers(region=dc)
serverImgs = raxCldSvr.images.list()
svrsCreated = {} # Dictionary to hold info on the servers that get created
completed = [] # Array to hold the servers that complete creation
if raxArgs.interactive:
for img in sorted(serverImgs, key=lambda serverImgs: serverImgs.name):
print img.name, " || ID:", img.id
imgIDToUse = raw_input('ID of image to use: ')
imgNameToUse = [img.name for img in serverImgs if img.id == imgIDToUse][0]
#print str(imgToUse)
serverFlvrs = raxCldSvr.flavors.list()
for flvr in serverFlvrs:
print "Name: " + flvr.name + " || ID:" + flvr.id
flvrIDToUse = raw_input('ID of flavor to use: ')
print 'Using ' + bcolors.OKBLUE + imgNameToUse + bcolors.ENDC
try:
numServers = int(raxArgs.numServers)
except (ValueError, TypeError):
numServers = 3
if (raxArgs.svrBaseName is None):
svrBaseName = raw_input('What is the server base name to use: ')
else:
svrBaseName = raxArgs.svrBaseName
print 'Creating a new server from image' \
' ' + bcolors.OKBLUE + imgIDToUse + bcolors.ENDC + ' in ' + \
bcolors.WARNING + dc + bcolors.ENDC + '.'
print 'Creating ' + str(numServers) + ' servers.'
print 'Server name will begin with ' + svrBaseName
for i in xrange(0, numServers):
svrName = '%s%s' % (svrBaseName, i)
svrsCreated[svrName] = raxCldSvr.servers.create(svrName, imgIDToUse,
flvrIDToUse)
print "Created server: %s" % svrName
sys.stdout.write("Waiting for builds to complete")
sys.stdout.flush()
while len(completed) < numServers:
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(30)
for name, server in svrsCreated.iteritems():
if name in completed:
continue
server.get()
if server.status in ['ACTIVE', 'ERROR', 'UNKNOWN']:
sys.stdout.write("\n")
print '======================================='
print 'Name: %s' % server.name
if (server.status == 'ERROR'):
print 'Status: %s %s %s' % bcolors.FAIL, server.status, \
bcolors.ENDC
else:
print 'Status: %s' % server.status
print 'ID: %s' % server.id
print 'Networks: %s' % server.networks
print 'Password: %s' % server.adminPass
completed.append(name)
def connect_to_rackspace(region,
access_key_id,
secret_access_key):
""" returns a connection object to Rackspace """
pyrax.set_setting('identity_type', 'rackspace')
pyrax.set_default_region(region)
pyrax.set_credentials(access_key_id, secret_access_key)
nova = pyrax.connect_to_cloudservers(region=region)
return nova
def home(request):
pyrax.set_credentials(request.user.rax_username, request.user.rax_api_key)
cs_dfw = pyrax.connect_to_cloudservers(region="DFW")
cs_ord = pyrax.connect_to_cloudservers(region="ORD")
dfw_servers = cs_dfw.servers.list()
ord_servers = cs_ord.servers.list()
all_servers = dfw_servers + ord_servers
html = "<html><body>"
for server in all_servers:
html += "Server: %s <br/>" % server.name
html += "</body></html>"
return HttpResponse(html)
def connect_to_rackspace():
""" returns a connection object to Rackspace """
import pyrax
pyrax.set_setting('identity_type', env.os_auth_system)
pyrax.set_default_region(env.os_region_name)
pyrax.set_credentials(env.os_username, env.os_password)
nova = pyrax.connect_to_cloudservers(region=env.os_region_name)
return nova
def main():
"""Parse arguments, take snap, and trigger deletion of oldest autosnap."""
parser = argparse.ArgumentParser(description='auto-rotate image snapshots')
parser.add_argument('user',
metavar='username',
type=str,
help='Username for account')
parser.add_argument('key',
metavar='apikey',
type=str,
help='API key for account')
parser.add_argument('server',
metavar='server',
type=str,
help='UUID of server to autosnap')
parser.add_argument('retention',
metavar='retention',
type=int,
help='Minimum number of autosnaps to retain')
parser.add_argument('region',
metavar='region',
type=str,
help='Region of Server (DFW, ORD, LON)',
choices=['DFW', 'ORD', 'LON'])
args = parser.parse_args()
pyrax.set_setting("identity_type", "rackspace")
pyrax.set_credentials(args.user, args.key)
#Set up a cloud object based on region specified by user
if args.region == "LON":
cloud = pyrax.cloudservers
else:
cloud = pyrax.connect_to_cloudservers(region=args.region)
server = cloud.servers.get(args.server)
images = cloud.images.list()
snap_list = []
snap_name = server.name + "-autosnap-" + args.server
#Search for previous autosnaps of server and append to a list
for i in images:
search_name = server.name + "-autosnap-" + server.id
if i.name == search_name:
snap_list.append(i)
#Delete oldest snapshot(s) if retention < num images
while args.retention < len(snap_list):
snap_list = delete_old(snap_list, cloud)
#Create snapshot if retention >= number of previous autosnaps
if args.retention >= len(snap_list):
server.create_image(snap_name)
def __init__(self, *args, **kwargs):
super(CloudBlockStorageVolume, self).__init__(*args, **kwargs)
try:
region = self.manager.api.region_name
self._nova_volumes = pyrax.connect_to_cloudservers(region).volumes
except AttributeError:
# This will happen in unit testing, where the full pyrax
# namespace is not exposed. In that situation, there is
# no need for the reference anyway
pass
def __init__(self, *args, **kwargs):
super(CloudBlockStorageVolume, self).__init__(*args, **kwargs)
try:
region = self.manager.api.region_name
self._nova_volumes = pyrax.connect_to_cloudservers(region).volumes
except AttributeError:
# This will happen in unit testing, where the full pyrax
# namespace is not exposed. In that situation, there is
# no need for the reference anyway
pass
def delete_rax_keypair(args):
"""Function for deleting Rackspace Key pairs"""
print("--- Cleaning Key Pairs matching '%s'" % args.match_re)
for region in pyrax.identity.services.compute.regions:
cs = pyrax.connect_to_cloudservers(region=region)
for keypair in cs.keypairs.list():
if re.search(args.match_re, keypair.name):
prompt_and_delete(keypair,
'Delete matching %s? [y/n]: ' % keypair,
args.assumeyes)
def delete_rax(args):
"""Function for deleting CloudServers"""
print("--- Cleaning CloudServers matching '%s'" % args.match_re)
search_opts = dict(name='^%s' % args.match_re)
for region in pyrax.identity.services.compute.regions:
cs = pyrax.connect_to_cloudservers(region=region)
servers = rax_list_iterator(cs.servers, search_opts=search_opts)
for server in servers:
prompt_and_delete(server, 'Delete matching %s? [y/n]: ' % server,
args.assumeyes)
def delete_rax_keypair(args):
"""Function for deleting Rackspace Key pairs"""
print ("--- Cleaning Key Pairs matching '%s'" % args.match_re)
for region in pyrax.identity.services.compute.regions:
cs = pyrax.connect_to_cloudservers(region=region)
for keypair in cs.keypairs.list():
if re.search(args.match_re, keypair.name):
prompt_and_delete(keypair,
'Delete matching %s? [y/n]: ' % keypair,
args.assumeyes)
def auth():
username = str(request.form['username'])
apikey = str(request.form['apikey'])
try:
pyrax.settings.set('identity_type', 'rackspace')
pyrax.set_credentials(username, apikey)
except exc.AuthenticationFailed:
return redirect('/login')
cloudservers_ord = pyrax.connect_to_cloudservers(region="ORD")
cloudservers_dfw = pyrax.connect_to_cloudservers(region="DFW")
cloudservers_iad = pyrax.connect_to_cloudservers(region="IAD")
cloudservers = cloudservers_ord.list() + cloudservers_dfw.list() + cloudservers_iad.list()
return render_template('cloud_servers.html',
title = 'Cloud Servers',
username = username,
servers = cloudservers)
def _list(regions):
groups = collections.defaultdict(list)
hostvars = collections.defaultdict(dict)
images = {}
# Go through all the regions looking for servers
for region in regions:
# Connect to the region
cs = pyrax.connect_to_cloudservers(region=region)
for server in cs.servers.list():
# Create a group on region
groups[region].append(server.name)
# Check if group metadata key in servers' metadata
group = server.metadata.get('group')
if group:
groups[group].append(server.name)
for extra_group in server.metadata.get('groups', '').split(','):
if extra_group:
groups[extra_group].append(server.name)
# Add host metadata
for key, value in to_dict(server).items():
hostvars[server.name][key] = value
hostvars[server.name]['rax_region'] = region
for key, value in server.metadata.iteritems():
prefix = os.getenv('RAX_META_PREFIX', 'meta')
groups['%s_%s_%s' % (prefix, key, value)].append(server.name)
groups['instance-%s' % server.id].append(server.name)
groups['flavor-%s' % server.flavor['id']].append(server.name)
try:
imagegroup = 'image-%s' % images[server.image['id']]
groups[imagegroup].append(server.name)
groups['image-%s' % server.image['id']].append(server.name)
except KeyError:
try:
image = cs.images.get(server.image['id'])
except cs.exceptions.NotFound:
groups['image-%s' % server.image['id']].append(server.name)
else:
images[image.id] = image.human_id
groups['image-%s' % image.human_id].append(server.name)
groups['image-%s' % server.image['id']].append(server.name)
# And finally, add an IP address
hostvars[server.name]['ansible_ssh_host'] = server.accessIPv4
if hostvars:
groups['_meta'] = {'hostvars': hostvars}
print(json.dumps(groups, sort_keys=True, indent=4))
def _get_driver(driver_type, region='ORD'):
"""
Returns the appropriate diver for the specified rackspace product.
Available options include::
lb: Cloud Load Balancers
db: Cloud Databases
dns: Cloud DNS
bs: Cloud Block Storage
mon: Cloud Monitoring
net: Cloud Networks
cf: Cloud Files
cs: Cloud Servers
:param driver_type: A str or unicode object for the appropriate type of
driver above.
:param region: A str or unicode object specify which region the driver
should be initialized for.
:return: A driver object initialized to the specified region
:raise TypeError:
:raise KeyError: If no valid drivers are found
"""
_auth()
if not isinstance(driver_type, six.string_types):
raise TypeError("driver_type must be str or unicode object")
if not isinstance(region, six.string_types):
raise TypeError("region must be str or unicode object")
region = region.upper()
if driver_type == "lb":
return pyrax.connect_to_cloud_loadbalancers(region)
if driver_type == "db":
return pyrax.connect_to_cloud_databases(region)
if driver_type == "dns":
return pyrax.connect_to_cloud_dns()
if driver_type == "bs":
return pyrax.connect_to_cloud_blockstorage(region)
if driver_type == "mon":
return pyrax.connect_to_cloud_monitoring(region)
if driver_type == "net":
return pyrax.connect_to_cloud_networks(region)
if driver_type == 'cf':
return pyrax.connect_to_cloudfiles(region)
if driver_type == 'cs':
return pyrax.connect_to_cloudservers(region)
raise KeyError(u"No Driver found by: {}".format(driver_type))
def _get_driver(driver_type, region='ORD'):
"""
Returns the appropriate diver for the specified rackspace product.
Available options include::
lb: Cloud Load Balancers
db: Cloud Databases
dns: Cloud DNS
bs: Cloud Block Storage
mon: Cloud Monitoring
net: Cloud Networks
cf: Cloud Files
cs: Cloud Servers
:param driver_type: A str or unicode object for the appropriate type of
driver above.
:param region: A str or unicode object specify which region the driver
should be initialized for.
:return: A driver object initialized to the specified region
:raise TypeError:
:raise KeyError: If no valid drivers are found
"""
_auth()
if not isinstance(driver_type, six.string_types):
raise TypeError("driver_type must be str or unicode object")
if not isinstance(region, six.string_types):
raise TypeError("region must be str or unicode object")
region = region.upper()
if driver_type == "lb":
return pyrax.connect_to_cloud_loadbalancers(region)
if driver_type == "db":
return pyrax.connect_to_cloud_databases(region)
if driver_type == "dns":
return pyrax.connect_to_cloud_dns()
if driver_type == "bs":
return pyrax.connect_to_cloud_blockstorage(region)
if driver_type == "mon":
return pyrax.connect_to_cloud_monitoring(region)
if driver_type == "net":
return pyrax.connect_to_cloud_networks(region)
if driver_type == 'cf':
return pyrax.connect_to_cloudfiles(region)
if driver_type == 'cs':
return pyrax.connect_to_cloudservers(region)
raise KeyError(u"No Driver found by: {}".format(driver_type))
def test_set_http_debug(self):
pyrax.cloudservers = None
sav = pyrax.connect_to_cloudservers
pyrax.connect_to_cloudservers = self.orig_connect_to_cloudservers
pyrax.cloudservers = pyrax.connect_to_cloudservers()
pyrax.cloudservers.http_log_debug = False
pyrax.set_http_debug(True)
self.assertTrue(pyrax.cloudservers.http_log_debug)
pyrax.set_http_debug(False)
self.assertFalse(pyrax.cloudservers.http_log_debug)
pyrax.connect_to_cloudservers = sav
def _list(regions):
groups = collections.defaultdict(list)
hostvars = collections.defaultdict(dict)
images = {}
# Go through all the regions looking for servers
for region in regions:
# Connect to the region
cs = pyrax.connect_to_cloudservers(region=region)
for server in cs.servers.list():
# Create a group on region
groups[region].append(server.name)
# Check if group metadata key in servers' metadata
group = server.metadata.get('group')
if group:
groups[group].append(server.name)
for extra_group in server.metadata.get('groups', '').split(','):
if extra_group:
groups[extra_group].append(server.name)
# Add host metadata
for key, value in to_dict(server).items():
hostvars[server.name][key] = value
hostvars[server.name]['rax_region'] = region
for key, value in server.metadata.iteritems():
prefix = os.getenv('RAX_META_PREFIX', 'meta')
groups['%s_%s_%s' % (prefix, key, value)].append(server.name)
groups['instance-%s' % server.id].append(server.name)
groups['flavor-%s' % server.flavor['id']].append(server.name)
try:
imagegroup = 'image-%s' % images[server.image['id']]
groups[imagegroup].append(server.name)
groups['image-%s' % server.image['id']].append(server.name)
except KeyError:
try:
image = cs.images.get(server.image['id'])
except cs.exceptions.NotFound:
groups['image-%s' % server.image['id']].append(server.name)
else:
images[image.id] = image.human_id
groups['image-%s' % image.human_id].append(server.name)
groups['image-%s' % server.image['id']].append(server.name)
# And finally, add an IP address
hostvars[server.name]['ansible_ssh_host'] = server.accessIPv4
if hostvars:
groups['_meta'] = {'hostvars': hostvars}
print(json.dumps(groups, sort_keys=True, indent=4))
def test_set_http_debug(self):
pyrax.cloudservers = None
sav = pyrax.connect_to_cloudservers
pyrax.connect_to_cloudservers = self.orig_connect_to_cloudservers
pyrax.cloudservers = pyrax.connect_to_cloudservers()
pyrax.cloudservers.http_log_debug = False
pyrax.set_http_debug(True)
self.assertTrue(pyrax.cloudservers.http_log_debug)
pyrax.set_http_debug(False)
self.assertFalse(pyrax.cloudservers.http_log_debug)
pyrax.connect_to_cloudservers = sav
def delete_rax(args):
"""Function for deleting CloudServers"""
print ("--- Cleaning CloudServers matching '%s'" % args.match_re)
search_opts = dict(name='^%s' % args.match_re)
for region in pyrax.identity.services.compute.regions:
cs = pyrax.connect_to_cloudservers(region=region)
servers = rax_list_iterator(cs.servers, search_opts=search_opts)
for server in servers:
prompt_and_delete(server,
'Delete matching %s? [y/n]: ' % server,
args.assumeyes)
def create_server(name, img_id, flv_id, dc):
cs = pyrax.connect_to_cloudservers(region=dc)
new_server = cs.servers.create(name, img_id, flv_id)
print "-"*30, "\nName:", new_server.name, "\nID:", new_server.id, \
"\nStatus:", new_server.status, "\nAdmin Password:"******"IPv6:", new_server.networks["public"][1], \
"\nIPv4:", new_server.networks["public"][0], \
"\nPrivate IP", new_server.networks["private"][0]
def _create_client(self, clt_class, url, public=True, special=False):
"""
Creates a client instance for the service.
"""
if self.service == "compute" and not special:
# Novaclient requires different parameters.
client = pyrax.connect_to_cloudservers(region=self.region,
context=self.identity, verify_ssl=self.verify_ssl)
client.identity = self.identity
else:
client = clt_class(self.identity, region_name=self.region,
management_url=url, verify_ssl=self.verify_ssl)
return client
def _create_client(self, clt_class, url, public=True, special=False):
"""
Creates a client instance for the service.
"""
if self.service == "compute" and not special:
# Novaclient requires different parameters.
client = pyrax.connect_to_cloudservers(region=self.region,
context=self.identity, verify_ssl=self.verify_ssl)
client.identity = self.identity
else:
client = clt_class(self.identity, region_name=self.region,
management_url=url, verify_ssl=self.verify_ssl)
return client
def __init__(self, *args, **kwargs):
super(CloudBlockStorageVolume, self).__init__(*args, **kwargs)
try:
region = self.manager.api.region_name
self._nova_volumes = pyrax.connect_to_cloudservers(region).volumes
except AttributeError:
# This will happen in unit testing, where the full pyrax
# namespace is not exposed. In that situation, there is
# no need for the reference anyway
pass
self._snapshot_manager = BaseManager(self.manager.api,
resource_class=CloudBlockStorageSnapshot,
response_key="snapshot", uri_base="snapshots")
def _create_rackspace_connection(creds, region):
"""
Connect to a Rackspace region with the given credentials.
:param creds: a dict containing a Rackspace username and api_key
:region: the name of a Rackspace region, such as "ord"
:rtype: a connected :class:`~novaclient.v1_1.client.Client`
:raises EnvironmentError: if no credentials are provided
"""
if not creds:
raise EnvironmentError('No credentials provided')
pyrax.set_setting('identity_type', creds['identity_type'])
pyrax.set_credentials(creds['username'], creds['api_key'])
return pyrax.connect_to_cloudservers(region.upper())
def host(regions, hostname):
hostvars = {}
for region in regions:
# Connect to the region
cs = pyrax.connect_to_cloudservers(region=region)
for server in cs.servers.list():
if server.name == hostname:
for key, value in to_dict(server).items():
hostvars[key] = value
# And finally, add an IP address
hostvars['ansible_ssh_host'] = server.accessIPv4
print(json.dumps(hostvars, sort_keys=True, indent=4))
def _list(regions):
groups = collections.defaultdict(list)
hostvars = collections.defaultdict(dict)
# Go through all the regions looking for servers
for region in regions:
# Connect to the region
cs = pyrax.connect_to_cloudservers(region=region)
for server in cs.servers.list():
# Create a group on region
groups[region].append(server.name)
# Check if group metadata key in servers' metadata
try:
group = server.metadata['group']
except KeyError:
pass
else:
# Create group if not exist and add the server
groups[group].append(server.name)
ansible_groups = server.metadata.get('ansible_groups', '')
for group in ansible_groups.split(','):
if group != '':
groups[group].append(server.name)
# Add host metadata
keys = [key for key in vars(server) if key not in ('manager', '_info')]
for key in keys:
# Extract value
value = getattr(server, key)
# Generate sanitized key
key = 'rax_' + (re.sub("[^A-Za-z0-9\-]", "_", key)
.lower()
.lstrip('_'))
hostvars[server.name][key] = value
# And finally, add an IP address
hostvars[server.name]['ansible_ssh_host'] = server.accessIPv4
if hostvars:
groups['_meta'] = {'hostvars': hostvars}
print(json.dumps(groups, sort_keys=True, indent=4))
def _get_client(self):
username = self.config['username']
api_key = self.config['api_key']
# Needs to be extracted to per-action
region = self.config['region'].upper()
pyrax.set_setting('identity_type', 'rackspace')
pyrax.set_default_region(region)
pyrax.set_credentials(username, api_key)
debug = self.config.get('debug', False)
if debug:
pyrax.set_http_debug(True)
pyrax.cloudservers = pyrax.connect_to_cloudservers(region=region)
pyrax.cloud_loadbalancers = pyrax.connect_to_cloud_loadbalancers(region=region)
pyrax.cloud_dns = pyrax.connect_to_cloud_dns(region=region)
return pyrax
def _create_client(self, clt_class, url, public=True, special=False):
"""
Creates a client instance for the service.
"""
verify_ssl = pyrax.get_setting("verify_ssl")
if not special and self.service == "object_store":
# Swiftclient requires different parameters.
client = pyrax.connect_to_cloudfiles(region=self.region,
public=public,
context=self.identity)
client.identity = self.identity
elif not special and self.service == "compute":
# Novaclient also requires special handling.
client = pyrax.connect_to_cloudservers(region=self.region,
context=self.identity)
client.identity = self.identity
else:
client = clt_class(self.identity,
region_name=self.region,
management_url=url,
verify_ssl=verify_ssl)
return client
def main():
auth()
#Creating cloudserver client
cs = pyrax.connect_to_cloudservers(region="ORD")
server_uuid = 'FILL_IN_YOUR_SERVER_UUID_HERE'
image_name = "ROLLING_IMAGE_NAME"
print "Looking for old images named %s" % image_name
old_images = cs.images.findall(name=image_name)
print "Finding server from uuid %s" % server_uuid
server = cs.servers.get(server=server_uuid)
print "Creating new image of %s named %s" % (server.name, image_name)
image_uuid = create_image(server, image_name=image_name)
print "New image created: %s" % image_uuid
for image in old_images:
print "Deleting Old Image: %s -- %s" % (image.name, image.id)
cs.images.delete(image.id)
def host(regions, hostname):
hostvars = {}
for region in regions:
# Connect to the region
cs = pyrax.connect_to_cloudservers(region=region)
for server in cs.servers.list():
if server.name == hostname:
keys = [key for key in vars(server) if key not in ('manager', '_info')]
for key in keys:
# Extract value
value = getattr(server, key)
# Generate sanitized key
key = 'rax_' + (re.sub("[^A-Za-z0-9\-]", "_", key)
.lower()
.lstrip("_"))
hostvars[key] = value
# And finally, add an IP address
hostvars['ansible_ssh_host'] = server.accessIPv4
print(json.dumps(hostvars, sort_keys=True, indent=4))
def __init__(self, *args, **kwargs):
super(CloudBlockStorageVolume, self).__init__(*args, **kwargs)
region = self.manager.api.region_name
context = self.manager.api.identity
cs = pyrax.connect_to_cloudservers(region=region, context=context)
self._nova_volumes = cs.volumes
def main():
"""Run the main application."""
# Setup argument parsing
parser = argparse.ArgumentParser(description='Basic pyrax CLI utilities',
epilog='Licensed "Apache 2.0"')
parser.add_argument('-c',
'--credentialsfile',
help='<Required> The path to the pyrax.cfg file',
default='~/.pyrax.cfg')
parser.add_argument(
'-r',
'--cloudregion',
help='<Required> The region to execute commands against',
required=True)
parser.add_argument(
'-s',
'--serveruuid',
help='<Required> The server uuid to execute commands against',
required=True)
parser.add_argument('-i',
'--imagename',
help='<Required> The name to use for the saved image',
required=True)
# Parse arguments
args = parser.parse_args()
# Set the identity type for Rackspace Cloud
pyrax.set_setting('identity_type', 'rackspace')
# Set the credentials
pyrax.set_credential_file(args.credentialsfile)
# Create the cloudservers object
cs = pyrax.connect_to_cloudservers(region=args.cloudregion)
# Get the list of current images with the same name
current_images = [
image for image in cs.images.list()
if hasattr(image, "server") and image.name == args.imagename
]
# Request the image creation (it returns the id, not an object)
saved_image_id = cs.servers.create_image(args.serveruuid, args.imagename)
# Get the image object
saved_image = cs.images.get(saved_image_id)
# Wait until the image creation returns a result
saved_image = pyrax.utils.wait_until(saved_image,
"status", ["ACTIVE", "ERROR"],
attempts=0)
# Delete all previous images of the same name if the resulting image
# status is 'ACTIVE'
if saved_image.status == "ACTIVE":
for image in current_images:
image.delete()
def launch_node(node_num=7):
region = "iad"
domain = "tmpnb.org"
key_name = "team"
pyrax.set_setting("identity_type", "rackspace")
pyrax.set_credentials(os.environ["OS_USERNAME"], os.environ["OS_PASSWORD"])
cs = pyrax.connect_to_cloudservers(region=region.upper())
# My least favorite bug in pyrax - silent errors
if(cs is None):
raise Exception("Unable to connect to given region '{}'".format(region))
# Get our base images
images = cs.list_base_images()
ubs = [image for image in images if "Ubuntu 14.04" in image.name]
user_image = [image for image in ubs if "OnMetal" in image.name][0]
proxy_image = [image for image in ubs if "PVHVM" in image.name][0]
user_server_name, proxy_server_name = name_new_nodes(region.lower(),
node_num=node_num,
domain=domain)
# Launch the servers
proxy_server = cs.servers.create(proxy_server_name, image=proxy_image.id, flavor='performance2-15', key_name=key_name)
user_server = cs.servers.create(user_server_name, image=user_image.id, flavor='onmetal-compute1', key_name=key_name)
# Wait on them
print("Waiting on Proxy server")
proxy_server = pyrax.utils.wait_for_build(proxy_server, verbose=True)
print("Waiting on Notebook User server")
user_server = pyrax.utils.wait_for_build(user_server, verbose=True)
# Making this in case we want some JSON
node_layout = {
'notebook_server': {
'private': user_server.networks['private'][0],
'public': user_server.networks['public'][0]
},
'proxy_server': {
'public': proxy_server.networks['public'][0]
}
}
inventory = '''[notebook]
{user_server_name} ansible_ssh_user=root ansible_ssh_host={notebook_server_public} configproxy_auth_token={token}
[proxy]
{proxy_server_name} ansible_ssh_user=root ansible_ssh_host={proxy_server_public} notebook_host={notebook_server_private}
'''.format(notebook_server_public=user_server.accessIPv4,
notebook_server_private=user_server.networks['private'][0],
proxy_server_public=proxy_server.accessIPv4,
token=binascii.hexlify(os.urandom(24)),
user_server_name=user_server_name,
proxy_server_name=proxy_server_name,
)
print(inventory)
pyrax.set_credentials(os.environ["OS_DNS_USERNAME"], os.environ["OS_DNS_PASSWORD"])
dns = pyrax.cloud_dns.find(name=domain)
dns.add_record({'type': 'A',
'name': proxy_server_name,
'ttl': 60*5,
'data': proxy_server.accessIPv4})
def _list_into_cache(regions):
groups = collections.defaultdict(list)
hostvars = collections.defaultdict(dict)
images = {}
cbs_attachments = collections.defaultdict(dict)
prefix = get_config(p, 'rax', 'meta_prefix', 'RAX_META_PREFIX', 'meta')
try:
# Ansible 2.3+
networks = get_config(p,
'rax',
'access_network',
'RAX_ACCESS_NETWORK',
'public',
value_type='list')
except TypeError:
# Ansible 2.2.x and below
# pylint: disable=unexpected-keyword-arg
networks = get_config(p,
'rax',
'access_network',
'RAX_ACCESS_NETWORK',
'public',
islist=True)
try:
try:
# Ansible 2.3+
ip_versions = map(
int,
get_config(p,
'rax',
'access_ip_version',
'RAX_ACCESS_IP_VERSION',
4,
value_type='list'))
except TypeError:
# Ansible 2.2.x and below
# pylint: disable=unexpected-keyword-arg
ip_versions = map(
int,
get_config(p,
'rax',
'access_ip_version',
'RAX_ACCESS_IP_VERSION',
4,
islist=True))
except:
ip_versions = [4]
else:
ip_versions = [v for v in ip_versions if v in [4, 6]]
if not ip_versions:
ip_versions = [4]
# Go through all the regions looking for servers
for region in regions:
# Connect to the region
cs = pyrax.connect_to_cloudservers(region=region)
if cs is None:
warnings.warn(
'Connecting to Rackspace region "%s" has caused Pyrax to '
'return None. Is this a valid region?' % region,
RuntimeWarning)
continue
for server in cs.servers.list():
# Create a group on region
groups[region].append(server.name)
# Check if group metadata key in servers' metadata
group = server.metadata.get('group')
if group:
groups[group].append(server.name)
for extra_group in server.metadata.get('groups', '').split(','):
if extra_group:
groups[extra_group].append(server.name)
# Add host metadata
for key, value in to_dict(server).items():
hostvars[server.name][key] = value
hostvars[server.name]['rax_region'] = region
for key, value in iteritems(server.metadata):
groups['%s_%s_%s' % (prefix, key, value)].append(server.name)
groups['instance-%s' % server.id].append(server.name)
groups['flavor-%s' % server.flavor['id']].append(server.name)
# Handle boot from volume
if not server.image:
if not cbs_attachments[region]:
cbs = pyrax.connect_to_cloud_blockstorage(region)
for vol in cbs.list():
if boolean(vol.bootable, strict=False):
for attachment in vol.attachments:
metadata = vol.volume_image_metadata
server_id = attachment['server_id']
cbs_attachments[region][server_id] = {
'id': metadata['image_id'],
'name': slugify(metadata['image_name'])
}
image = cbs_attachments[region].get(server.id)
if image:
server.image = {'id': image['id']}
hostvars[server.name]['rax_image'] = server.image
hostvars[server.name]['rax_boot_source'] = 'volume'
images[image['id']] = image['name']
else:
hostvars[server.name]['rax_boot_source'] = 'local'
try:
imagegroup = 'image-%s' % images[server.image['id']]
groups[imagegroup].append(server.name)
groups['image-%s' % server.image['id']].append(server.name)
except KeyError:
try:
image = cs.images.get(server.image['id'])
except cs.exceptions.NotFound:
groups['image-%s' % server.image['id']].append(server.name)
else:
images[image.id] = image.human_id
groups['image-%s' % image.human_id].append(server.name)
groups['image-%s' % server.image['id']].append(server.name)
# And finally, add an IP address
ansible_ssh_host = None
# use accessIPv[46] instead of looping address for 'public'
for network_name in networks:
if ansible_ssh_host:
break
if network_name == 'public':
for version_name in ip_versions:
if ansible_ssh_host:
break
if version_name == 6 and server.accessIPv6:
ansible_ssh_host = server.accessIPv6
elif server.accessIPv4:
ansible_ssh_host = server.accessIPv4
if not ansible_ssh_host:
addresses = server.addresses.get(network_name, [])
for address in addresses:
for version_name in ip_versions:
if ansible_ssh_host:
break
if address.get('version') == version_name:
ansible_ssh_host = address.get('addr')
break
if ansible_ssh_host:
hostvars[server.name]['ansible_ssh_host'] = ansible_ssh_host
if hostvars:
groups['_meta'] = {'hostvars': hostvars}
with open(get_cache_file_path(regions), 'w') as cache_file:
json.dump(groups, cache_file)
help='The autoscale group config ID')
parser.add_argument('--region', required=False, default='SYD',
help='The region to authenticate to')
args = vars(parser.parse_args())
pyrax.set_setting("identity_type", "rackspace")
# Using credentials file
try:
pyrax.set_credential_file(os.path.expanduser("~/.cloud_credentials"))
except Exception, e:
sys.stderr.write("Failed to authenticate: %s" % str(e))
au = pyrax.connect_to_autoscale(region=args['region'])
cs = pyrax.connect_to_cloudservers(region=args['region'])
as_group = au.get(args['as_group']);
snet_ips = []
for s_id in as_group.get_state()['active']:
try
server = cs.servers.get(s_id)
snet_ips.append(server.networks['private'][0])
except:
pass
generate_lsync_config(snet_ips)
if __name__ == '__main__':
def main():
argument_spec = rax_argument_spec()
argument_spec.update(
dict(
auto_increment=dict(default=True, type='bool'),
boot_from_volume=dict(default=False, type='bool'),
boot_volume=dict(type='str'),
boot_volume_size=dict(type='int', default=100),
boot_volume_terminate=dict(type='bool', default=False),
config_drive=dict(default=False, type='bool'),
count=dict(default=1, type='int'),
count_offset=dict(default=1, type='int'),
disk_config=dict(choices=['auto', 'manual']),
exact_count=dict(default=False, type='bool'),
extra_client_args=dict(type='dict', default={}),
extra_create_args=dict(type='dict', default={}),
files=dict(type='dict', default={}),
flavor=dict(),
group=dict(),
image=dict(),
instance_ids=dict(type='list'),
key_name=dict(aliases=['keypair']),
meta=dict(type='dict', default={}),
name=dict(),
networks=dict(type='list', default=['public', 'private']),
service=dict(),
state=dict(default='present', choices=['present', 'absent']),
user_data=dict(no_log=True),
wait=dict(default=False, type='bool'),
wait_timeout=dict(default=300),
))
module = AnsibleModule(
argument_spec=argument_spec,
required_together=rax_required_together(),
)
if not HAS_PYRAX:
module.fail_json(msg='pyrax is required for this module')
service = module.params.get('service')
if service is not None:
module.fail_json(msg='The "service" attribute has been deprecated, '
'please remove "service: cloudservers" from your '
'playbook pertaining to the "rax" module')
auto_increment = module.params.get('auto_increment')
boot_from_volume = module.params.get('boot_from_volume')
boot_volume = module.params.get('boot_volume')
boot_volume_size = module.params.get('boot_volume_size')
boot_volume_terminate = module.params.get('boot_volume_terminate')
config_drive = module.params.get('config_drive')
count = module.params.get('count')
count_offset = module.params.get('count_offset')
disk_config = module.params.get('disk_config')
if disk_config:
disk_config = disk_config.upper()
exact_count = module.params.get('exact_count', False)
extra_client_args = module.params.get('extra_client_args')
extra_create_args = module.params.get('extra_create_args')
files = module.params.get('files')
flavor = module.params.get('flavor')
group = module.params.get('group')
image = module.params.get('image')
instance_ids = module.params.get('instance_ids')
key_name = module.params.get('key_name')
meta = module.params.get('meta')
name = module.params.get('name')
networks = module.params.get('networks')
state = module.params.get('state')
user_data = module.params.get('user_data')
wait = module.params.get('wait')
wait_timeout = int(module.params.get('wait_timeout'))
setup_rax_module(module, pyrax)
if extra_client_args:
pyrax.cloudservers = pyrax.connect_to_cloudservers(
region=pyrax.cloudservers.client.region_name, **extra_client_args)
client = pyrax.cloudservers.client
if 'bypass_url' in extra_client_args:
client.management_url = extra_client_args['bypass_url']
if pyrax.cloudservers is None:
module.fail_json(msg='Failed to instantiate client. This '
'typically indicates an invalid region or an '
'incorrectly capitalized region name.')
cloudservers(module,
state=state,
name=name,
flavor=flavor,
image=image,
meta=meta,
key_name=key_name,
files=files,
wait=wait,
wait_timeout=wait_timeout,
disk_config=disk_config,
count=count,
group=group,
instance_ids=instance_ids,
exact_count=exact_count,
networks=networks,
count_offset=count_offset,
auto_increment=auto_increment,
extra_create_args=extra_create_args,
user_data=user_data,
config_drive=config_drive,
boot_from_volume=boot_from_volume,
boot_volume=boot_volume,
boot_volume_size=boot_volume_size,
boot_volume_terminate=boot_volume_terminate)
