python第七十六天--堡垒机完成

堡垒机
windows ,linux 都通过测试
初始化说明：
    #进入根目录
    1、初始化表结构   #python3 bin/start.py syncdb
    2、创建堡垒机用户 #python3 bin/start.py create_users -f share/examples/new_user.yml
    3、创建分组       #python3 bin/start.py create_groups -f share/examples/new_groups.yml
    4、创建远程主机   #python3 bin/start.py create_hosts -f share/examples/new_hosts.yml
    5、创建远程主机用户（绑定堡垒机用户与分组）#python3 bin/start.py create_remoteusers -f share/examples/new_remoteusers.yml
    6、绑定远程主机与远程主机用户【远程绑定组合】（关联远程绑定组合与堡垒机用户、关联远程绑定组合与分组）
        #python3 bin/start.py create_bindhosts -f share/examples/new_bindhosts.yml
    7、登陆堡垒机    #python3 bin/start.py start_session  （示例用户： uge3 密码：uge3）
    8、查看用户日志      #python3 bin/start.py audit -n uge3


plj/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
|      |- - -__init__.py
|      |- - -start.py#启动
|
|- - -conf/#配置目录
|      |- - -__init__.py
|      |- - -action_registers.py#开始参数配置文件
|      |- - -settings.py#配置文件
|
|- - -modules/#主逻辑目录
|      |- - -__init__.py
|      |- - -actions.py#开始函数 帮助信息
|      |- - -db_conn.py#数据库连接配置
|      |- - -interactive.py#ssh命令重写
|      |- - -models.py#表结构 类
|      |- - -ssh_login.py#登陆远程主机调用
|      |- - -utils.py#工具函数
|      |- - -views.py#主要逻辑函数
|
|- - -REDMAE
|
|- - -share/#添加堡垒机用户\远程主机\分组\远程主机用户 目录
|      |- - -examples/#文件目录
|              |- - -new_bindhosts.yml/#远程主机用户与远程主机 组合表（组合表与 分组）（堡垒机用户与组合表） 创建 示例
|              |- - -new_groups.yml/#分组创建 示例（ 堡垒机用户与 分组）
|              |- - -new_hosts.yml/#远程主机创建 示例
|              |- - -new_remoteusers.yml/#远程主机用户创建 示例
|              |- - -new_user.yml/#堡垒机用户机创建 示例

plj/#程序目录
|- - -__init__.py
|- - -bin/#启动目录
|      |- - -__init__.py
|      |- - -start.py#启动

#!/usr/bin/env python
#_*_coding:utf-8_*_
#Python 
#17-7-14    下午6:22
#__author__='Administrator'

import os,sys

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

#print(BASE_DIR)
sys.path.append(BASE_DIR)#加入环境变量

if __name__ == '__main__':
    from modules.actions import excute_from_command_line
    excute_from_command_line(sys.argv)

|- - -conf/#配置目录
|      |- - -__init__.py
|      |- - -action_registers.py#开始参数配置文件

#_*_coding:utf-8_*_
import os,sys

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)#加入环境变量

from modules import views

'''
actions = {
    'start_session': views.start_session,#开始程序
    'stop': views.stop_server,#停止
    'syncdb': views.syncdb,#创建表结构
    'create_users': views.create_users,
    'create_groups': views.create_groups,
    'create_hosts': views.create_hosts,
    'create_bindhosts': views.create_bindhosts,
    'create_remoteusers': views.create_remoteusers,
}
'''
actions = {
    'audit':views.audit,#查看日志
    'start_session': views.start_session,#开始程序
    'stop': views.stop_server,#停止
    'syncdb': views.syncdb,#创建表结构
    'create_users': views.create_users,#创建堡垒机用户
    'create_groups': views.create_groups,#创建分组
    'create_hosts': views.create_hosts,#创建远程主机
    'create_remoteusers': views.create_remoteusers,# #创建远程主机用户
    'create_bindhosts': views.create_bindhosts,# 远程主机与远程主机用户 绑定  关联堡垒机用户与
    #'ass_bind_group': views.ass_bindhost_group,#远程主机与远程主机用户组合 与 分组


}

actionses = {
    'audit                  [查看日志]':views.audit,#查看日志
    'start_session          [开始程序]': views.start_session,#开始程序
    'stop                   [停止]': views.stop_server,#停止
    'syncdb                 [创建表结构]': views.syncdb,#创建表结构
    'create_users           [创建堡垒机用户]': views.create_users,#创建堡垒机用户
    'create_groups          [创建分组]': views.create_groups,#创建分组
    'create_hosts           [创建远程主机]': views.create_hosts,#创建远程主机
    'create_remoteusers     [创建远程主机用户]': views.create_remoteusers,# #创建远程主机用户
    'create_bindhosts       [绑定堡垒机用户与远程主机用户]': views.create_bindhosts,#绑定堡垒机用户与远程主机用户
    #'ass_bind_group         [绑定远程主机+远程主机用户组合与分组]': views.ass_bindhost_group,#远程主机与远程主机用户组合 与 分组


}

|      |- - -settings.py#配置文件

import os,sys

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

USER='root'#用户名
PASSWORD='root'#密码
HOST_IP='127.0.0.1'#数据库地址
PORT="3306"#数据库端口
DB='little_finger'#库名
DB_CONN ="mysql+pymysql://"+USER+":"+PASSWORD+"@"+HOST_IP+":"+PORT+"/"+DB+"?charset=utf8"#连接参数
#DB_CONN ="mysql+pymysql://root:root@localhost:3306/"+DB+"?charset=utf8"#连接参数

|- - -modules/#主逻辑目录
|      |- - -__init__.py
|      |- - -actions.py#开始函数 帮助信息

#!/usr/bin/env python
#_*_coding:utf-8_*_
#Python 
#17-7-14    下午6:25
#__author__='Administrator'
import os,sys

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)#加入环境变量

from conf import settings
from conf import action_registers
from modules import utils


def help_msg():#帮助信息
    '''
    print help msgs
    :return:
    '''
    print("\033[31;1mAvailable commands:\033[0m")
    for key in action_registers.actionses:#打印配置文件中的帮助信息
        print("\t",key)


def excute_from_command_line(argvs):#接收输入的命令
    if len(argvs) < 2: #如果小于两个词
        help_msg()#打印帮助信息
        exit()
    if argvs[1] not in action_registers.actions:
        utils.print_err("Command [%s] does not exist!" % argvs[1], quit=True)
    action_registers.actions[argvs[1]](argvs[1:])#获取到命令

|      |- - -db_conn.py#数据库连接配置

from sqlalchemy import create_engine,Table
from  sqlalchemy.orm import sessionmaker

from conf import settings


#engine = create_engine(settings.DB_CONN)
engine = create_engine(settings.DB_CONN,echo=True)#数据库连接通道

SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = SessionCls()

|      |- - -interactive.py#ssh命令重写

import socket
import sys
from paramiko.py3compat import u
from  modules import models
import datetime

# windows does not have termios...
try:
    import termios
    import tty
    has_termios = True
except ImportError:
    has_termios = False

#记录日志相关              堡垒机用户 连接主机    命令       写入日志
def interactive_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording):
    if has_termios:
        posix_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording)
    else:
        windows_shell(chan)


def posix_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording):
    import select
    
    oldtty = termios.tcgetattr(sys.stdin)
    try:
        tty.setraw(sys.stdin.fileno())
        tty.setcbreak(sys.stdin.fileno())
        chan.settimeout(0.0)
        cmd = ''
        tab_key = False
        while True:
            r, w, e = select.select([chan, sys.stdin], [], [])#select 连接传入命令返回 三个变量
            if chan in r:#如果命令存在
                try:
                    x = u(chan.recv(1024))#连接返回数据
                    if tab_key:
                        if x not in ('\x07' , '\r\n'): #判断空格 和回车
                            #print('tab:',x)
                            cmd += x
                        tab_key = False
                    if len(x) == 0:
                        sys.stdout.write('\r\n*** EOF\r\n')
                        break
                    sys.stdout.write(x)
                    sys.stdout.flush()#实时输出到屏幕
                except socket.timeout:
                    pass
            if sys.stdin in r:
                x = sys.stdin.read(1)
                if '\r' != x:
                    cmd +=x
                else:

                    print('cmd->:',cmd)#命令
                    log_item = models.AuditLog(user_id=user_obj.id,
                                          bind_host_id=bind_host_obj.id,
                                          action_type='cmd',
                                          cmd=cmd ,
                                          date=datetime.datetime.now()
                                          )
                    cmd_caches.append(log_item)#添加到列表
                    cmd = ''

                    if len(cmd_caches)>=10:#每十条写入日志
                        log_recording(user_obj,bind_host_obj,cmd_caches)
                        cmd_caches = []
                if '\t' == x:
                    tab_key = True
                if len(x) == 0:
                    break
                chan.send(x)#发送命令

    finally:
        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)

    
# thanks to Mike Looijmans for this code
def windows_shell(chan):
    import threading

    sys.stdout.write("Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n")
        
    def writeall(sock):
        while True:
            data = sock.recv(256)
            if not data:
                sys.stdout.write('\r\n*** EOF ***\r\n\r\n')
                sys.stdout.flush()
                break
            sys.stdout.write(data.decode())##windows下要转成str
            sys.stdout.flush()#实时输出到屏幕
        
    writer = threading.Thread(target=writeall, args=(chan,))
    writer.start()
        
    try:
        while True:
            d = sys.stdin.read(1)
            if not d:
                break
            chan.send(d)
    except EOFError:
        # user hit ^Z or F6
        pass

|      |- - -models.py#表结构 类

#!/usr/bin/env python
#_*_coding:utf-8_*_
#Python 
#17-7-12    上午10:54
#__author__='Administrator'

# 创建表
import os ,sys
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取相对路径转为绝对路径赋于变量
sys.path.append(BASE_DIR)#增加环境变量
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,Table,DATE,DateTime
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy import func #统计
from sqlalchemy_utils import ChoiceType,PasswordType #
from  conf import settings
Base = declarative_base()#生成orm 基类

# #创建堡垒机用户关联－－联合表,自动维护
user_profile_m2m_bind_host = Table('user_profile_m2m_bind_host', Base.metadata,
                        Column('user_profile_id',Integer,ForeignKey('user_profile.id')),#关联,用户id
                        Column('bind_host_id',Integer,ForeignKey('bind_host.id')),#关联,联合表id
                        )
# #创建联合表－－分组,自动维护
bind_host_m2m_host_group = Table('bind_host_m2m_host_group', Base.metadata,
                        Column('bind_host_id',Integer,ForeignKey('bind_host.id')),#关联,联合表id
                        Column('host_group_id',Integer,ForeignKey('host_group.id')),#关联,分组id
                        )
# #创建堡垒机用户－－分组,自动维护
user_profile_m2m_host_group = Table('user_profile_m2m_host_group', Base.metadata,
                        Column('user_profile_id',Integer,ForeignKey('user_profile.id')),#关联,堡垒机用户id
                        Column('host_group_id',Integer,ForeignKey('host_group.id')),#关联,分组id
                        )
#主机表
class Host(Base):#主机表
    __tablename__='host'
    id=Column(Integer,primary_key=True)
    hostname=Column(String(64),unique=True)#主机名
    ip=Column(String(64),unique=True)#ip
    port=Column(Integer,default=22)#端口默认为22
    def __repr__(self):
        return self.hostname#输出主机名

#服务器远程主机用户名密码
class RemoteUser(Base):
    __tablename__='remote_user'

    id=Column(Integer,primary_key=True)
    AuthType=[
        ('ssh-passwd','SSH-Password'),
        ('ssh-key','SSH-Key'),
    ]
    auth_type=Column(ChoiceType(AuthType))#认证类型
    username=Column(String(64))#用户名 不用唯一
    password=Column(String(64))
    __table_args__=(UniqueConstraint('auth_type','username','password',name='user_password_type'),)#联合只唯一
    def __repr__(self):
        return self.username#用户名

#绑定远程主机-远程用户关联表
class BindHost(Base):
    __tablename__='bind_host'
    __table_args__=(UniqueConstraint('host_id',"remote_user_id",name='host_id_remote'),)#联合唯一
    id=Column(Integer,primary_key=True)
    host_id=Column(Integer,ForeignKey('host.id'))#外键－－〉主机表
    remote_user_id=Column(Integer,ForeignKey('remote_user.id'))#外键－－〉主机用户表
    host=relationship('Host',backref='bind_hosts')#外键  主机表 查询与反查
    remote_user=relationship('RemoteUser',backref='bind_hosts')#外键 用户表 查询与反查
    def __repr__(self):
        return '[主机：%s----->登陆用户：%s]'%(self.host.ip,self.remote_user.username)#


#主机分组
class HostGroup(Base):
    __tablename__='host_group'
    id=Column(Integer,primary_key=True)
    group_name=Column(String(64),unique=True)#主机分组名
    bind_host=relationship('BindHost',secondary=bind_host_m2m_host_group,backref='host_groups')#分组表 远程联合表 查询与反查
    def __repr__(self):
        return self.group_name#输出主机名

#堡垒机用户,
class UserProfile(Base):
    __tablename__='user_profile'
    id=Column(Integer,primary_key=True)
    username=Column(String(64),unique=True)#用户名
    password=Column(String(256))
    bind_hosts = relationship('BindHost',secondary=user_profile_m2m_bind_host,backref='user_profiles')#调用关联绑定表查看 堡垒机用户名
    host_group = relationship('HostGroup',secondary=user_profile_m2m_host_group,backref='user_profiles')#调用关联 分组查看 堡垒机用户名
    #audit_logs = relationship('AuditLog')#查日志
    def __repr__(self):
        return self.username#用户名

#日志类
class AuditLog(Base):
    __tablename__ = 'audit_log'
    id = Column(Integer,primary_key=True)
    user_id = Column(Integer,ForeignKey('user_profile.id'))#外键  堡垒机用户ID
    bind_host_id = Column(Integer,ForeignKey('bind_host.id'))#外键  远程主机ID
    action_choices = [
        (u'cmd',u'CMD'),#命令
        (u'login',u'Login'),#登陆
        (u'logout',u'Logout'),#退出
    ]
    action_type = Column(ChoiceType(action_choices))#日志类型
    cmd = Column(String(255))#命令
    date = Column(DateTime)#日期时间
    user_profile = relationship("UserProfile",backref='audit_logs')#关联堡垒机用户  查询
    bind_host = relationship("BindHost",backref='audit_logs')#关联远程主机   查询

|      |- - -ssh_login.py#登陆远程主机调用

#!usr/bin/env python
#-*-coding:utf-8-*-
# Author calmyan 
#python 
#2017/7/15    19:44
#__author__='Administrator'


import base64
import getpass
import os
import socket
import sys
import traceback
from paramiko.py3compat import input
from  modules import models
import datetime

import paramiko
try:
    import interactive
except ImportError:
    from . import interactive

#登陆远程主机
def ssh_login(user_obj,bind_host_obj,mysql_engine,log_recording):#ssh进入远程主机
    # now, connect and use paramiko Client to negotiate SSH2 across the connection
    try:
        client = paramiko.SSHClient()
        client.load_system_host_keys()
        client.set_missing_host_key_policy(paramiko.WarningPolicy())
        print('*** Connecting...')#开始连接
        #client.connect(hostname, port, username, password)
        client.connect(bind_host_obj.host.ip,
                       bind_host_obj.host.port,
                       bind_host_obj.remote_user.username,
                       bind_host_obj.remote_user.password,
                       timeout=30)#超时30秒

        cmd_caches = []#定义一个列表,暂时保存命令
        chan = client.invoke_shell()
        print(repr(client.get_transport()))
        print('*** Here we go!\n')
        cmd_caches.append(models.AuditLog(user_id=user_obj.id,
                                          bind_host_id=bind_host_obj.id,
                                          action_type='login',
                                          date=datetime.datetime.now()
                                          ))
        log_recording(user_obj,bind_host_obj,cmd_caches)
        interactive.interactive_shell(chan,user_obj,bind_host_obj,cmd_caches,log_recording)#传入 堡垒机用户, 连接远程主机 命令 记当日志函数
        chan.close()
        client.close()

    except Exception as e:
        print('*** Caught exception: %s: %s' % (e.__class__, e))
        traceback.print_exc()
        try:
            client.close()
        except:
            pass
        sys.exit(1)

|      |- - -utils.py#工具函数

from conf import settings
import yaml
try:
    from yaml import CLoader as Loader, CDumper as Dumper
except ImportError:
    from yaml import Loader, Dumper

def print_err(msg,quit=False):#错误提示输出
    output = "\033[31;1mError: %s\033[0m" % msg
    if quit:
        exit(output)
    else:
        print(output)


def yaml_parser(yml_filename):
    '''
    load yaml file and return
    :param yml_filename:
    :return:
    '''
    #yml_filename = "%s/%s.yml" % (settings.StateFileBaseDir,yml_filename)
    try:
        yaml_file = open(yml_filename,'r')#打开文件
        data = yaml.load(yaml_file)#load 成一个对象
        return data#返回数据
    except Exception as e:
        print_err(e)

|      |- - -views.py#主要逻辑函数

#_*_coding:utf-8_*_
import os,sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)#加入环境变量
from modules import models
from modules.db_conn import engine,session
from modules.utils import print_err,yaml_parser
#from modules import common_filt
from modules import ssh_login
from sqlalchemy import create_engine,Table
from  sqlalchemy.orm import sessionmaker

from conf import settings

#用户登陆函数
def auth():
    '''
    do the user login authentication
    :return:
    '''
    count = 0
    while count <3:#用户输入三次机会
        username = input("\033[32;1mUsername:\033[0m").strip()
        if len(username) ==0:continue
        password = input("\033[32;1mPassword:\033[0m").strip()
        if len(password) ==0:continue
        user_obj = session.query(models.UserProfile).filter(models.UserProfile.username==username,
                                                            models.UserProfile.password==password).first()#从数据库中获取堡垒机用户信息
        if user_obj:
            return user_obj
        else:
            print("wrong username or password, you have %s more chances." %(3-count-1))
            count +=1
    else:
        print_err("too many attempts.")


#欢迎界面
def welcome_msg(user):
    WELCOME_MSG = '''\033[32;1m
    ------------- Welcome [%s] login LittleFinger -------------
    \033[0m'''%  user.username
    print(WELCOME_MSG)


#写入数据库 日志
def log_recording(user_obj,bind_host_obj,logs):
    '''
    flush user operations on remote host into DB
    :param user_obj:
    :param bind_host_obj:
    :param logs: list format [logItem1,logItem2,...]
    :return:
    '''
    print("\033[41;1m--logs:\033[0m",logs)
    session.add_all(logs)
    session.commit()

#开始函数
def start_session(argvs):
    print('going to start sesssion ')
    user = auth()#判断用户名 并返回用户对应信息
    if user:
        welcome_msg(user)#打印欢迎界面
        #print(user.id)#用户ID
        #print(user.bind_hosts)#绑定主机
        #print(user.host_group)#所在组
        #log_recording(user,user.bind_hosts,user.host_group,logs)
        exit_flag = False#设定点 为假
        while not exit_flag:#如果设定点 为假 说明登陆成功
            if user.bind_hosts:#有绑定远程主机 打印远程主机
                print('\033[32;1mz.\tungroupped hosts (%s)\033[0m' %len(user.bind_hosts) )
            for index,group in enumerate(user.host_group):#打印当前用户所在组
                print('\033[32;1m%s.\t%s (%s)\033[0m' %(index,group.group_name,  len(group.bind_host)) )

            print('(q)=quit')
            choice = input("[%s]:" % user.username).strip()#开始获取输入的命令

            if len(choice) == 0:continue#如果没有输入跳过
            if choice == 'q':
                exit_flag=True
            #if choice=='exit': exit()#退出
            if choice == 'z':#如果输入 z
                print("------ Group: ungroupped hosts ------" )#输出所有的未分组的主机
                for index,bind_host in enumerate(user.bind_hosts):
                    print("  %s.\t%s@%s(%s)"%(index,
                                              bind_host.remote_user.username,#绑定的用户名
                                              bind_host.host.hostname,#主机名
                                              bind_host.host.ip,#IP地址
                                              ))
                print("----------- END -----------" )
            elif choice.isdigit():#如果是选择数字
                choice = int(choice)
                if choice < len(user.host_group):
                    print("------ Group: %s ------"  % user.host_group[choice].group_name )
                    for index,bind_host in enumerate(user.host_group[choice].bind_host):#打印出选择组的包括的
                        print("  %s.\t%s@%s(%s)"%(index,
                                                  bind_host.remote_user.username,#绑定的用户名
                                                  bind_host.host.hostname,#主机名
                                                  bind_host.host.ip,#IP地址
                                                  ))
                    print("----------- END -----------" )

                    #host selection
                    while not exit_flag:
                        user_option = input("[(b)back, (q)quit, select host to login]:").strip()
                        if len(user_option)==0:continue
                        if user_option == 'b':break
                        if user_option == 'q':
                            exit_flag=True
                        if user_option.isdigit():
                            user_option = int(user_option)
                            if user_option < len(user.host_group[choice].bind_host) :#查看分组所绑定的远程 主机
                                print('host:',user.host_group[choice].bind_host[user_option])
                                print('audit log:',user.host_group[choice].bind_host[user_option].audit_logs)
                                ssh_login.ssh_login(user,
                                                    user.host_group[choice].bind_host[user_option],
                                                    session,
                                                    log_recording)
                else:
                    print("no this option..")

#停止退出
def stop_server(argvs):
    exit()

#创建表结构
def syncdb(argvs):
    print("Syncing DB....[创建所有表结构]")
    models.Base.metadata.create_all(engine) #创建所有表结构

'''======创建四个基础表====  '''
#堡垒机用户添加
def create_users(argvs):
    if '-f' in argvs:#判断参数 -f 是否存在
        user_file  = argvs[argvs.index("-f") +1 ]#获取文件位置
    else:
        print_err("invalid usage, should be:\ncreateusers -f <the new users file>",quit=True)
    source = yaml_parser(user_file)#获取文件内容数据
    if source:#如果获取成功
        for key,val in source.items():
            print(key,val)
            obj = models.UserProfile(username=key,password=val.get('password'))#创建新数据
            session.add(obj)
        session.commit()

#分组添加
def create_groups(argvs):
    if '-f' in argvs:#判断参数 -f 是否存在
        group_file  = argvs[argvs.index("-f") +1 ]
    else:
        print_err("invalid usage, should be:\ncreategroups -f <the new groups file>",quit=True)
    source = yaml_parser(group_file)#通过yaml 获取文件中的数据,
    if source:
        for key,val in source.items():
            print(key,val)
            obj = models.HostGroup(group_name=key)#创建一条新数据
            if val.get('bind_hosts'):#
                bind_hosts = bind_hosts_filter(val)#绑定的远程主机组合表
                obj.bind_host = bind_hosts
            if val.get('user_profiles'):#堡垒机用户
                user_profiles = user_profiles_filter(val)#堡垒机用户
                obj.user_profiles = user_profiles
            session.add(obj)
        session.commit()

#远程主机添加
def create_hosts(argvs):
    if '-f' in argvs:#判断参数 -f 是否存在
        hosts_file  = argvs[argvs.index("-f") +1 ]
    else:
        print_err("invalid usage, should be:\ncreate_hosts -f <the new hosts file>",quit=True)#退出函数
    source = yaml_parser(hosts_file)#通过yaml 获取文件中的数据,
    if source:#如果获取成功,不为空
        for key,val in source.items():#进行数据的解析
            print(key)
            print(val)
            obj = models.Host(hostname=key,ip=val.get('ip'), port=val.get('port') or 22)#port 端口默认为22
            session.add(obj)#写入到数据库
        session.commit()#关闭 确认写入

#创建远程主机用户
def create_remoteusers(argvs):
    if '-f' in argvs:
        remoteusers_file  = argvs[argvs.index("-f") +1 ]
    else:
        print_err("invalid usage, should be:\ncreate_remoteusers -f <the new remoteusers file>",quit=True)
    source = yaml_parser(remoteusers_file)#通过yaml 获取文件中的数据,
    if source:
        for key,val in source.items():#进行数据的解析
            print(key,val)
            obj = models.RemoteUser(username=val.get('username'),auth_type=val.get('auth_type'),password=val.get('password'))
            session.add(obj)#写入数据库
        session.commit()


'''====远程主机与远程主机用户组合表====='''
##远程主机用户名密码与远程主机组合绑定   关联 到堡垒机用户
def create_bindhosts(argvs):
    if '-f' in argvs:
        bindhosts_file  = argvs[argvs.index("-f") +1 ]
    else:
        print_err("invalid usage, should be:\ncreate_hosts -f <the new bindhosts file>",quit=True)
    source = yaml_parser(bindhosts_file)#通过yaml 获取文件中的数据,
    if source:
        for key,val in source.items():
            print(key,val)
            host_obj = session.query(models.Host).filter(models.Host.hostname==val.get('hostname')).first()#获取对应主机数据
            assert host_obj#断言 当前主机一定要存在才能往下执行
            for item in val['remote_users']:#输出存在的远程主机用户
                print(item )
                assert item.get('auth_type')#断言 一定要存在才能往下执行
                if item.get('auth_type') == 'ssh-passwd':#判断ssh连接类型 从数据库选出合条件的数据
                    remoteuser_obj = session.query(models.RemoteUser).filter(
                                                        models.RemoteUser.username==item.get('username'),
                                                        models.RemoteUser.password==item.get('password')
                                                    ).first()#获取主机数据 返回对象
                else:
                    remoteuser_obj = session.query(models.RemoteUser).filter(
                                                        models.RemoteUser.username==item.get('username'),
                                                        models.RemoteUser.auth_type==item.get('auth_type'),
                                                    ).first()
                if not remoteuser_obj:#如果远程主机用户不存在
                    print_err("RemoteUser obj %s does not exist." % item,quit=True )
                bindhost_obj = models.BindHost(host_id=host_obj.id,remote_user_id=remoteuser_obj.id)#创建一条新数据
                session.add(bindhost_obj)
                #for groups this host binds to
                if source[key].get('groups'):#如果有分组标志
                    #获取分组信息
                    group_objs = session.query(models.HostGroup).filter(models.HostGroup.group_name.in_(source[key].get('groups') )).all()
                    assert group_objs#断言  分组一定要存在才能往下执行
                    print('groups:', group_objs)
                    bindhost_obj.host_groups = group_objs#主机加到分组
                #for user_profiles this host binds to
                if source[key].get('user_profiles'):#如果有堡垒机用户标志
                    #获取堡垒机用信息
                    userprofile_objs = session.query(models.UserProfile).filter(models.UserProfile.username.in_(
                        source[key].get('user_profiles')
                    )).all()
                    assert userprofile_objs#断言 堡垒机用户一定要存在才能往下执行
                    print("userprofiles:",userprofile_objs)
                    bindhost_obj.user_profiles = userprofile_objs#主机与堡垒机用户绑定
                #print(bindhost_obj)
        session.commit()


#远程主机组合表查看
def bind_hosts_filter(vals):#远程主机组合表查看
    print('**>',vals.get('bind_hosts') )
    bind_hosts = session.query(models.BindHost).filter(models.Host.hostname.in_(vals.get('bind_hosts'))).all()
    if not bind_hosts:
        print_err("none of [%s] exist in bind_host table." % vals.get('bind_hosts'),quit=True)
    return bind_hosts

#堡垒机用户查看
def user_profiles_filter(vals):
    user_profiles = session.query(models.UserProfile).filter(models.UserProfile.username.in_(vals.get('user_profiles'))).all()
    if not user_profiles:
        print_err("none of [%s] exist in user_profile table." % vals.get('user_profiles'),quit=True)
    return  user_profiles



#查看用户日志
def audit(argvs):
    if '-n' in argvs:
        user_name  = argvs[argvs.index("-n") +1 ]#获取要查看的用户名
    else:
        print_err("invalid usage, should be:\n输入参数 -n <用户名/user_name >",quit=True)
    print(user_name)
    user_obj = session.query(models.UserProfile).filter(models.UserProfile.username==user_name).first()#取到
    print(user_obj.id)
    log_obj = session.query(models.AuditLog).filter(models.AuditLog.user_id==user_obj.id).all()
    for i in log_obj:
        print('堡垒机用户：【%s】,远程主机【%s】,远程用户：【%s】命令：【%s】,日期：【%s】'%(i.user_profile,i.bind_host.host,i.bind_host.remote_user,i.cmd,i.date))
    input('========')

 

|- - -share/#添加堡垒机用户\远程主机\分组\远程主机用户 目录
|      |- - -examples/#文件目录
|              |- - -new_bindhosts.yml/#远程主机用户与远程主机 组合表（组合表与 分组）（堡垒机用户与组合表） 创建 示例

bind0:
  hostname: ubuntu test
  remote_users:
    - user0:
      username: root
      auth_type: ssh-passwd
      password: root
  groups:
    - test_group
  user_profiles:
    - uge3
    - alex


bind1:
  hostname: server1
  remote_users:
    - user1:
      username: root
      auth_type: ssh-key
      #password: 123
    - user0:
      username: root
      auth_type: ssh-passwd
      password: root
    - user4:
      username: calmyan
      auth_type: ssh-passwd
      password: yjj
  groups:
    - bj_group
  user_profiles:
    - uge3

bind2:
  hostname: server2
  remote_users:
    - user1:
      username: alex
      auth_type: ssh-passwd
      password: alex3714
  groups:
    - bj_group
    - sh_group
  user_profiles:
    - rain

|              |- - -new_groups.yml/#分组创建 示例（ 堡垒机用户与 分组）

bj_group:
  user_profiles:
    - alex
    - uge3

sh_group:
  user_profiles:
    - jack
    - alex
    - rain
    - uge3
test_group:
  user_profiles:
    - uge3

|              |- - -new_hosts.yml/#远程主机创建 示例

ubuntu test:
  ip: 192.168.11.50
  port: 22

server1:
  ip: 192.168.11.51


server2:
  ip: 10.4.4.22
  port: 30000

|              |- - -new_remoteusers.yml/#远程主机用户创建 示例

user0:
  auth_type:  ssh-passwd
  username: root
  password: root

user1:
  auth_type:  ssh-passwd
  username: root
  password: alex!34321

user2:
  auth_type:  ssh-key
  username: root
  #password: abc!23

user3:
  auth_type:  ssh-passwd
  username: alex
  password: alex3714

user4:
  auth_type:  ssh-passwd
  username: calmyan
  password: yjj

|              |- - -new_user.yml/#堡垒机用户机创建 示例

alex:
  password: alex123
uge3:
  password: uge3

jack:
  password: jack123

rain:
  password: rain123