主机解析过程（未完待续）

if __name__ =='__main__':
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "Stark.settings")
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sys.path.append(BASE_DIR)
    from Arya.backends.utils import ArgvManagement
    obj = ArgvManagement(sys.argv)

import sys
import django
django.setup()
from Stark import settings
from Arya import action_list
from Arya import models


class ArgvManagement(object):
    """
    接受用户从命令行输入的指令，并分配到相应的模块
    """
    def __init__(self,argvs):
        self.argvs = argvs
        self.argv_parse()

    def help_msg(self):
        print("Available modules:")
        for registered_module in action_list.actions:
            print(" %s" % registered_module)
        exit()

    def argv_parse(self):
        if len(self.argvs) < 2:
            self.help_msg()
        module_name = self.argvs[1]
        if "." in module_name:
            mod_name,mod_method = module_name.split('.')
            module_instance = action_list.actions.get(mod_name)
            if module_instance:
                module_obj = module_instance(self.argvs,models,settings)
                module_obj.process() #解析任务，发送到队列，取任务结果
                if hasattr(module_obj,mod_method):
                    module_method_obj = getattr(module_obj,mod_method)
                    module_method_obj()#调用指定的指令
                else:
                    exit("module [%s] doesn't have [%s] method" % (mod_name,mod_method))
        else:
            exit('invalid module name argument')

class BaseSaltModule(object):

    def __init__(self,sys_argvs,db_models,settings):
        self.sys_argvs = sys_argvs
        self.db_models = db_models
        self.setting =settings

    def process(self):
        self.fetch_hosts()
        self.config_data_dic = self.get_selected_os_types()

    def get_selected_os_types(self):
        data = {}
        for host in self.host_list:
            data[host.os_type] = []
        print('-->data',data)
        return data

    def fetch_hosts(self):
        print("there fetching host")
        if '-h' in self.sys_argvs or '-g' in self.sys_argvs:
            host_list = []
            if '-h' in self.sys_argvs:
                host_str_index = self.sys_argvs.index('-h')+1
                if len(self.sys_argvs)  <= host_str_index:
                    exit('host argument must be provide after -h')
                else:
                    host_str = self.sys_argvs[host_str_index]
                    host_str_list = host_str.split(',')
                    host_list += self.db_models.Host.objects.filter(hostname__in = host_str_list )
            if '-g' in self.sys_argvs:
                group_str_index = self.sys_argvs.index('-g')+1
                if len(self.sys_argvs)  <= group_str_index:
                    exit('group argument must be provide after -g')
                else:
                    group_str = self.sys_argvs[group_str_index]
                    group_str_list = group_str.split(',')
                    group_list = self.db_models.HostGroup.objects.filter(name__in = group_str_list )
                    for group in group_list:
                        host_list +=group.host.select_related()
            self.host_list = set(host_list)
            return True
        else:
            print('host [-h] argument or [-g] argument must be provided')

    def syntax_parser(self, section_name, mod_name, mod_data):
        print("-going to parser state data:", section_name, mod_name)
        for state_item in mod_data:
            print("	", state_item)
            for key, val in state_item.items():
                if hasattr(self, key):
                    state_func = getattr(self, key)
                    state_func(val)
                else:
                    exit("Error:module [%s] has no argument [%s]" % (mod_name, key))

    def require(self,*args,**kwargs):
        pass

import os
from Arya.backends.base_module import BaseSaltModule


class State(BaseSaltModule):

    def load_state_files(self, state_filename):
        from yaml import load, dump
        try:
            from yaml import CLoader as Loader, CDumper as Dumper
        except ImportError:
            from yaml import Loader, Dumper
        state_file_path = "%s/%s" % (self.setting.SALT_CONFIG_FILES_DIR, state_filename)
        if os.path.isfile(state_file_path):
            with open(state_file_path) as f:
                data = load(f.read(), Loader=Loader)
                return data
        else:
            exit("%s is not a valid yaml config file" % state_filename)


    def apply(self):
        """
        1、下载配置文件
        2、解析
        3、创建一个任务，并发送到队列
        4、收集任务结果
        :return:
        """
        if '-f' in self.sys_argvs:
            yaml_file_index = self.sys_argvs.index('-f') + 1
            try:
                yaml_filename = self.sys_argvs[yaml_file_index]
                state_data = self.load_state_files(yaml_filename)
                for os_type, os_type_data in self.config_data_dic.items():  # 按照不同的操作系统单独生成一份配置文件
                    for section_name, section_data in state_data.items():
                            print('Section:', section_name)
                            for mod_name, mod_data in section_data.items():
                                base_mod_name = mod_name.split(".")[0]
                                plugin_file_path = "%s/%s.py" % (self.setting.SALT_PLUGINS_DIR, base_mod_name)
                                if os.path.isfile(plugin_file_path):
                                    module_plugin = __import__('plugins.%s' % base_mod_name)
                                    special_os_module_name = "%s%s" % (os_type.capitalize(), base_mod_name.capitalize())
                                    getattr(module_plugin, base_mod_name)
                                    module_file = getattr(module_plugin, base_mod_name)
                                    if hasattr(module_file, special_os_module_name):  # 判断有没有根据操作系统的类型进行特殊解析 的类，在这个文件里
                                        module_instance = getattr(module_file, special_os_module_name)
                                    else:
                                        module_instance = getattr(module_file, base_mod_name.capitalize())
                                    module_obj = module_instance(self.sys_argvs, self.db_models, self.setting)
                                    module_obj.syntax_parser(section_name, mod_name, mod_data)
                                else:
                                    exit("module [%s] is not exist" % base_mod_name)
                                print(" ",mod_name)
                                for state_item in mod_data:
                                    print("	",state_item)
                            # base_mod_name = mod_name.split(".")[0]
                            # plugin_file_path = "%s/%s.py" % (self.setting.SALT_PLUGINS_DIR, base_mod_name)
                            # if os.path.isfile(plugin_file_path):
                            #     # 导入 模块
                            #
                            #     module_plugin = __import__('plugins.%s' % base_mod_name)
                            #     special_os_module_name = "%s%s" % (os_type.capitalize(), base_mod_name.capitalize())
                            #     # print('dir module plugin:',module_plugin,base_mod_name)
                            #     # getattr(module_plugin,base_mod_name)
                            #     module_file = getattr(module_plugin, base_mod_name)  # 这里才是真正导入模块
                            #     if hasattr(module_file, special_os_module_name):  # 判断有没有根据操作系统的类型进行特殊解析 的类，在这个文件里
                            #         module_instance = getattr(module_file, special_os_module_name)
                            #     else:
                            #         module_instance = getattr(module_file, base_mod_name.capitalize())
                            #
                            #     # 开始调用 此module 进行配置解析
                            #     module_obj = module_instance(self.sys_argvs, self.db_models, self.settings)
                            #     module_obj.syntax_parser(section_name, mod_name, mod_data)
                            # else:
                            #     exit("module [%s] is not exist" % base_mod_name)
                            #     # print("  ",mod_name)
                            #     # for state_item in mod_data:
                            #     #    print("	",state_item)

            except IndexError as e:
                exit("state file must be provided after -f")

        else:
            exit("statefile must be specified.")

from Arya.backends.base_module import BaseSaltModule

class User(BaseSaltModule):

    def uid(self,*args):
        pass

    def gid(self,*args):
        pass

    def shell(self,*args):
        pass

    def home(self,*args):
        pass

class UbuntuUser(User):
    def home(self,*args):
        print('in ubuntu ')

from Arya.plugins import cmd,state

actions = {
    'cmd': cmd.CMD,
    'state':state.State
}

from django.db import models

# Create your models here.


class Host(models.Model):

    hostname = models.CharField(max_length=32)
    key = models.TextField()

    status_choices = ((0,'Waiting'),
                      (1,'Accepted'),
                      (2,'Rejected'))
    status = models.SmallIntegerField(choices=status_choices,default=0)
    os_type_choices = (
        ('redhat', 'RedhatCentOS'),
        ('ubuntu', 'Ubuntu'),
        ('suse', 'Suse'),
        ('windows', 'Windows'),
    )
    os_type = models.CharField(choices=os_type_choices, max_length=64, default='redhat')

    def __str__(self):
        return self.hostname

class HostGroup(models.Model):
    name = models.CharField(max_length=64,unique=True)
    host = models.ManyToManyField(Host,blank=True)

    def __str__(self):
        return self.name

apache:
  #pkg.installed: []
  #service.running:
  #  - reload: True
  #  - watch:
  #    - file: /etc/httpd/conf/httpd.conf
  user.present:
    - uid: 87
    #- username: alex
    - gid: 87
    - home: /var/www/html
    - shell: /bin/nologin
    - require:
      - group: apache
  group.present:
    - gid: 87
    - require:
      - pkg: apache

#/etc/httpd/conf/httpd.conf:
#  file.managed:
#    - source: salt://apache/httpd.conf
#    - user: root
#    - group: root
#    - mode: 644

setting.py中的配置
SALT_CONFIG_FILES_DIR = "%s/Arya/salt_configs" % BASE_DIR
SALT_PLUGINS_DIR = "%s/Arya/plugins" % BASE_DIR
命令行输入调试命令：
python salt.py state.apply -h "windows,redhat" -g "group2" -f test.yml