对webssh实现命令回放功能

想要实现webssh的命令记录功能需要一个前端的组件 asciinema

django服务端代码

class WebSSH(WebsocketConsumer):
    message = {'status': 0, 'message': None}
    """
    status:
        0: ssh 连接正常, websocket 正常
        1: 发生未知错误, 关闭 ssh 和 websocket 连接

    message:
        status 为 1 时, message 为具体的错误信息
        status 为 0 时, message 为 ssh 返回的数据, 前端页面将获取 ssh 返回的数据并写入终端页面
    """

    def connect(self):
        try:
            self.accept()
            logger.info('open connet service ssh')

            query_string = self.scope['query_string']
            logger.info(query_string)
            connet_argv = QueryDict(query_string=query_string, encoding='utf-8')
            logger.info(connet_argv)
            serverid = connet_argv.get('unique')
            width = connet_argv.get('width')
            height = connet_argv.get('height')
            appid = connet_argv.get('appid','')
            execuserid = connet_argv.get('execuserid','')

            width = int(width)
            height = int(height)

            service = models.ServiceModel.objects.get(id=serverid)

            host = service.ipaddress
            port = str(service.port)
            user = system_config.log_user
            logger.info('{} {} {} {} {}'.format(serverid,height,serverid,host,user))
            self.ssh = SSH(websocker=self, message=self.message)
            self.execuserid = execuserid
            self.serverid = serverid


            self.ssh.connect(
                host=host,
                user=user,
                port=port,
                pty_width=width,
                pty_height=height
            )
            if appid:
                app = models.ApplicationModel.objects.get(id=appid)
                self.ssh.shell('/home/{}/showlog.sh {}
'.format(user,app.tomcatname))

        except Exception as e:
            logger.info(e)
            self.message['status'] = 1
            self.message['message'] = str(e)
            message = json.dumps(self.message)
            self.send(message)
            self.close()

    def disconnect(self, close_code):
        try:
            self.ssh.close()
        except:
            pass

    def receive(self, text_data=None, bytes_data=None):
        data = json.loads(text_data)
        if type(data) == dict:
            status = data['status']
            if status == 0:
                data = data['data']
                self.ssh.shell(data,self) #这里执行命令的时候把对象本身传进去（用了channels和xterm.js通过websocket实现的webssh是一个字符一个字符发送的，在parimako这个模块中做了一系列的命令组装，组成一个完整的shell命令）

            else:
                cols = data['cols']
                rows = data['rows']
                self.ssh.resize_pty(cols=cols, rows=rows)

    def savecommend(self,commend):   #这里是保存命令的方法
        servicecommit = ServiceCommitModel()
        servicecommit.service_id = self.serverid
        servicecommit.user_id = self.execuserid
        json_commend = json.dumps(commend)
        servicecommit.commitname = json_commend[1:-1]
        servicecommit.save()
        logger.info(json_commend)

import paramiko
from threading import Thread
from libs.ansible_libs.tools import get_key_obj
import socket
import json
import logging


class SSH:
    def __init__(self, websocker, message):
        self.websocker = websocker
        self.message = message

    def connect(self, host, user, password=None, pkey=None, port=22, timeout=120,
                term='xterm', pty_width=80, pty_height=24):
        try:
            ssh_client = paramiko.SSHClient()
            ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

            if password:
                ssh_client.connect(username=user, password=password, hostname=host, port=port, timeout=timeout)
            else:
                ssh_client.connect(username=user, hostname=host, port=port, timeout=timeout)

            transport = ssh_client.get_transport()
            self.channel = transport.open_session()
            self.channel.get_pty(term=term, width=pty_width, height=pty_height)
            self.channel.invoke_shell()

            for i in range(2):
                recv = self.channel.recv(1024).decode('utf-8')
                self.message['status'] = 0
                self.message['message'] = recv
                message = json.dumps(self.message)
                self.websocker.send(message)

        except socket.timeout as e:
            self.message['status'] = 1
            self.message['message'] = 'ssh 连接超时'
            message = json.dumps(self.message)
            logging.info('connet server timeout')
            self.websocker.send(message)
            self.websocker.close()
        except Exception as e:
            self.message['status'] = 1
            self.message['message'] = str(e)
            message = json.dumps(self.message)
            logging.info('connet server custom')
            self.websocker.send(message)
            self.websocker.close()

    def resize_pty(self, cols, rows):
        self.channel.resize_pty(width=cols, height=rows)


    def django_to_ssh(self, data):
        try:
            self.channel.send(data)
            return
        except:
            self.close()

    def websocket_to_django(self,httpobj):
        try:
            while True:
                data = self.channel.recv(1024).decode('utf-8')
                if not len(data):
                    return
                self.message['status'] = 0
                self.message['message'] = data
                message = json.dumps(self.message)  
                self.websocker.send(message)
                print(data)
                try:
                    if httpobj:
                        httpobj.savecommend(str(data))  在这里做命令记录,把命令保存到数据库
                except Exception as e:
                    print(e)
                # httpobj.savecommend(data)
        except Exception as e:
            print(e)
            self.close()

    def close(self):
        self.message['status'] = 1
        self.message['message'] = '关闭连接'
        message = json.dumps(self.message)
        self.websocker.send(message)
        self.channel.close()
        self.websocker.close()

    def shell(self, data, httpobj=None):
        Thread(target=self.django_to_ssh, args=(data,)).start()
        Thread(target=self.websocket_to_django, args=(httpobj,)).start()  #这里是返回到前端的线程，在这个线程中做命令的记录

当需要查看命令回放的时候

class CommandData(LoginRequiredMixin,View):
    def get(self,request):
        '''
        获取用户选择的参数以返回视频文件
        :param request:
        :return:
        '''
        serverid = request.GET.get('sid')
        end_time = request.GET.get('end_time')
        start_time = request.GET.get('start_time')
        userid = request.GET.get('uid')
        servers = ServiceModel.objects.all()
        users = User.objects.all()
        datas = ServiceCommitModel.objects.filter(date__gte=start_time,date__lte=end_time,service_id=serverid,user_id=userid).values('commitname')
        # fileurl = '/home/PyObject/static/image/demo/demo.json'
        fileurl = '/opt/object/static/image/demo/demo.json'
        datalist = list()
        playindex = 0
        with open(fileurl,'wb') as f:
            f.write(bytes('{"version": 2, "width": 1500, "height": 1000, "timestamp": 1559530296, "env": {"SHELL": "/bin/bash", "TERM": "xterm-256color"}}
',encoding='utf-8')) #这里是asciinema需要的文件头
            for data in datas:
                playindex += 0.4  #设置播放速度

                commitname = data['commitname']

                linestr = '[{}, "o", "{}"]
'.format(playindex,commitname) #把命令写入到asciiname文件里面（必须按照这种格式）
                # print(type(commitname),print(commitname))
                f.write(bytes(linestr,encoding='utf-8')) 以二进制格式写入
            # datalist.append(data['commitname'])
        # print(json.dumps(datalist))
        # return JsonResponse({
        #     'datas': json.dumps(datalist)
        # })
        player = 'ok'
        return render(request,'command/playbackcommend.html',locals()) 返回页面

前端网页：

在html中导入asciinema的js和css文件

<div class="row">
    {% if player %}
         <asciinema-player src="{% static 'image/demo/demo.json' %}" cols="260" rows="40"></asciinema-player>
    {% endif %}
</div>

这样就实现了webssh的命令回放功能