def test_load_minion_config_from_environ_var(self):
        original_environ = os.environ.copy()

        tempdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
        try:
            env_root_dir = os.path.join(tempdir, "foo", "env")
            os.makedirs(env_root_dir)
            env_fpath = os.path.join(env_root_dir, "config-env")

            salt.utils.fopen(env_fpath, "w").write("root_dir: {0}\n" "log_file: {1}\n".format(env_root_dir, env_fpath))

            os.environ["SALT_MINION_CONFIG"] = env_fpath
            # Should load from env variable, not the default configuration file
            config = sconfig.minion_config("/etc/salt/minion")
            self.assertEqual(config["log_file"], env_fpath)
            os.environ.clear()
            os.environ.update(original_environ)

            root_dir = os.path.join(tempdir, "foo", "bar")
            os.makedirs(root_dir)
            fpath = os.path.join(root_dir, "config")
            salt.utils.fopen(fpath, "w").write("root_dir: {0}\n" "log_file: {1}\n".format(root_dir, fpath))
            # Let's set the environment variable, yet, since the configuration
            # file path is not the default one, ie, the user has passed an
            # alternative configuration file form the CLI parser, the
            # environment variable will be ignored.
            os.environ["SALT_MINION_CONFIG"] = env_fpath
            config = sconfig.minion_config(fpath)
            self.assertEqual(config["log_file"], fpath)
            os.environ.clear()
            os.environ.update(original_environ)
        finally:
            if os.path.isdir(tempdir):
                shutil.rmtree(tempdir)

    def test_check_dns_deprecation_warning(self):
        helium_version = SaltStackVersion.from_name('Helium')
        if salt_version.__version_info__ >= helium_version:
            raise AssertionError(
                'Failing this test on purpose! Please delete this test case, '
                'the \'check_dns\' keyword argument and the deprecation '
                'warnings in `salt.config.minion_config` and '
                'salt.config.apply_minion_config`'
            )

        # Let's force the warning to always be thrown
        warnings.resetwarnings()
        warnings.filterwarnings(
            'always', '(.*)check_dns(.*)', DeprecationWarning, 'salt.config'
        )
        with warnings.catch_warnings(record=True) as w:
            sconfig.minion_config(None, None, check_dns=True)
            self.assertEqual(
                'The functionality behind the \'check_dns\' keyword argument '
                'is no longer required, as such, it became unnecessary and is '
                'now deprecated. \'check_dns\' will be removed in Salt '
                '{0}.'.format(helium_version.formatted_version),
                str(w[-1].message)
            )

        with warnings.catch_warnings(record=True) as w:
            sconfig.apply_minion_config(
                overrides=None, defaults=None, check_dns=True
            )
            self.assertEqual(
                'The functionality behind the \'check_dns\' keyword argument '
                'is no longer required, as such, it became unnecessary and is '
                'now deprecated. \'check_dns\' will be removed in Salt '
                '{0}.'.format(helium_version.formatted_version),
                str(w[-1].message)
            )

        with warnings.catch_warnings(record=True) as w:
            sconfig.minion_config(None, None, check_dns=False)
            self.assertEqual(
                'The functionality behind the \'check_dns\' keyword argument '
                'is no longer required, as such, it became unnecessary and is '
                'now deprecated. \'check_dns\' will be removed in Salt '
                '{0}.'.format(helium_version.formatted_version),
                str(w[-1].message)
            )

        with warnings.catch_warnings(record=True) as w:
            sconfig.apply_minion_config(
                overrides=None, defaults=None, check_dns=False
            )
            self.assertEqual(
                'The functionality behind the \'check_dns\' keyword argument '
                'is no longer required, as such, it became unnecessary and is '
                'now deprecated. \'check_dns\' will be removed in Salt '
                '{0}.'.format(helium_version.formatted_version),
                str(w[-1].message)
            )

    def test_check_dns_deprecation_warning(self):
        if salt_version.__version_info__ >= (0, 19):
            raise AssertionError(
                "Failing this test on purpose! Please delete this test case, "
                "the 'check_dns' keyword argument and the deprecation "
                "warnings in `salt.config.minion_config` and "
                "salt.config.apply_minion_config`"
            )

        # Let's force the warning to always be thrown
        warnings.resetwarnings()
        warnings.filterwarnings("always", "(.*)check_dns(.*)", DeprecationWarning, "salt.config")
        with warnings.catch_warnings(record=True) as w:
            sconfig.minion_config(None, None, check_dns=True)
            self.assertEqual(
                "The functionality behind the 'check_dns' keyword argument "
                "is no longer required, as such, it became unnecessary and is "
                "now deprecated. 'check_dns' will be removed in salt > "
                "0.18.0",
                str(w[-1].message),
            )

        with warnings.catch_warnings(record=True) as w:
            sconfig.apply_minion_config(overrides=None, defaults=None, check_dns=True)
            self.assertEqual(
                "The functionality behind the 'check_dns' keyword argument "
                "is no longer required, as such, it became unnecessary and is "
                "now deprecated. 'check_dns' will be removed in salt > "
                "0.18.0",
                str(w[-1].message),
            )

        with warnings.catch_warnings(record=True) as w:
            sconfig.minion_config(None, None, check_dns=False)
            self.assertEqual(
                "The functionality behind the 'check_dns' keyword argument "
                "is no longer required, as such, it became unnecessary and is "
                "now deprecated. 'check_dns' will be removed in salt > "
                "0.18.0",
                str(w[-1].message),
            )

        with warnings.catch_warnings(record=True) as w:
            sconfig.apply_minion_config(overrides=None, defaults=None, check_dns=False)
            self.assertEqual(
                "The functionality behind the 'check_dns' keyword argument "
                "is no longer required, as such, it became unnecessary and is "
                "now deprecated. 'check_dns' will be removed in salt > "
                "0.18.0",
                str(w[-1].message),
            )

    def setup_config(self):
        opts = config.master_config(self.get_config_file_path('master'))
        user = opts.get('user', 'root')
        opts['_minion_conf_file'] = opts['conf_file']
        opts.update(config.minion_config(self.get_config_file_path('minion')))
        # Over ride the user from the master config file
        opts['user'] = user

        if 'syndic_master' not in opts:
            self.error(
                "The syndic_master needs to be configured in the salt master "
                "config, EXITING!"
            )

        from salt import utils
        # Some of the opts need to be changed to match the needed opts
        # in the minion class.
        opts['master'] = opts['syndic_master']
        opts['master_ip'] = utils.dns_check(opts['master'])

        opts['master_uri'] = 'tcp://{0}:{1}'.format(
            opts['master_ip'], str(opts['master_port'])
        )
        opts['_master_conf_file'] = opts['conf_file']
        opts.pop('conf_file')
        return opts

    def setUp(self, *args, **kwargs):
        super(RendererMixin, self).setUp(*args, **kwargs)

        self.root_dir = tempfile.mkdtemp("pyobjects_test_root")

        self.config = minion_config(None)
        self.config.update({"file_client": "local", "file_roots": {"base": [self.root_dir]}})

def returner(ret):
    '''
    Send the return data to the Salt Master over the encrypted
    0MQ bus with custom tag for 3rd party script filtering.
    '''

    # get opts from minion config file, supports minion.d drop dir!
    opts = minion_config(os.path.join(syspaths.CONFIG_DIR, 'minion'))

    # TODO: this needs to be customizable!
    tag = 'third-party'

    # add custom tag to return data for filtering
    ret['tag'] = tag

    # multi event example, supports a list of event ret objects.
    # single event does not currently expand/filter properly on Master side.
    package = {
      #'id': opts['id'],
      'events': [ ret ],
      'tag': None,
      'pretag': None,
      'data': None
    }

    # opts must contain valid minion ID else it binds to invalid 0MQ socket.
    event = salt.utils.event.SaltEvent('minion', **opts)

    # Fire event payload with 'fire_master' tag which triggers the
    # salt-minion daemon to forward payload to the master event bus!
    event.fire_event(package, 'fire_master')

    def test_issue_5970_minion_confd_inclusion(self):
        try:
            tempdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
            minion_config = os.path.join(tempdir, 'minion')
            minion_confd = os.path.join(tempdir, 'minion.d')
            os.makedirs(minion_confd)

            # Let's populate a minion configuration file with some basic
            # settings
            salt.utils.fopen(minion_config, 'w').write(
                'blah: false\n'
                'root_dir: {0}\n'
                'log_file: {1}\n'.format(tempdir, minion_config)
            )

            # Now, let's populate an extra configuration file under minion.d
            # Notice that above we've set blah as False and bellow as True.
            # Since the minion.d files are loaded after the main configuration
            # file so overrides can happen, the final value of blah should be
            # True.
            extra_config = os.path.join(minion_confd, 'extra.conf')
            salt.utils.fopen(extra_config, 'w').write(
                'blah: true\n'
            )

            # Let's load the configuration
            config = sconfig.minion_config(minion_config)

            self.assertEqual(config['log_file'], minion_config)
            # As proven by the assertion below, blah is True
            self.assertTrue(config['blah'])
        finally:
            if os.path.isdir(tempdir):
                shutil.rmtree(tempdir)

 def setUp(self):
     self.opts = _config = minion_config(None)
     self.opts['grains'] = grains(self.opts)
     self.loader = LazyLoader(_module_dirs(self.opts, 'modules', 'module'),
                              self.opts,
                              tag='module',
                              virtual_enable=False)

    def setUp(self):
        self.opts = _config = minion_config(None)
        self.tmp_dir = tempfile.mkdtemp(dir=integration.TMP)
        os.makedirs(self.module_dir)

        self.lib_count = collections.defaultdict(int)  # mapping of path -> count

        # bootstrap libs
        with open(os.path.join(self.module_dir, '__init__.py'), 'w') as fh:
            fh.write(deep_init_base)
            fh.flush()
            os.fsync(fh.fileno())  # flush to disk

        self.lib_paths = {}
        dir_path = self.module_dir
        for lib_name in self.libs:
            dir_path = os.path.join(dir_path, lib_name)
            self.lib_paths[lib_name] = dir_path
            os.makedirs(dir_path)
            self.update_lib(lib_name)

        dirs = _module_dirs(self.opts, 'modules', 'module')
        dirs.append(self.tmp_dir)
        self.loader = LazyLoader(dirs,
                                 self.opts,
                                 tag='module')

 def _init_env(self):
     '''
     Initialize some Salt environment.
     '''
     from salt.config import minion_config
     from salt.grains import core as g_core
     g_core.__opts__ = minion_config(self.DEFAULT_MINION_CONFIG_PATH)
     self.grains_core = g_core

 def render(self, template, opts=None):
     _config = minion_config(None)
     _config['file_client'] = 'local'
     if opts:
         _config.update(opts)
     _state = salt.state.State(_config)
     return compile_template_str(template,
                                 _state.rend,
                                 _state.opts['renderer'])

def _minion_opts(cfg='minion'):
    if 'conf_file' in __opts__:
        default_dir = os.path.dirname(__opts__['conf_file'])
    else:
        default_dir = salt.syspaths.CONFIG_DIR,
    cfg = os.environ.get(
        'SALT_MINION_CONFIG', os.path.join(default_dir, cfg))
    opts = config.minion_config(cfg)
    return opts

    def test_load_minion_config_from_environ_var(self):
        original_environ = os.environ.copy()

        tempdir = tempfile.mkdtemp(dir=integration.SYS_TMP_DIR)
        try:
            env_root_dir = os.path.join(tempdir, 'foo', 'env')
            os.makedirs(env_root_dir)
            env_fpath = os.path.join(env_root_dir, 'config-env')

            with salt.utils.fopen(env_fpath, 'w') as fp_:
                fp_.write(
                    'root_dir: {0}\n'
                    'log_file: {1}\n'.format(env_root_dir, env_fpath)
                )

            os.environ['SALT_MINION_CONFIG'] = env_fpath
            # Should load from env variable, not the default configuration file
            config = sconfig.minion_config('/etc/salt/minion')
            self.assertEqual(config['log_file'], env_fpath)
            os.environ.clear()
            os.environ.update(original_environ)

            root_dir = os.path.join(tempdir, 'foo', 'bar')
            os.makedirs(root_dir)
            fpath = os.path.join(root_dir, 'config')
            with salt.utils.fopen(fpath, 'w') as fp_:
                fp_.write(
                    'root_dir: {0}\n'
                    'log_file: {1}\n'.format(root_dir, fpath)
                )
            # Let's set the environment variable, yet, since the configuration
            # file path is not the default one, i.e., the user has passed an
            # alternative configuration file form the CLI parser, the
            # environment variable will be ignored.
            os.environ['SALT_MINION_CONFIG'] = env_fpath
            config = sconfig.minion_config(fpath)
            self.assertEqual(config['log_file'], fpath)
            os.environ.clear()
            os.environ.update(original_environ)
        finally:
            if os.path.isdir(tempdir):
                shutil.rmtree(tempdir)

 def test_get_opts(self):
     '''
     test.get_opts
     '''
     opts = config.minion_config(
         self.get_config_file_path('minion')
     )
     self.assertEqual(
         self.run_function('test.get_opts')['cachedir'],
         opts['cachedir']
     )

 def test_sha256_is_default_for_minion(self):
     fpath = tempfile.mktemp()
     try:
         salt.utils.fopen(fpath, 'w').write(
             "root_dir: /\n"
             "key_logfile: key\n"
         )
         config = sconfig.minion_config(fpath)
         self.assertEqual(config['hash_type'], 'sha256')
     finally:
         if os.path.isfile(fpath):
             os.unlink(fpath)

    def setup_config(self):
        opts = config.master_config(self.get_config_file_path("master"))
        opts["_minion_conf_file"] = opts["conf_file"]
        opts.update(config.minion_config(self.get_config_file_path("minion")))

        if "syndic_master" not in opts:
            self.error("The syndic_master needs to be configured in the salt master " "config, EXITING!")

        from salt import utils

        # Some of the opts need to be changed to match the needed opts
        # in the minion class.
        opts["master"] = opts["syndic_master"]
        opts["master_ip"] = utils.dns_check(opts["master"])

        opts["master_uri"] = "tcp://{0}:{1}".format(opts["master_ip"], str(opts["master_port"]))
        opts["_master_conf_file"] = opts["conf_file"]
        opts.pop("conf_file")
        return opts

    def setup_config(self):
        opts = config.master_config(self.get_config_file_path())
        user = opts.get('user', 'root')
        opts['_minion_conf_file'] = opts['conf_file']
        opts.update(config.minion_config(self.get_config_file_path('minion')))
        # Override the user from the master config file
        opts['user'] = user
        # Override the name of the PID file.
        opts['pidfile'] = '/var/run/salt-syndic.pid'

        if not opts.get('syndic_master', None):
            self.error(
                'The syndic_master needs to be configured in the salt master '
                'config, EXITING!'
            )

        # Some of the opts need to be changed to match the needed opts
        # in the minion class.
        opts['master'] = opts.get('syndic_master', opts['master'])
        try:
            opts['master_ip'] = utils.dns_check(
                opts['master'],
                ipv6=opts['ipv6']
            )
        except exceptions.SaltSystemExit as exc:
            self.exit(
                status=exc.code,
                msg='{0}: {1}\n'.format(self.get_prog_name(), exc.message)
            )

        opts['master_uri'] = 'tcp://{0}:{1}'.format(
            opts['master_ip'], str(opts['master_port'])
        )
        opts['_master_conf_file'] = opts['conf_file']
        opts.pop('conf_file')
        return opts

 def test_bad_name(self):
     self.opts = minion_config(None)
     testmod = salt.loader.raw_mod(self.opts, 'module_we_do_not_have', None)
     self.assertEqual(testmod, {})

 def test_basic(self):
     self.opts = minion_config(None)
     testmod = salt.loader.raw_mod(self.opts, 'test', None)
     for k, v in six.iteritems(testmod):
         self.assertEqual(k.split('.')[0], 'test')

    def _mixin_setup(self):
        group = self.output_options_group = optparse.OptionGroup(
            self, "Output Options", "Configure your preferred output format"
        )
        self.add_option_group(group)
        group.add_option(
            '--raw-out',
            default=False,
            action='store_true',
            help=('DEPRECATED. Print the output from the \'{0}\' command in '
                  'raw python form, this is suitable for re-reading the '
                  'output into an executing python script with eval.'.format(
                      self.get_prog_name()
                  ))
        )
        group.add_option(
            '--yaml-out',
            default=False,
            action='store_true',
            help=('DEPRECATED. Print the output from the \'{0}\' command in '
                  'yaml.'.format(self.get_prog_name()))
        )
        group.add_option(
            '--json-out',
            default=False,
            action='store_true',
            help=('DEPRECATED. Print the output from the \'{0}\' command in '
                  'json.'.format(self.get_prog_name()))
        )

        if self._include_text_out_:
            group.add_option(
                '--text-out',
                default=False,
                action='store_true',
                help=('DEPRECATED. Print the output from the \'{0}\' command '
                      'in the same form the shell would.'.format(
                          self.get_prog_name()
                      ))
            )

        outputters = loader.outputters(
            config.minion_config(
                '/etc/salt/minion', check_dns=False
            )
        )

        group.add_option(
            '--out', '--output',
            dest='output',
            choices=outputters.keys(),
            help=(
                'Print the output from the \'{0}\' command using the '
                'specified outputter. One of {1}.'.format(
                    self.get_prog_name(),
                    ', '.join([repr(k) for k in outputters])
                )
            )
        )
        group.add_option(
            '--out-indent', '--output-indent',
            dest='output_indent',
            default=None,
            type=int,
            help=('Print the output indented by the provided value in spaces. '
                  'Negative values disables indentation. Only applicable in '
                  'outputters that support indentation.')
        )
        group.add_option(
            '--no-color',
            default=False,
            action='store_true',
            help='Disable all colored output'
        )

        for option in self.output_options_group.option_list:
            def process(opt):
                default = self.defaults.get(opt.dest)
                if getattr(self.options, opt.dest, default) is False:
                    return

                if opt.dest not in ('out', 'output_indent', 'no_color'):
                    msg = (
                        'The option {0} is deprecated. Please consider using '
                        '\'--out {1}\' instead.'.format(
                            opt.get_opt_string(),
                            opt.dest.split('_', 1)[0]
                        )
                    )
                    if version.__version_info__ >= (0, 10, 7):
                        # XXX: CLEAN THIS CODE WHEN 0.10.8 is about to come out
                        self.error(msg)
                    elif log.is_console_configured():
                        logging.getLogger(__name__).warning(msg)
                    else:
                        sys.stdout.write('WARNING: {0}\n'.format(msg))

                self.selected_output_option = opt.dest

            funcname = 'process_{0}'.format(option.dest)
#.........这里部分代码省略.........