主机管理+堡垒机系统开发：前端批量命令结果（十二）

一、实际生产的架构图

1、生产环境为什么要这样干

1. 解耦
2. 异步

 2、常用的queue软件

1. redis, rabbitmq
2. github ,
3. restful API
4. celery

二、我们今天如何实现？

1、实现思路

问题：views和web之间已返回，线程这里就断开了，那是因为你用django又启了一个线程

怎样才启动一个独立的进程，和django是没有关系，只不过是用django启动的，由操作系统来管理

三、目录结构

四、代码实现

1、backend

1、main

import subprocess
from web import models
from django.contrib.auth import authenticate
import random,string,uuid


class HostManager(object):
    """用户登陆堡垒机后的交互程序"""
    def __init__(self):
        self.user = None
    def get_session_id(self,bind_host_obj,tag):
        '''apply  session id'''
        session_obj = models.Session(user_id = self.user.id,bind_host=bind_host_obj,tag=tag)

        session_obj.save()
        return session_obj
    
    def interactive(self):
        """交互脚本"""
        print("----run---------")

        count = 0
        while count <3:
            username = input("Username:").strip()
            password = input("Password:").strip()
            user = authenticate(username=username,password=password)
            if user:
                print("Welcome %s".center(50,'-') % user.name )
                self.user = user
                break
            else:
                print("Wrong username or password!")

            count += 1

        else:
            exit("Too many attempts, bye.")

        if self.user: #验证成功
            while True:
                for index,host_group  in enumerate(self.user.host_groups.all()): #select_related()
                    print("%s.	%s[%s]" %(index,host_group.name, host_group.bind_hosts.count()))
                print("z.	未分组主机[%s]" %(self.user.bind_hosts.count()))


                choice = input("%s>>:"% self.user.name).strip()
                if len(choice) == 0:continue
                selected_host_group = None

                if choice.isdigit():
                    choice = int(choice)
                    if choice >=0 and choice <= index: #合法选项
                        selected_host_group = self.user.host_groups.all()[choice]
                elif choice == 'z':
                    selected_host_group = self.user

                if selected_host_group:
                    print("selected host group", selected_host_group)
                    while True:
                        for index, bind_host in enumerate(selected_host_group.bind_hosts.all()):
                            print("%s.	%s" % (index, bind_host))
                        choice = choice = input("%s>>>:" % self.user.name).strip()
                        if choice.isdigit():
                            choice = int(choice)
                            if choice >= 0 and choice <= index:  # 合法选项
                                print("going to logon ....", selected_host_group.bind_hosts.all()[choice])
                                bind_host = selected_host_group.bind_hosts.all()[choice]
                                ssh_tag  = uuid.uuid4()
                                session_obj =  self.get_session_id(bind_host,ssh_tag)

                                monitor_script = subprocess.Popen("sh /opt/CrazyEye/backend/session_tracker.sh %s %s" % (ssh_tag,session_obj.id),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
                                
                                #print(monitor_script.stderr.read()) 

                                subprocess.run('sshpass -p %s ssh %s@%s -E %s -o  StrictHostKeyChecking=no' %(bind_host.remote_user.password,
                                                                           bind_host.remote_user.username,
                                                                           bind_host.host.ip_addr ,ssh_tag ), shell=True)
                                

                        elif choice == 'b':
                            break

2、task_manager

import json,os ,subprocess
from django import conf
from web import models

class MultiTaskManger(object):
    """负责解析并触发批量任务"""

    def __init__(self,request):
        self.request = request

        self.call_task()

    def task_parser(self):
        """解析任务"""
        self.task_data = json.loads(self.request.POST.get("task_data"))

    def call_task(self):

        self.task_parser()

        if self.task_data['task_type'] == 0:#cmd
            self.cmd_task()

        elif self.task_data['task_type'] == 1:#file transfer
            self.file_transfer_task()


    def cmd_task(self):
        """
        1.生产任务id
        2.触发任务
        3.返回任务id
        :return:
        """

        task_obj = models.Task.objects.create(user=self.request.user,
                                              task_type=self.task_data['task_type'],
                                              content = self.task_data["cmd"])

        sub_task_objs = []

        for host_id in self.task_data['selected_host_ids']       :
            sub_task_objs.append(models.TaskLogDetail(task=task_obj,bind_host_id=host_id,result='init...',status=2))


        models.TaskLogDetail.objects.bulk_create(sub_task_objs)

        task_script_obj = subprocess.Popen("python %s %s" %(conf.settings.MULTITASK_SCRIPT,task_obj.id),
                                           shell=True,stdout=subprocess.PIPE)



        self.task = task_obj





    def file_transfer_task(self):
        """
         1.生产任务记录
         2.触发任务
         3. 返回任务id
        :return:
        """


        task_obj = models.Task.objects.create(user=self.request.user,
                                              task_type=self.task_data['task_type'],
                                              content=json.dumps(self.task_data))

        sub_task_objs = []


        for host_id in self.task_data['selected_host_ids']:
            sub_task_objs.append(models.TaskLogDetail(task=task_obj, bind_host_id=host_id, result='init...', status=2))

        models.TaskLogDetail.objects.bulk_create(sub_task_objs)


        task_script_obj = subprocess.Popen("python %s %s" % (conf.settings.MULTITASK_SCRIPT, task_obj.id),
                                           shell=True, stdout=subprocess.PIPE)

        self.task = task_obj

3、task_runner　　

import sys ,os
import time,json
from concurrent.futures  import ThreadPoolExecutor

import paramiko

def  ssh_cmd(task_log_obj):
    host = task_log_obj.bind_host.host
    user_obj = task_log_obj.bind_host.remote_user

    try:

        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect(host.ip_addr, host.port, user_obj.username, user_obj.password,timeout=10)

        stdin, stdout, stderr = ssh.exec_command(task_log_obj.task.content)

        stdout_res = stdout.read()
        stderr_res = stderr.read()

        result = stdout_res + stderr_res
        print(result)
        task_log_obj.result = result

        task_log_obj.status = 0
        ssh.close()

    except Exception as e :
        task_log_obj.result = e
        task_log_obj.status = 1

    task_log_obj.save()

def file_transfer(task_log_obj):
    host = task_log_obj.bind_host.host
    user_obj = task_log_obj.bind_host.remote_user
    try:

        t = paramiko.Transport((host.ip_addr, host.port))

        t.connect(username=user_obj.username, password=user_obj.password)

        sftp = paramiko.SFTPClient.from_transport(t)

        task_data = json.loads(task_log_obj.task.content)


        if task_data['file_transfer_type'] == 'send':
            sftp.put(task_data['local_file_path'],task_data['remote_file_path'])
            task_log_obj.result = "send local file [%s] to remote [%s] succeeded!" %(task_data['local_file_path'],
                                                                                     task_data['remote_file_path'])

        else: #get

            local_file_path = "%s/%s" %(django.conf.settings.DOWNLOAD_DIR,task_log_obj.task.id)
            if not os.path.isdir(local_file_path):
                os.mkdir(local_file_path)
            file_name = task_data['remote_file_path'].split('/')[-1]
            sftp.get(task_data['remote_file_path'], "%s/%s.%s" %(local_file_path,host.ip_addr,file_name))
            task_log_obj.result = "get remote file [%s] succeeded" %(task_data['remote_file_path'])

        t.close()
        task_log_obj.status = 0

    except Exception as e:
        task_log_obj.result = e
        task_log_obj.status = 1
    task_log_obj.save()


if __name__ == '__main__':

    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    sys.path.append(base_dir)
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "CrazyEye.settings")
    import django
    django.setup()
    from django import conf

    from web import models


    if len(sys.argv) ==  1:
        exit("error:must provide task_id!")
    task_id = sys.argv[1]

    task_obj = models.Task.objects.get(id=task_id)


    #1. 生产多线程
    pool = ThreadPoolExecutor(10)


    if task_obj.task_type == 0:#cmd
        thread_func = ssh_cmd
    else: #file_transfer
        thread_func = file_transfer

    for task_log_detail_obj in task_obj.tasklogdetail_set.all():
        pool.submit(thread_func,task_log_detail_obj)

        #ssh_cmd(task_log_detail_obj)

    pool.shutdown(wait=True)

2、CrazyEye

1、settings

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'c+lq-s!5j1($4zj+_3icw1xwr)yt#%x%&um#!e!b*-*5x(0&3a'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = ["*"]


# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'web',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'CrazyEye.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'CrazyEye.wsgi.application'


# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# Password validation
# https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/1.10/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/

STATIC_URL = '/static/'

STATICFILES_DIRS = (
    os.path.join(BASE_DIR,'statics'),
)


AUTH_USER_MODEL = 'web.UserProfile'

AUDIT_LOG_DIR = os.path.join(BASE_DIR,'log')
MULTITASK_SCRIPT= os.path.join(BASE_DIR,'backend/task_runner.py')

DOWNLOAD_DIR = os.path.join(BASE_DIR,'downloads')


LOGIN_URL = "/login/"

2、urls

from django.conf.urls import url
from django.contrib import admin
from web import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', views.dashboard),
    url(r'^user_audit/$', views.user_audit,name="user_audit"),
    url(r'^audit_log/(w+-w+-w+)/$', views.audit_log_date,name="audit_log_date"),
    url(r'^audit_log/(w+-w+-w+)/(d+)/$', views.audit_log_detail,name="audit_log_detail"),
    url(r'^webssh/$', views.webssh,name="webssh"),
    url(r'^multitask/cmd/$', views.multitask_cmd,name="multitask_cmd"),
    url(r'^multitask/file_transfer/$', views.multitask_file_transfer,name="multitask_file_transfer"),
    url(r'^multitask/$', views.multitask,name="multitask"),
    url(r'^multitask/result/$', views.multitask_result,name="task_result"),
    url(r'^login/$', views.acc_login),
    url(r'^logout/$', views.acc_logout,name="logout"),

]

3、templates

1、multitack_cmd.html

{% extends 'index.html' %}


{% block page-title %}主机管理|批量命令{% endblock %}

{% block page-content %}
    {% csrf_token %}

<div class="row">

    {% include 'multitask_host_list_component.html' %}

    <div class="col-lg-8">
        <div class="panel">
            <div class="panel-heading">
                <h3 class="panel-title">命令操作</h3>
            </div>
            <div class="panel-body">
                <textarea id="cmd_text" class="form-control"></textarea>
                <input type="button" id='post_task_btn'  onclick="PostTask(this,'cmd')" class="btn btn-success pull-right" value="执行命令">
            </div>
        </div>
        <div class="panel">
            <div class="panel-heading">
                <h3 class="panel-title">任务结果</h3>
            </div>
            <div class="panel-body">
                <ul id="task_result_container"></ul>
            </div>
        </div>
    </div>

</div>


{% include 'multitask_js_component.html' %}

{% endblock %}

2、multitask_host_list_component

    <div class="col-lg-4">
        <div class="panel">
            <div class="panel-heading">
                <h3 class="panel-title">主机列表</h3>
            </div>
            <div class="panel-body">
                    <div class="list-group bord-no">
                        <a onclick="HostListDisplayToggle(this)" class="list-group-item " href="#">
                            <input type="checkbox" onclick="SelectGroup(this)">
                            未分组主机
                            <span class="badge badge-primary">{{ request.user.bind_hosts.count }}</span>
                        </a>
                        <ol class="hide">
                            {% for bind_host in request.user.bind_hosts.all %}
                                <li><input type="checkbox"  select_host="true" value="{{ bind_host.id }}">{{ bind_host.host.hostname }}({{ bind_host.host.ip_addr }})@{{ bind_host.remote_user.username}}</li>
                            {% endfor %}
                        </ol>



                        {% for host_group in request.user.host_groups.select_related %}

                            <a onclick="HostListDisplayToggle(this)" class="list-group-item " href="#">
                                <input type="checkbox" onclick="SelectGroup(this)">
                                {{ host_group.name }}
                                <span class="badge badge-primary">{{ host_group.bind_hosts.count }}</span>
                            </a>
                            <ol class="hide">
                                {% for bind_host in host_group.bind_hosts.all %}
                                    <li><input type="checkbox"  select_host="true" value="{{ bind_host.id }}">{{ bind_host.host.hostname }}({{ bind_host.host.ip_addr }})@{{ bind_host.remote_user.username}}</li>
                                {% endfor %}
                            </ol>


                        {% endfor %}
                    </div>
            </div>
        </div>

    </div>

3、multitask_js_component

<script>


    function SelectFileTransferType(ele) {
        if ($(ele).val() == 'get'){

            $("#local_file_path").addClass("hide");
        }else {
            $("#local_file_path").removeClass("hide");
        }
    }

    function HostListDisplayToggle(ele) {

        $(ele).next().toggleClass("hide");


    }

    function SelectGroup(ele) {

        $(ele).parent().next().find("input").prop("checked",$(ele).prop("checked"))

    }

    function  GetTaskResult(task_id) {

        $.getJSON( "{% url 'task_result'  %}" ,{'task_id':task_id},function(callback){

           console.log( callback);
           var all_task_done = true;
           $.each(callback,function (index,ele) {
               var li_ele = $("li[bind_host_id='"+  ele['id'] +"']");
               li_ele.next().text(ele['result']);
               $(li_ele.children()[0]).text(ele.status);
               if ( ele.status == 2 ){
                   all_task_done = false; //有任务未完成
               }

           })

           if (all_task_done){

               clearInterval(ResultRefreshObj);
               $("#post_task_btn").removeClass("disabled");
           }

        });//end getJSON
    }


    function PostTask(ele,task_type) {

        var selected_host_ids  = [];

        $("input[select_host]:checked").each(function () {
            selected_host_ids.push( $(this).val()  );
        })

        console.log(selected_host_ids)
        if (selected_host_ids.length == 0){
            alert("必须选择主机!")
            return false
        }

        if (task_type == "cmd"){
            var cmd_text = $("#cmd_text").val().trim();

            if (cmd_text.length == 0){

                alert("必须输入要执行的命令!")
                return false
            }

            var task_arguments = {
                'selected_host_ids' : selected_host_ids,
                'task_type':0 ,//cmd
                'cmd': cmd_text,

            }

        }else {

            var file_transfer_type = $("select[name='file_transfer_type']").val()
            var local_file_path = $("#local_file_path").val().trim()
            var remote_file_path = $("#remote_file_path").val().trim()
            if (file_transfer_type == "send"){
                if (local_file_path.length == 0){
                    alert("必须输入本地文件路径！")
                    return false
                }

            }

            if (remote_file_path.length == 0){
                    alert("必须输入远程文件路径！")
                    return false
            }

            var task_arguments = {
                'selected_host_ids' : selected_host_ids,
                'task_type':1 ,//file_transfer
                'file_transfer_type': file_transfer_type,
                'local_file_path':local_file_path,
                'remote_file_path':remote_file_path

            }

        }






        //再此任务执行完成前，不允许再提交新任务
        $(ele).addClass("disabled")
        //提交新任务之前情况任务结果面版
        $("#task_result_container").empty();


        $.post("{%  url 'multitask' %}"  , {'task_data':JSON.stringify(task_arguments),'csrfmiddlewaretoken':$("input[name='csrfmiddlewaretoken']").val() },function(callback){

            console.log(callback);

            var callback = JSON.parse(callback);
            $.each(callback.selected_hosts,function (index,ele) {
                var li_ele = "<li bind_host_id='"+ ele['id'] +"'>Host:" + ele.bind_host__host__hostname + "(" +ele.bind_host__host__ip_addr +")----------------<span></span></li><pre>sdff</pre>" ;
                $("#task_result_container").append(li_ele);

            })



            //去后端定时拿结果
            ResultRefreshObj = setInterval(function () {

                    GetTaskResult(callback.task_id);


                },2000);

        });//end post



    }

</script>

4、web

1、admin

from django.contrib import admin

from web import models
# Register your models here.


from django import forms
from django.contrib import admin
from django.contrib.auth.models import Group
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib.auth.forms import ReadOnlyPasswordHashField

from web.models import UserProfile


class UserCreationForm(forms.ModelForm):
    """A form for creating new users. Includes all the required
    fields, plus a repeated password."""
    password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
    password2 = forms.CharField(label='Password confirmation', widget=forms.PasswordInput)

    class Meta:
        model = UserProfile
        fields = ('email', 'name')

    def clean_password2(self):
        # Check that the two password entries match
        password1 = self.cleaned_data.get("password1")
        password2 = self.cleaned_data.get("password2")
        if password1 and password2 and password1 != password2:
            raise forms.ValidationError("Passwords don't match")
        return password2

    def save(self, commit=True):
        # Save the provided password in hashed format
        user = super(UserCreationForm, self).save(commit=False)
        user.set_password(self.cleaned_data["password1"])
        if commit:
            user.save()
        return user


class UserChangeForm(forms.ModelForm):
    """A form for updating users. Includes all the fields on
    the user, but replaces the password field with admin's
    password hash display field.
    """
    password = ReadOnlyPasswordHashField()

    class Meta:
        model = UserProfile
        fields = ('email', 'password', 'name', 'is_active', 'is_admin')

    def clean_password(self):
        # Regardless of what the user provides, return the initial value.
        # This is done here, rather than on the field, because the
        # field does not have access to the initial value
        return self.initial["password"]


class UserProfileAdmin(BaseUserAdmin):
    # The forms to add and change user instances
    form = UserChangeForm
    add_form = UserCreationForm

    # The fields to be used in displaying the User model.
    # These override the definitions on the base UserAdmin
    # that reference specific fields on auth.User.
    list_display = ('email', 'name','is_staff', 'is_admin')
    list_filter = ('is_admin','is_staff')
    fieldsets = (
        (None, {'fields': ('email', 'password')}),
        ('Personal info', {'fields': ('name',)}),
        ('堡垒机主机授权', {'fields': ('bind_hosts','host_groups')}),
        ('Permissions', {'fields': ('is_admin','is_staff','user_permissions','groups')}),
    )
    # add_fieldsets is not a standard ModelAdmin attribute. UserAdmin
    # overrides get_fieldsets to use this attribute when creating a user.
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'name', 'password1', 'password2')}
        ),
    )
    search_fields = ('email',)
    ordering = ('email',)
    filter_horizontal = ('user_permissions','groups','bind_hosts','host_groups')

# Now register the new UserAdmin...
admin.site.register(models.UserProfile, UserProfileAdmin)
# ... and, since we're not using Django's built-in permissions,
# unregister the Group model from admin.
admin.site.unregister(Group)



class RemoteUserAdmin(admin.ModelAdmin):
    list_display = ('username','auth_type','password')


class TaskAdmin(admin.ModelAdmin):
    list_display = ['id','user','task_type','content','date']


class TaskLogDetailAdmin(admin.ModelAdmin):
    list_display = ['id','task','bind_host','result','status','start_date','end_date']


admin.site.register(models.Host)
admin.site.register(models.HostGroup)
admin.site.register(models.BindHost)
admin.site.register(models.RemoteUser,RemoteUserAdmin)
admin.site.register(models.IDC)
admin.site.register(models.Session)
admin.site.register(models.Task,TaskAdmin)
admin.site.register(models.TaskLogDetail,TaskLogDetailAdmin)

2、models

from django.db import models
from django.contrib.auth.models import User

from django.contrib.auth.models import (
    BaseUserManager, AbstractBaseUser,PermissionsMixin
)



# Create your models here.

class IDC(models.Model):
    name = models.CharField(max_length=64,unique=True)

    def __str__(self):
        return self.name

class Host(models.Model):
    """存储所有主机"""
    hostname = models.CharField(max_length=64)
    ip_addr = models.GenericIPAddressField(unique=True)
    port = models.PositiveSmallIntegerField(default=22)
    idc = models.ForeignKey("IDC")

    enabled = models.BooleanField(default=True)

    def __str__(self):
        return self.ip_addr



class HostGroup(models.Model):
    """主机组"""
    name = models.CharField(max_length=64, unique=True)
    bind_hosts  = models.ManyToManyField("BindHost")
    def __str__(self):
        return self.name



class RemoteUser(models.Model):
    """存储远程用户名密码"""
    username = models.CharField(max_length=64)
    auth_type_choices = ((0,'ssh/password'),(1,'ssh/key'))
    auth_type = models.SmallIntegerField(choices=auth_type_choices,default=0)
    password = models.CharField(max_length=128,blank=True,null=True)

    #hosts = models.ManyToManyField("Host")

    def __str__(self):
        return "%s(%s)%s" %( self.username,self.get_auth_type_display(),self.password)

    class Meta:
        unique_together = ('username','auth_type','password')

class BindHost(models.Model):
    """绑定远程主机和远程用户的对应关系"""
    host = models.ForeignKey("Host")
    remote_user = models.ForeignKey("RemoteUser")

    def __str__(self):
        return "%s -> %s" %(self.host,self.remote_user)
    class Meta:
        unique_together = ("host","remote_user")



class UserProfileManager(BaseUserManager):
    def create_user(self, email, name, password=None):
        """
        Creates and saves a User with the given email, date of
        birth and password.
        """
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            email=self.normalize_email(email),
            name=name,
        )

        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, name, password):
        """
        Creates and saves a superuser with the given email, date of
        birth and password.
        """
        user = self.create_user(
            email,
            password=password,
            name=name,
        )
        user.is_admin = True
        user.is_staff = True
        user.save(using=self._db)
        return user


class UserProfile(AbstractBaseUser,PermissionsMixin):
    email = models.EmailField(
        verbose_name='email address',
        max_length=255,
        unique=True,
    )
    name = models.CharField(max_length=64)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)
    is_staff = models.BooleanField(
        ('staff status'),
        default=False,
        help_text=('Designates whether the user can log into this admin site.'),
    )

    bind_hosts = models.ManyToManyField("BindHost",blank=True)
    host_groups = models.ManyToManyField("HostGroup",blank=True)

    objects = UserProfileManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['name',]

    def get_full_name(self):
        # The user is identified by their email address
        return self.email

    def get_short_name(self):
        # The user is identified by their email address
        return self.email

    def __str__(self):              # __unicode__ on Python 2
        return self.email

    def has_perm(self, perm, obj=None):
        "Does the user have a specific permission?"
        # Simplest possible answer: Yes, always
        return True

    def has_module_perms(self, app_label):
        "Does the user have permissions to view the app `app_label`?"
        # Simplest possible answer: Yes, always
        return True




class Session(models.Model):
    '''生成用户操作session id '''
    user = models.ForeignKey('UserProfile')
    bind_host = models.ForeignKey('BindHost')
    tag = models.CharField(max_length=128,default='n/a')
    closed = models.BooleanField(default=False)
    cmd_count = models.IntegerField(default=0) #命令执行数量
    stay_time = models.IntegerField(default=0, help_text="每次刷新自动计算停留时间",verbose_name="停留时长(seconds)")
    date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return '<id:%s user:%s bind_host:%s>' % (self.id,self.user.email,self.bind_host.host)
    class Meta:
        verbose_name = '审计日志'
        verbose_name_plural = '审计日志'



class Task(models.Model):
    """批量任务记录表"""
    user = models.ForeignKey("UserProfile")
    task_type_choices = ((0,'cmd'),(1,'file_transfer'))
    task_type = models.SmallIntegerField(choices=task_type_choices)
    content = models.TextField(verbose_name="任务内容")
    #hosts = models.ManyToManyField("BindHost")
    date  = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return "%s %s" %(self.task_type,self.content)


class TaskLogDetail(models.Model):
    task = models.ForeignKey("Task")
    bind_host = models.ForeignKey("BindHost")
    result = models.TextField()

    status_choices = ((0,'success'),(1,'failed'),(2,'init'))
    status = models.SmallIntegerField(choices=status_choices)

    start_date = models.DateTimeField(auto_now_add=True)
    end_date = models.DateTimeField(blank=True,null=True)


    def __str__(self):
        return "%s %s" %(self.bind_host,self.status)

3、views

from django.shortcuts import render,redirect,HttpResponse
from django.contrib.auth.decorators import login_required
from django.contrib.auth import authenticate,logout,login
from  django.conf import settings
import os,re,json
from web import models
from backend.task_manager import  MultiTaskManger

from backend import audit
# Create your views here.

def json_date_handler(obj):
    if hasattr(obj, 'isoformat'):
        return obj.strftime("%Y-%m-%d %T")



@login_required
def dashboard(request):
    return render(request,'index.html')


def acc_login(request):

    error_msg = ''

    if request.method == "POST":
        username = request.POST.get('username')
        password = request.POST.get('password')
        user = authenticate(username=username,password=password)
        if user:
            login(request,user)

            return redirect("/")

        else:
            error_msg = "Wrong username or password!"
    return render(request,"login.html",{'error_msg':error_msg})


def acc_logout(request):

    logout(request)

    return redirect("/login/")



@login_required
def webssh(request):
    return render(request,'web_ssh.html')

@login_required
def user_audit(request):

    log_dirs = os.listdir(settings.AUDIT_LOG_DIR)


    return render(request,'user_audit.html',locals())


@login_required
def audit_log_date(request,log_date):
    log_date_path = "%s/%s" %(settings.AUDIT_LOG_DIR,log_date)
    log_file_dirs = os.listdir(log_date_path)
    session_ids = [re.search("d+",i).group() for i in log_file_dirs ]

    session_objs = models.Session.objects.filter(id__in=session_ids)

    return render(request, 'user_audit_file_list.html', locals())


@login_required
def multitask_cmd(request):

    return render(request,"multitask_cmd.html")

@login_required
def multitask_file_transfer(request):
    return render(request,'multitask_file_transfer.html')


@login_required
def multitask_result(request):
    task_id = request.GET.get('task_id')
    task_obj = models.Task.objects.get(id=task_id)
    task_log_results = list(task_obj.tasklogdetail_set.values('id', 'result','status','start_date','end_date'))

    return  HttpResponse(json.dumps(task_log_results,default=json_date_handler))

@login_required
def multitask(request):

    print("--->",request.POST)
    task_data = json.loads(request.POST.get('task_data'))
    print("--->selcted hosts",task_data)

    task_obj= MultiTaskManger(request)
    selected_hosts = list(task_obj.task.tasklogdetail_set.all().values('id', 'bind_host__host__ip_addr',
                                                             'bind_host__host__hostname', 'bind_host__remote_user__username'))



    return HttpResponse(
        json.dumps({'task_id':task_obj.task.id,'selected_hosts':selected_hosts})
    )


@login_required
def audit_log_detail(request,log_date,session_id):
    log_date_path = "%s/%s" % (settings.AUDIT_LOG_DIR, log_date)
    log_file_path = "%s/session_%s.log" %(log_date_path,session_id)

    log_parser = audit.AuditLogHandler(log_file_path)
    cmd_list = log_parser.parse()

    return render(request,"user_audit_detail.html",locals())

五、测试截图

1、执行一条命令

1、web端

2、admin后台

2、执行多条命令

1、web前端

2、admin后台

4、连接不上的命令截图

连接不上直接排除timeout

3、后台触发一条命令

1、后台触发创建

2、控制台截图

3、admin后台截图

4、执行结果前端web显示

1、任务结果前端显示hostid

2、任务结果限制执行结果

 3、超时处理

 4、机器连接不通

5、超时状态数字变化

6、执行成功状态变化