def __virtual__(): ''' Set up the libcloud functions and check for JOYENT configs ''' if get_configured_provider() is False: return False global script conn = None script = namespaced_function(script, globals(), (conn,)) return True
def __virtual__(): """ Set up the libcloud functions and check for JOYENT configs """ if get_configured_provider() is False: log.debug("There is no Joyent cloud provider configuration available. Not " "loading module.") return False log.debug("Loading Joyent cloud module") global script conn = None script = namespaced_function(script, globals(), (conn,)) return True
def __virtual__(): ''' Only works on Windows systems ''' if salt.utils.is_windows(): if HAS_WINDOWS_MODULES: global check_perms, get_managed, makedirs_perms, manage_file global source_list, mkdir, __clean_tmp, makedirs, _is_bin check_perms = namespaced_function(check_perms, globals()) get_managed = namespaced_function(get_managed, globals()) makedirs_perms = namespaced_function(makedirs_perms, globals()) makedirs = namespaced_function(makedirs, globals()) manage_file = namespaced_function(manage_file, globals()) source_list = namespaced_function(source_list, globals()) mkdir = namespaced_function(mkdir, globals()) __clean_tmp = namespaced_function(__clean_tmp, globals()) _is_bin = namespaced_function(_is_bin, globals()) return 'file' log.warn(salt.utils.required_modules_error(__file__, __doc__)) return False
def parse_rpm(path): try: from salt.modules.yumpkg5 import __QUERYFORMAT, _parse_pkginfo from salt.utils import namespaced_function _parse_pkginfo = namespaced_function(_parse_pkginfo, globals()) except ImportError: log.critical('Error importing helper functions. This is almost ' 'certainly a bug.') return '', '' pkginfo = __salt__['cmd.run_all']( 'rpm -qp --queryformat {0!r} {1!r}'.format(__QUERYFORMAT, path) ).get('stdout', '').strip() pkginfo = _parse_pkginfo(pkginfo) if pkginfo is None: return '', '' else: return pkginfo.name, pkginfo.version
def __virtual__(): ''' Confine this module to yum based systems ''' # Work only on RHEL/Fedora based distros with python 2.5 and below try: os_grain = __grains__['os'] os_family = __grains__['os_family'] os_major_version = int(__grains__['osrelease'].split('.')[0]) except Exception: return False valid = False # Fedora <= 10 need to use this module if os_grain == 'Fedora' and os_major_version < 11: valid = True # XCP == 1.x uses a CentOS 5 base elif os_grain == 'XCP': if os_major_version == 1: valid = True # XenServer 6 and earlier uses a CentOS 5 base elif os_grain == 'XenServer': if os_major_version <= 6: valid = True else: # RHEL <= 5 and all variants need to use this module if os_family == 'RedHat' and os_major_version <= 5: valid = True if valid: global mod_repo, _parse_repo_file, list_repos, get_repo global expand_repo_def, del_repo mod_repo = namespaced_function(mod_repo, globals()) _parse_repo_file = namespaced_function(_parse_repo_file, globals()) list_repos = namespaced_function(list_repos, globals()) get_repo = namespaced_function(get_repo, globals()) expand_repo_def = namespaced_function(expand_repo_def, globals()) del_repo = namespaced_function(del_repo, globals()) return 'pkg' return False
import logging # Import salt libs import salt.utils from salt.utils import namespaced_function from salt.exceptions import CommandNotFoundError import salt.modules.pip from salt.modules.pip import * # pylint: disable=wildcard-import,unused-wildcard-import from salt.modules.pip import install as pip_install from salt.modules.pip import list_ as pip_list # Import 3rd Party libs import salt.ext.six as six # Let's namespace the pip_install function pip_install = namespaced_function(pip_install, globals()) # pylint: disable=invalid-name pip_list = namespaced_function(pip_list, globals()) # pylint: disable=invalid-name # Let's namespace all other functions from the pip module for name in dir(salt.modules.pip): attr = getattr(salt.modules.pip, name) if isinstance(attr, types.FunctionType): if attr == 'install': continue if attr in globals(): continue globals()[name] = namespaced_function(attr, globals()) log = logging.getLogger(__name__) __func_alias__ = {'list_': 'list'}
vm_['name'] ) ) log.info('Created Cloud VM {0[name]!r}'.format(vm_)) log.debug( '{0[name]!r} VM creation details:\n{1}'.format( vm_, pprint.pformat(node.__dict__) ) ) ret.update(node.__dict__) salt.utils.cloud.fire_event( 'event', 'created instance', 'salt/cloud/{0}/created'.format(vm_['name']), { 'name': vm_['name'], 'profile': vm_['profile'], 'provider': vm_['provider'], }, ) return ret list_nodes = namespaced_function(list_nodes, globals()) script = namespaced_function(script, globals())
# Import libcloud from libcloud.compute.base import NodeAuthPassword # Import salt cloud libs import salt.config as config from salt.cloud.libcloudfuncs import * # pylint: disable=W0614,W0401 from salt.utils import namespaced_function # Get logging started log = logging.getLogger(__name__) # Redirect linode functions to this module namespace get_size = namespaced_function(get_size, globals()) get_image = namespaced_function(get_image, globals()) avail_locations = namespaced_function(avail_locations, globals()) avail_images = namespaced_function(avail_images, globals()) avail_sizes = namespaced_function(avail_sizes, globals()) script = namespaced_function(script, globals()) destroy = namespaced_function(destroy, globals()) list_nodes = namespaced_function(list_nodes, globals()) list_nodes_full = namespaced_function(list_nodes_full, globals()) list_nodes_select = namespaced_function(list_nodes_select, globals()) show_instance = namespaced_function(show_instance, globals()) # Only load in this module if the LINODE configurations are in place def __virtual__(): '''
SaltCloudExecutionTimeout ) # Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) request_log = logging.getLogger('requests') # namespace libcloudfuncs get_salt_interface = namespaced_function(get_salt_interface, globals()) # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace script = namespaced_function(script, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module is the OPENSTACK configurations are in place def __virtual__(): ''' Check for Nova configurations ''' request_log.setLevel(getattr(logging, __opts__.get('requests_log_level', 'warning').upper()))
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' if not HAS_LIBCLOUD: return False try: # Import botocore import botocore.session except ImportError: # Botocore is not available, the Libcloud AWS module will be loaded # instead. return False # "Patch" the imported libcloud_aws to have the current __opts__ libcloud_aws.__opts__ = __opts__ libcloudfuncs.__opts__ = __opts__ if get_configured_provider() is False: return False for provider, details in six.iteritems(__opts__['providers']): if 'provider' not in details or details['provider'] != 'aws': continue if not os.path.exists(details['private_key']): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration does not exist\n'.format( details['private_key'], provider ) ) keymode = str( oct(stat.S_IMODE(os.stat(details['private_key']).st_mode)) ) if keymode not in ('0400', '0600'): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration needs to be set to mode 0400 or 0600\n'.format( details['private_key'], provider ) ) # Let's bring the functions imported from libcloud_aws to the current # namespace. keysdiff = set(POST_IMPORT_LOCALS_KEYS).difference( PRE_IMPORT_LOCALS_KEYS ) for key in keysdiff: # only import callables that actually have __code__ (this includes # functions but excludes Exception classes) if (callable(POST_IMPORT_LOCALS_KEYS[key]) and hasattr(POST_IMPORT_LOCALS_KEYS[key], "__code__")): globals().update( { key: namespaced_function( POST_IMPORT_LOCALS_KEYS[key], globals(), () ) } ) global avail_images, avail_sizes, avail_locations, script global list_nodes, list_nodes_full, list_nodes_select # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions avail_locations = namespaced_function(avail_locations, globals(), (conn,)) avail_images = namespaced_function(avail_images, globals(), (conn,)) avail_sizes = namespaced_function(avail_sizes, globals(), (conn,)) script = namespaced_function(script, globals(), (conn,)) list_nodes = namespaced_function(list_nodes, globals(), (conn,)) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn,)) list_nodes_select = namespaced_function( list_nodes_select, globals(), (conn,) ) return 'aws'
# Import saltcloud libs import salt.utils.cloud import salt.config as config from salt.cloud.libcloudfuncs import * # pylint: disable=W0401,W0614 from salt.cloud.exceptions import ( SaltCloudException, SaltCloudSystemExit, ) # pylint: disable=C0103,E0602,E0102 # Get logging started log = logging.getLogger(__name__) # Redirect GCE functions to this module namespace avail_locations = namespaced_function(avail_locations, globals()) script = namespaced_function(script, globals()) destroy = namespaced_function(destroy, globals()) list_nodes = namespaced_function(list_nodes, globals()) list_nodes_full = namespaced_function(list_nodes_full, globals()) list_nodes_select = namespaced_function(list_nodes_select, globals()) # Only load in this module if the GCE configurations are in place def __virtual__(): ''' Set up the libcloud functions and check for GCE configurations. ''' if get_configured_provider() is False: log.debug( 'There is no GCE cloud provider configuration available. Not '
import salt.utils # Import salt.cloud libs import salt.utils.cloud import salt.config as config from salt.utils import namespaced_function from salt.exceptions import (SaltCloudSystemExit, SaltCloudExecutionFailure, SaltCloudExecutionTimeout) # Get logging started log = logging.getLogger(__name__) # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace get_size = namespaced_function(get_size, globals()) get_image = namespaced_function(get_image, globals()) avail_locations = namespaced_function(avail_locations, globals()) avail_images = namespaced_function(avail_images, globals()) avail_sizes = namespaced_function(avail_sizes, globals()) script = namespaced_function(script, globals()) destroy = namespaced_function(destroy, globals()) list_nodes = namespaced_function(list_nodes, globals()) list_nodes_full = namespaced_function(list_nodes_full, globals()) list_nodes_select = namespaced_function(list_nodes_select, globals()) show_instance = namespaced_function(show_instance, globals()) get_salt_interface = namespaced_function(get_salt_interface, globals()) # Only load in this module is the RACKSPACE configurations are in place def __virtual__():
# Import python libs import logging import os import re # Import salt libs import salt.utils if salt.utils.is_windows(): from salt.utils import namespaced_function from salt.modules.win_pkg import _get_package_info from salt.modules.win_pkg import get_repo_data from salt.modules.win_pkg import _get_latest_pkg_version from salt.modules.win_pkg import _reverse_cmp_pkg_versions _get_package_info = namespaced_function(_get_package_info, globals()) get_repo_data = namespaced_function(get_repo_data, globals()) _get_latest_pkg_version = namespaced_function(_get_latest_pkg_version, globals()) _reverse_cmp_pkg_versions = namespaced_function(_reverse_cmp_pkg_versions, globals()) # The following imports are used by the namespaced win_pkg funcs # and need to be included in their globals. import msgpack from distutils.version import LooseVersion log = logging.getLogger(__name__) def __gen_rtag(): ''' Return the location of the refresh tag '''
def __virtual__(): """ Set up the libcloud funcstions and check for AWS configs """ try: # Import botocore import botocore.session except ImportError: # Botocore is not available, the Libcloud AWS module will be loaded # instead. log.debug("The 'botocore' library is not installed. The libcloud AWS " "support will be loaded instead.") return False # "Patch" the imported libcloud_aws to have the current __opts__ libcloud_aws.__opts__ = __opts__ libcloudfuncs.__opts__ = __opts__ if get_configured_provider() is False: log.debug("There is no AWS cloud provider configuration available. Not " "loading module") return False for provider, details in __opts__["providers"].iteritems(): if "provider" not in details or details["provider"] != "aws": continue if not os.path.exists(details["private_key"]): raise SaltCloudException( "The AWS key file {0!r} used in the {1!r} provider " "configuration does not exist\n".format(details["private_key"], provider) ) keymode = str(oct(stat.S_IMODE(os.stat(details["private_key"]).st_mode))) if keymode not in ("0400", "0600"): raise SaltCloudException( "The AWS key file {0!r} used in the {1!r} provider " "configuration needs to be set to mode 0400 or 0600\n".format(details["private_key"], provider) ) # Let's bring the functions imported from libcloud_aws to the current # namespace. keysdiff = set(POST_IMPORT_LOCALS_KEYS.keys()).difference(PRE_IMPORT_LOCALS_KEYS) for key in keysdiff: # only import callables that actually have __code__ (this includes # functions but excludes Exception classes) if callable(POST_IMPORT_LOCALS_KEYS[key]) and hasattr(POST_IMPORT_LOCALS_KEYS[key], "__code__"): globals().update({key: namespaced_function(POST_IMPORT_LOCALS_KEYS[key], globals(), ())}) global avail_images, avail_sizes, avail_locations, script global list_nodes, list_nodes_full, list_nodes_select # open a connection in a specific region conn = get_conn(**{"location": get_location()}) # Init the libcloud functions avail_locations = namespaced_function(avail_locations, globals(), (conn,)) avail_images = namespaced_function(avail_images, globals(), (conn,)) avail_sizes = namespaced_function(avail_sizes, globals(), (conn,)) script = namespaced_function(script, globals(), (conn,)) list_nodes = namespaced_function(list_nodes, globals(), (conn,)) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn,)) list_nodes_select = namespaced_function(list_nodes_select, globals(), (conn,)) log.debug("Loading AWS botocore cloud module") return "aws"
# Import salt.cloud libs import salt.utils.cloud import salt.config as config from salt.utils import namespaced_function from salt.utils.cloud import is_public_ip from salt.exceptions import ( SaltCloudSystemExit, SaltCloudExecutionFailure, SaltCloudExecutionTimeout ) # Get logging started log = logging.getLogger(__name__) # namespace libcloudfuncs get_salt_interface = namespaced_function(get_salt_interface, globals()) JOYENT_API_HOST_SUFFIX = '.api.joyentcloud.com' JOYENT_API_VERSION = '~6.5' JOYENT_LOCATIONS = { 'us-east-1': 'North Virginia, USA', 'us-west-1': 'Bay Area, California, USA', 'us-sw-1': 'Las Vegas, Nevada, USA', 'eu-ams-1': 'Amsterdam, Netherlands' } DEFAULT_LOCATION = 'us-east-1' # joyent no longer reports on all data centers, so setting this value to true # causes the list_nodes function to get information on machines from all # data centers
'-2': 'Boot Failed (not in use)', '-1': 'Being Created', '0': 'Brand New', '1': 'Running', '2': 'Powered Off', '3': 'Shutting Down (not in use)', '4': 'Saved to Disk (not in use)', } # Redirect linode functions to this module namespace #get_size = namespaced_function(get_size, globals()) #get_image = namespaced_function(get_image, globals()) # avail_locations = namespaced_function(avail_locations, globals()) # avail_images = namespaced_function(avail_distributions, globals()) # avail_sizes = namespaced_function(avail_sizes, globals()) script = namespaced_function(script, globals()) # destroy = namespaced_function(destroy, globals()) # list_nodes = namespaced_function(list_nodes, globals()) # list_nodes_full = namespaced_function(list_nodes_full, globals()) list_nodes_select = namespaced_function(list_nodes_select, globals()) show_instance = namespaced_function(show_instance, globals()) # get_node = namespaced_function(get_node, globals()) # Borrowed from Apache Libcloud class NodeAuthSSHKey(object): """ An SSH key to be installed for authentication to a node. This is the actual contents of the users ssh public key which will normally be installed as root's public key on the node.
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' try: # Import botocore import botocore.session except ImportError: # Botocore is not available, the Libcloud AWS module will be loaded # instead. return False # "Patch" the imported libcloud_aws to have the current __opts__ libcloud_aws.__opts__ = __opts__ libcloudfuncs.__opts__ = __opts__ if get_configured_provider() is False: return False if get_dependencies() is False: return False for provider, details in six.iteritems(__opts__['providers']): if 'aws' not in details: continue parameters = details['aws'] if salt.utils.cloud.check_key_path_and_mode( provider, parameters['private_key'] ) is False: return False # Let's bring the functions imported from libcloud_aws to the current # namespace. keysdiff = set(POST_IMPORT_LOCALS_KEYS).difference( PRE_IMPORT_LOCALS_KEYS ) for key in keysdiff: # only import callables that actually have __code__ (this includes # functions but excludes Exception classes) if (callable(POST_IMPORT_LOCALS_KEYS[key]) and hasattr(POST_IMPORT_LOCALS_KEYS[key], "__code__")): globals().update( { key: namespaced_function( POST_IMPORT_LOCALS_KEYS[key], globals(), () ) } ) global avail_images, avail_sizes, avail_locations, script global list_nodes, list_nodes_full, list_nodes_select # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions avail_locations = namespaced_function(avail_locations, globals(), (conn,)) avail_images = namespaced_function(avail_images, globals(), (conn,)) avail_sizes = namespaced_function(avail_sizes, globals(), (conn,)) script = namespaced_function(script, globals(), (conn,)) list_nodes = namespaced_function(list_nodes, globals(), (conn,)) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn,)) list_nodes_select = namespaced_function( list_nodes_select, globals(), (conn,) ) log.warning('This driver has been deprecated and will be removed in the ' 'Boron release of Salt. Please use the ec2 driver instead.') return __virtualname__
from salt.exceptions import SaltCloudSystemExit from salt.cloud.libcloudfuncs import * # pylint: disable=W0614,W0401 from salt.utils import namespaced_function # Attempt to import softlayer lib try: import SoftLayer HAS_SLLIBS = True except ImportError: HAS_SLLIBS = False # Get logging started log = logging.getLogger(__name__) # Redirect SoftLayer functions to this module namespace script = namespaced_function(script, globals()) # Only load in this module if the SoftLayer configurations are in place def __virtual__(): ''' Set up the libcloud functions and check for SoftLayer configurations. ''' if not HAS_SLLIBS: return False if get_configured_provider() is False: return False return True
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' try: import botocore # Since we have botocore, we won't load the libcloud AWS module log.debug( 'The \'botocore\' library is installed. The libcloud AWS support ' 'will not be loaded.') return False except ImportError: pass if get_configured_provider() is False: log.debug( 'There is no AWS cloud provider configuration available. Not ' 'loading module') return False for provider, details in __opts__['providers'].iteritems(): if 'provider' not in details or details['provider'] != 'aws': continue if not os.path.exists(details['private_key']): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration does not exist\n'.format( details['private_key'], provider)) keymode = str( oct(stat.S_IMODE(os.stat(details['private_key']).st_mode))) if keymode not in ('0400', '0600'): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration needs to be set to mode 0400 or 0600\n'.format( details['private_key'], provider)) global avail_images, avail_sizes, script, list_nodes global avail_locations, list_nodes_full, list_nodes_select, get_image global get_size, libcloudfuncs_destroy, show_instance # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions get_size = namespaced_function(get_size, globals(), (conn, )) get_image = namespaced_function(get_image, globals(), (conn, )) avail_locations = namespaced_function(avail_locations, globals(), (conn, )) avail_images = namespaced_function(avail_images, globals(), (conn, )) avail_sizes = namespaced_function(avail_sizes, globals(), (conn, )) script = namespaced_function(script, globals(), (conn, )) list_nodes = namespaced_function(list_nodes, globals(), (conn, )) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn, )) list_nodes_select = namespaced_function(list_nodes_select, globals(), (conn, )) libcloudfuncs_destroy = namespaced_function(libcloudfuncs_destroy, globals(), (conn, )) show_instance = namespaced_function(show_instance, globals()) log.debug('Loading Libcloud AWS cloud module') return __virtualname__
# Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace avail_locations = namespaced_function(avail_locations, globals()) script = namespaced_function(script, globals()) destroy = namespaced_function(destroy, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module is the OPENSTACK configurations are in place def __virtual__(): ''' Check for Nova configurations ''' if get_configured_provider() is False: log.debug( 'There is no Nova cloud provider configuration available. ' 'Not loading module.' )
# Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace get_size = namespaced_function(get_size, globals()) get_image = namespaced_function(get_image, globals()) avail_locations = namespaced_function(avail_locations, globals()) script = namespaced_function(script, globals()) destroy = namespaced_function(destroy, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module is the OPENSTACK configurations are in place def __virtual__(): """ Check for Nova configurations """ if get_configured_provider() is False: log.debug("There is no Nova cloud provider configuration available. " "Not loading module.") return False
SaltCloudExecutionTimeout) # Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace get_size = namespaced_function(get_size, globals()) get_image = namespaced_function(get_image, globals()) avail_locations = namespaced_function(avail_locations, globals()) script = namespaced_function(script, globals()) destroy = namespaced_function(destroy, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module is the OPENSTACK configurations are in place def __virtual__(): ''' Check for Nova configurations ''' if get_configured_provider() is False: return False
import salt.config as config from salt.ext.six.moves import range from salt.exceptions import ( SaltCloudException, SaltCloudSystemExit ) # Import Salt-Cloud Libs import salt.utils.cloud from salt.cloud.libcloudfuncs import get_size, get_image, script, show_instance from salt.utils import namespaced_function get_size = namespaced_function(get_size, globals()) get_image = namespaced_function(get_image, globals()) script = namespaced_function(script, globals()) show_instance = namespaced_function(show_instance, globals()) # Get logging started log = logging.getLogger(__name__) __virtualname__ = 'packet' # Only load this module if the Packet configuration is in place. def __virtual__(): '''
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' try: # Import botocore import botocore.session except ImportError: # Botocore is not available, the Libcloud AWS module will be loaded # instead. log.debug( 'The \'botocore\' library is not installed. The libcloud AWS ' 'support will be loaded instead.') return False # "Patch" the imported libcloud_aws to have the current __opts__ libcloud_aws.__opts__ = __opts__ libcloudfuncs.__opts__ = __opts__ if get_configured_provider() is False: log.debug( 'There is no AWS cloud provider configuration available. Not ' 'loading module') return False for provider, details in __opts__['providers'].iteritems(): if 'provider' not in details or details['provider'] != 'aws': continue if not os.path.exists(details['private_key']): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration does not exist\n'.format( details['private_key'], provider)) keymode = str( oct(stat.S_IMODE(os.stat(details['private_key']).st_mode))) if keymode not in ('0400', '0600'): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration needs to be set to mode 0400 or 0600\n'.format( details['private_key'], provider)) # Let's bring the functions imported from libcloud_aws to the current # namespace. keysdiff = set( POST_IMPORT_LOCALS_KEYS.keys()).difference(PRE_IMPORT_LOCALS_KEYS) for key in keysdiff: # only import callables that actually have __code__ (this includes # functions but excludes Exception classes) if (callable(POST_IMPORT_LOCALS_KEYS[key]) and hasattr(POST_IMPORT_LOCALS_KEYS[key], "__code__")): globals().update({ key: namespaced_function(POST_IMPORT_LOCALS_KEYS[key], globals(), ()) }) global avail_images, avail_sizes, avail_locations, script global list_nodes, list_nodes_full, list_nodes_select # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions avail_locations = namespaced_function(avail_locations, globals(), (conn, )) avail_images = namespaced_function(avail_images, globals(), (conn, )) avail_sizes = namespaced_function(avail_sizes, globals(), (conn, )) script = namespaced_function(script, globals(), (conn, )) list_nodes = namespaced_function(list_nodes, globals(), (conn, )) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn, )) list_nodes_select = namespaced_function(list_nodes_select, globals(), (conn, )) log.debug('Loading AWS botocore cloud module') return 'aws'
# Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) request_log = logging.getLogger('requests') # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace script = namespaced_function(script, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module is the OPENSTACK configurations are in place def __virtual__(): ''' Check for Nova configurations ''' request_log.setLevel(getattr(logging, __opts__.get('requests_log_level', 'warning').upper())) return nova.HAS_NOVA def get_configured_provider(): ''' Return the first configured instance.
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' try: import botocore # Since we have botocore, we won't load the libcloud AWS module return False except ImportError: pass if get_configured_provider() is False: return False if get_dependencies() is False: return False for provider, details in six.iteritems(__opts__['providers']): if 'provider' not in details or details['provider'] != 'aws': continue if not os.path.exists(details['private_key']): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration does not exist\n'.format( details['private_key'], provider)) keymode = str( oct(stat.S_IMODE(os.stat(details['private_key']).st_mode))) if keymode not in ('0400', '0600'): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration needs to be set to mode 0400 or 0600\n'.format( details['private_key'], provider)) global avail_images, avail_sizes, script, list_nodes global avail_locations, list_nodes_full, list_nodes_select, get_image global get_size, libcloudfuncs_destroy, show_instance # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions get_size = namespaced_function(get_size, globals(), (conn, )) get_image = namespaced_function(get_image, globals(), (conn, )) avail_locations = namespaced_function(avail_locations, globals(), (conn, )) avail_images = namespaced_function(avail_images, globals(), (conn, )) avail_sizes = namespaced_function(avail_sizes, globals(), (conn, )) script = namespaced_function(script, globals(), (conn, )) list_nodes = namespaced_function(list_nodes, globals(), (conn, )) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn, )) list_nodes_select = namespaced_function(list_nodes_select, globals(), (conn, )) libcloudfuncs_destroy = namespaced_function(libcloudfuncs_destroy, globals(), (conn, )) show_instance = namespaced_function(show_instance, globals()) log.warning('This driver has been deprecated and will be removed in the ' 'Boron release of Salt. Please use the ec2 driver instead.') return __virtualname__
# Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) request_log = logging.getLogger('requests') # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace script = namespaced_function(script, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module if the Nova configurations are in place def __virtual__(): ''' Check for Nova configurations ''' request_log.setLevel( getattr(logging, __opts__.get('requests_log_level', 'warning').upper())) return HAS_NOVA def get_configured_provider():
import packet # Import Salt Libs import salt.config as config from salt.ext.six.moves import range from salt.exceptions import (SaltCloudException, SaltCloudSystemExit) # Import Salt-Cloud Libs import salt.utils.cloud from salt.cloud.libcloudfuncs import get_size, get_image, script, show_instance from salt.utils import namespaced_function get_size = namespaced_function(get_size, globals()) get_image = namespaced_function(get_image, globals()) script = namespaced_function(script, globals()) show_instance = namespaced_function(show_instance, globals()) # Get logging started log = logging.getLogger(__name__) __virtualname__ = 'packet' # Only load this module if the Packet configuration is in place. def __virtual__(): '''
from salt.utils.cloud import is_public_ip from salt.exceptions import ( SaltCloudSystemExit, SaltCloudExecutionFailure, SaltCloudExecutionTimeout ) # Import 3rd-party libs import salt.ext.six as six from salt.ext.six.moves import http_client # pylint: disable=import-error,no-name-in-module # Get logging started log = logging.getLogger(__name__) # namespace libcloudfuncs get_salt_interface = namespaced_function(get_salt_interface, globals()) JOYENT_API_HOST_SUFFIX = '.api.joyentcloud.com' JOYENT_API_VERSION = '~7.2' JOYENT_LOCATIONS = { 'us-east-1': 'North Virginia, USA', 'us-west-1': 'Bay Area, California, USA', 'us-sw-1': 'Las Vegas, Nevada, USA', 'eu-ams-1': 'Amsterdam, Netherlands' } DEFAULT_LOCATION = 'us-east-1' # joyent no longer reports on all data centers, so setting this value to true # causes the list_nodes function to get information on machines from all # data centers
SaltCloudSystemExit, SaltCloudExecutionFailure, SaltCloudExecutionTimeout) # Import netaddr IP matching try: from netaddr import all_matching_cidrs HAS_NETADDR = True except ImportError: HAS_NETADDR = False # Get logging started log = logging.getLogger(__name__) request_log = logging.getLogger('requests') # namespace libcloudfuncs get_salt_interface = namespaced_function(get_salt_interface, globals()) # Some of the libcloud functions need to be in the same namespace as the # functions defined in the module, so we create new function objects inside # this module namespace script = namespaced_function(script, globals()) reboot = namespaced_function(reboot, globals()) # Only load in this module is the OPENSTACK configurations are in place def __virtual__(): ''' Check for Nova configurations ''' request_log.setLevel( getattr(logging,
from salt.cloud.libcloudfuncs import * # pylint: disable=W0614,W0401 from salt.utils import namespaced_function # Attempt to import softlayer lib try: import SoftLayer HAS_SLLIBS = True except ImportError: HAS_SLLIBS = False # Get logging started log = logging.getLogger(__name__) # Redirect SoftLayer functions to this module namespace script = namespaced_function(script, globals()) # Only load in this module if the SoftLayer configurations are in place def __virtual__(): ''' Set up the libcloud functions and check for SoftLayer configurations. ''' if not HAS_SLLIBS: log.debug( 'The SoftLayer Python Library needs to be installed in ordere to ' 'use the SoftLayer HW salt.cloud module. See: ' 'https://pypi.python.org/pypi/SoftLayer' ) return False
import logging # Import salt libs from salt.utils import namespaced_function from salt.exceptions import CommandNotFoundError import salt.states.pip_state from salt.states.pip_state import * # pylint: disable=wildcard-import,unused-wildcard-import from salt.states.pip_state import installed as pip_state_installed # Import 3rd Party libs import salt.ext.six as six log = logging.getLogger(__name__) # Let's namespace the pip_state_installed function pip_state_installed = namespaced_function(pip_state_installed, globals()) # pylint: disable=invalid-name # Let's namespace all other functions from the pip_state module for name in dir(salt.states.pip_state): attr = getattr(salt.states.pip_state, name) if isinstance(attr, types.FunctionType): if attr in ('installed',): continue if attr in globals(): continue globals()[name] = namespaced_function(attr, globals()) def _get_pip_bin(bin_env): ''' Locate the pip binary, either from `bin_env` as a virtualenv, as the
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' try: import botocore # Since we have botocore, we won't load the libcloud AWS module return False except ImportError: pass if get_configured_provider() is False: return False for provider, details in __opts__['providers'].iteritems(): if 'provider' not in details or details['provider'] != 'aws': continue if not os.path.exists(details['private_key']): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration does not exist\n'.format( details['private_key'], provider ) ) keymode = str( oct(stat.S_IMODE(os.stat(details['private_key']).st_mode)) ) if keymode not in ('0400', '0600'): raise SaltCloudException( 'The AWS key file {0!r} used in the {1!r} provider ' 'configuration needs to be set to mode 0400 or 0600\n'.format( details['private_key'], provider ) ) global avail_images, avail_sizes, script, list_nodes global avail_locations, list_nodes_full, list_nodes_select, get_image global get_size, libcloudfuncs_destroy, show_instance # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions get_size = namespaced_function(get_size, globals(), (conn,)) get_image = namespaced_function(get_image, globals(), (conn,)) avail_locations = namespaced_function(avail_locations, globals(), (conn,)) avail_images = namespaced_function(avail_images, globals(), (conn,)) avail_sizes = namespaced_function(avail_sizes, globals(), (conn,)) script = namespaced_function(script, globals(), (conn,)) list_nodes = namespaced_function(list_nodes, globals(), (conn,)) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn,)) list_nodes_select = namespaced_function( list_nodes_select, globals(), (conn,) ) libcloudfuncs_destroy = namespaced_function( libcloudfuncs_destroy, globals(), (conn,) ) show_instance = namespaced_function(show_instance, globals()) return __virtualname__
def __virtual__(): ''' Set up the libcloud funcstions and check for AWS configs ''' try: # Import botocore import botocore.session except ImportError: # Botocore is not available, the Libcloud AWS module will be loaded # instead. return False # "Patch" the imported libcloud_aws to have the current __opts__ libcloud_aws.__opts__ = __opts__ libcloudfuncs.__opts__ = __opts__ if get_configured_provider() is False: return False if get_dependencies() is False: return False for provider, details in six.iteritems(__opts__['providers']): if 'aws' not in details: continue parameters = details['aws'] if salt.utils.cloud.check_key_path_and_mode( provider, parameters['private_key']) is False: return False # Let's bring the functions imported from libcloud_aws to the current # namespace. keysdiff = set(POST_IMPORT_LOCALS_KEYS).difference(PRE_IMPORT_LOCALS_KEYS) for key in keysdiff: # only import callables that actually have __code__ (this includes # functions but excludes Exception classes) if (callable(POST_IMPORT_LOCALS_KEYS[key]) and hasattr(POST_IMPORT_LOCALS_KEYS[key], "__code__")): globals().update({ key: namespaced_function(POST_IMPORT_LOCALS_KEYS[key], globals(), ()) }) global avail_images, avail_sizes, avail_locations, script global list_nodes, list_nodes_full, list_nodes_select # open a connection in a specific region conn = get_conn(**{'location': get_location()}) # Init the libcloud functions avail_locations = namespaced_function(avail_locations, globals(), (conn, )) avail_images = namespaced_function(avail_images, globals(), (conn, )) avail_sizes = namespaced_function(avail_sizes, globals(), (conn, )) script = namespaced_function(script, globals(), (conn, )) list_nodes = namespaced_function(list_nodes, globals(), (conn, )) list_nodes_full = namespaced_function(list_nodes_full, globals(), (conn, )) list_nodes_select = namespaced_function(list_nodes_select, globals(), (conn, )) log.warning('This driver has been deprecated and will be removed in the ' 'Boron release of Salt. Please use the ec2 driver instead.') return __virtualname__