def test_deprecated_preserve_context_kwarg(preserve_context): def foo(): pass with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") namespaced_function(foo, globals(), preserve_context=preserve_context) assert str(w[-1].message) == ( "Passing 'preserve_context' to 'namespaced_function' is deprecated, slated " "for removal in 3008 and no longer does anything for the function " "being namespaced.")
def install(*args, **kwargs): ''' Winrepo install that can install packages without a win_repo, the package definition can passed to install via a win_repo keyword argument. ''' global _get_package_info _orig_get_package_info = salt.modules.win_pkg._get_package_info pkg_install = namespaced_function(salt.modules.win_pkg.install, globals()) try: _get_package_info = functools.partial( _get_package_info_partial, win_repo=kwargs.get('win_repo', {}), orig_func=namespaced_function(_orig_get_package_info, globals()), ) return pkg_install(*args, **kwargs) finally: _get_package_info = _orig_get_package_info
import time import salt.config as config import salt.utils.cloud from salt.cloud.libcloudfuncs import get_image, get_size, script, show_instance from salt.exceptions import SaltCloudException, SaltCloudSystemExit from salt.utils.functools import namespaced_function try: import packet HAS_PACKET = True except ImportError: HAS_PACKET = False 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 import namespaced_function try: from salt.utils.platform import is_windows except (ImportError, AttributeError): from salt.utils import is_windows import salt.modules.win_pkg from salt.modules.win_pkg import * # pylint: disable=wildcard-import,unused-wildcard-import from salt.modules.win_pkg import install as win_pkg_install # Import 3rd Party libs import salt.ext.six as six # pylint: disable=import-error,no-name-in-module from salt.ext.six.moves.urllib.parse import urlparse as _urlparse, urlsplit, uses_params, ParseResult # Let's namespace the pip_install function win_pkg_install = namespaced_function(win_pkg_install, globals()) # pylint: disable=invalid-name # Let's namespace all other functions from the pip module for name in dir(salt.modules.win_pkg): attr = getattr(salt.modules.win_pkg, name) if isinstance(attr, types.FunctionType): if attr in ('install', ): continue globals()[name] = namespaced_function(attr, globals()) __virtualname__ = 'pkg' def __virtual__(): ''' Set the virtual pkg module if the os is Windows
except ImportError: HAS_LIBCLOUD = False try: from netaddr import all_matching_cidrs # pylint: disable=unused-import HAS_NETADDR = True except ImportError: HAS_NETADDR = False # 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()) reboot = namespaced_function(reboot, 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()) # Get logging started log = logging.getLogger(__name__)
# Import python libs from __future__ import absolute_import import os import types import pkg_resources # Import salt libs from salt.utils.functools import namespaced_function import salt.utils.args 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 # 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()) __virtualname__ = 'pip' def __virtual__():
try: import salt.utils.winapi HAS_DEPENDENCIES = True except ImportError: HAS_DEPENDENCIES = False try: import wmi # pylint: disable=import-error except ImportError: HAS_DEPENDENCIES = False if salt.utils.platform.is_windows() and HAS_DEPENDENCIES: wol = namespaced_function(wol, globals()) get_hostname = namespaced_function(get_hostname, globals()) interface = namespaced_function(interface, globals()) interface_ip = namespaced_function(interface_ip, globals()) subnets6 = namespaced_function(subnets6, globals()) ip_in_subnet = namespaced_function(ip_in_subnet, globals()) convert_cidr = namespaced_function(convert_cidr, globals()) calc_net = namespaced_function(calc_net, globals()) get_fqdn = namespaced_function(get_fqdn, globals()) ifacestartswith = namespaced_function(ifacestartswith, globals()) iphexval = namespaced_function(iphexval, globals()) # Define the module's virtual name __virtualname__ = "network"
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') __virtualname__ = 'nova' # 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())) if get_configured_provider() is False: return False
import salt.utils.platform from salt.utils.functools import namespaced_function from salt.utils.versions import LooseVersion 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 freeze as pip_freeze from salt.modules.pip import list_ as pip_list from salt.modules.pip import _get_pip_bin as __get_pip_bin # 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_freeze = namespaced_function(pip_freeze, globals()) # pylint: disable=invalid-name pip_list = namespaced_function(pip_list, globals()) # pylint: disable=invalid-name __get_pip_bin = namespaced_function(__get_pip_bin, globals()) # 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 in ('install', 'freeze', 'list', 'list_', __get_pip_bin): continue globals()[name] = namespaced_function(attr, globals()) log = logging.getLogger(__name__) __func_alias__ = {'list_': 'list'}
''' # Import python libs from __future__ import absolute_import import types # Import salt libs from salt.utils.functools import namespaced_function 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 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()) __virtualname__ = 'pip2' def __virtual__():
from salt.modules.win_pkg import * from salt.ext.six.moves.urllib.parse import urlparse as _urlparse PKG_DATA = {} NAMESPACE_FUNCS = [ '_get_repo_details', '_get_msiexec', '_get_latest_pkg_version', 'get_repo_data', ] for name in dir(salt.modules.win_pkg): attr = getattr(salt.modules.win_pkg, name) if isinstance(attr, types.FunctionType): if name in NAMESPACE_FUNCS: globals()[name] = namespaced_function(attr, globals()) def __virtual__(): if salt.utils.platform.is_windows(): return True return (False, 'This module only works on Windows.') def refresh_db(*args, **kwargs): ''' Override refresh db and peform a no-op ''' return
PKG_DATA = {} NAMESPACE_FUNCS = [ '_get_repo_details', '_get_msiexec', '_get_latest_pkg_version', 'get_repo_data', ] for name in dir(salt.modules.win_pkg): attr = getattr(salt.modules.win_pkg, name) if isinstance(attr, types.FunctionType): if name in NAMESPACE_FUNCS: globals()[name] = namespaced_function(attr, globals()) def __virtual__(): if salt.utils.platform.is_windows(): return True return (False, 'This module only works on Windows.') def refresh_db(*args, **kwargs): ''' Override refresh db and peform a no-op ''' return
from salt.utils.versions import LooseVersion 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 try: from salt.utils.versions import LooseVersion except ImportError: from distutils.version import LooseVersion # 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__)
HAS_WMI = True else: HAS_WMI = False except ImportError: HAS_WMI = False try: import psutil HAS_PSUTIL = True except ImportError: HAS_PSUTIL = False if salt.utils.platform.is_windows(): ping_master = namespaced_function(ping_master, globals()) time_ = namespaced_function(time_, globals()) __virtualname__ = "status" # Taken from https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/sysinfo/performance.htm class SYSTEM_PERFORMANCE_INFORMATION(ctypes.Structure): _fields_ = [ ("IdleProcessTime", ctypes.c_int64), ("IoReadTransferCount", ctypes.c_int64), ("IoWriteTransferCount", ctypes.c_int64), ("IoOtherTransferCount", ctypes.c_int64), ("IoReadOperationCount", ctypes.c_ulong), ("IoWriteOperationCount", ctypes.c_ulong), ("IoOtherOperationCount", ctypes.c_ulong),