Python之路_Day13

Python之路_Day13_课堂笔记

前期回顾

一、redis

发布订阅

二、rabbitMQ

原始队列

exchange

ex全部转发

ex，关键字

ex，模糊匹配

rpc

三、MySQL

四、Python MySQL

pymysql

excute    执行单条语句，返回受影响的行数

excutemany    执行多条语句，返回受影响的行数

fetchone

fetchall

fetchmany

scroll

lastrowid

五、SQLAlchemy

ORM框架

db first

code first

====> 我们以后通过类和对象操作数据库

code first

1、自定义生成表

2、使用类操作表

本节摘要

一、ORM

连表

一对多

多对多

二、Paramiko模块

链接：

堡垒机

三、前端

HTML

http://www.cnblogs.com/wupeiqi/articles/5699254.html

一、ORM—SQLAlchemy

连表

一对多

1、创建表，主动知道外键

2、操作：

类：repr

单表

连表

session.query(表1).join(表2).all()

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

    6. 

  6. from sqlalchemy import create_engine
    7. 

  7. from sqlalchemy.ext.declarative import declarative_base
    8. 

  8. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
    9. 

  9. from sqlalchemy.orm import sessionmaker, relationship
    10. 

  10. engine = create_engine("mysql+pymysql://root:[email protected]:3306/s13", max_overflow=5)
    11. 

    12. 

  12. Base = declarative_base()
    13. 

    14. 

  14. class Test(Base):
    15. 

  15.     __tablename__ = ‘test‘
    16. 

  16.     nid = Column(Integer,primary_key=True,autoincrement=True)
    17. 

  17.     name = Column(String(32))
    18. 

    19. 

  19. class Group(Base):
    20. 

  20.     __tablename__ = ‘group‘
    21. 

  21.     nid = Column(Integer,primary_key=True,autoincrement=True)
    22. 

  22.     caption = Column(String(32))
    23. 

    24. 

    25. 

  25. class User(Base):
    26. 

  26.     __tablename__ = ‘user‘
    27. 

  27.     nid = Column(Integer,primary_key=True,autoincrement=True)
    28. 

  28.     username = Column(String(32))
    29. 

  29.     group_id = Column(Integer,ForeignKey(‘group.nid‘))
    30. 

    31. 

  31.     def __repr__(self):
    32. 

  32.         temp = "%s - %s : %s" %(self.nid,self.username,self.group_id)
    33. 

  33.         return temp
    34. 

    35. 

    36. 

  36. def init_db():
    37. 

  37.     Base.metadata.create_all(engine)
    38. 

    39. 

  39. def drop_db():
    40. 

  40.     Base.metadata.drop_all(engine)
    41. 

    42. 

  42. # init_db()
    43. 

  43. Session = sessionmaker(bind=engine)
    44. 

  44. session = Session()
    45. 

    46. 

  46. # session.add(Group(caption=‘dba‘))
    47. 

  47. # session.add(Group(caption=‘ddd‘))
    48. 

  48. # session.commit()
    49. 

    50. 

  50. # session.add_all([
    51. 

  51. #     User(username=‘alex1‘,group_id=1),
    52. 

  52. #     User(username=‘alex2‘,group_id=2)
    53. 

  53. # ])
    54. 

  54. # session.commit()
    55. 

    56. 

  56. # 只是获取用户
    57. 

  57. # ret = session.query(User).filter(User.username == ‘alex1‘).all()
    58. 

  58. # print(ret)
    59. 

  59. # ret = session.query(User).all()
    60. 

  60. # obj = ret[0]
    61. 

  61. # print(ret)
    62. 

  62. # print(obj)
    63. 

  63. # print(obj.nid)
    64. 

  64. # print(obj.username)
    65. 

  65. # print(obj.group_id)
    66. 

    67. 

  67. # ret = session.query(User.username).all()
    68. 

  68. # print(ret)
    69. 

  69. sql = session.query(User,Group).join(Group, isouter=True)
    70. 

  70. print(sql)
    71. 

  71. ret = session.query(User,Group).join(Group, isouter=True).all()
    72. 

  72. print(ret)
    73. 

  73. # select * from user left join group on user.group_id = group.nid
    74.
正反向查找

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

    6. 

  6. from sqlalchemy import create_engine
    7. 

  7. from sqlalchemy.ext.declarative import declarative_base
    8. 

  8. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
    9. 

  9. from sqlalchemy.orm import sessionmaker, relationship
    10. 

  10. engine = create_engine("mysql+pymysql://root:[email protected]:3306/s13", max_overflow=5)
    11. 

    12. 

  12. Base = declarative_base()
    13. 

    14. 

  14. class Test(Base):
    15. 

  15.     __tablename__ = ‘test‘
    16. 

  16.     nid = Column(Integer,primary_key=True,autoincrement=True)
    17. 

  17.     name = Column(String(32))
    18. 

    19. 

  19. class Group(Base):
    20. 

  20.     __tablename__ = ‘group‘
    21. 

  21.     nid = Column(Integer,primary_key=True,autoincrement=True)
    22. 

  22.     caption = Column(String(32))
    23. 

    24. 

    25. 

  25. class User(Base):
    26. 

  26.     __tablename__ = ‘user‘
    27. 

  27.     nid = Column(Integer,primary_key=True,autoincrement=True)
    28. 

  28.     username = Column(String(32))
    29. 

  29.     group_id = Column(Integer,ForeignKey(‘group.nid‘))
    30. 

  30.     group = relationship(‘Group‘,backref=‘uuu‘)
    31. 

    32. 

  32.     def __repr__(self):
    33. 

  33.         temp = "%s - %s : %s" %(self.nid,self.username,self.group_id)
    34. 

  34.         return temp
    35. 

    36. 

    37. 

  37. def init_db():
    38. 

  38.     Base.metadata.create_all(engine)
    39. 

    40. 

  40. def drop_db():
    41. 

  41.     Base.metadata.drop_all(engine)
    42. 

    43. 

  43. # init_db()
    44. 

  44. Session = sessionmaker(bind=engine)
    45. 

  45. session = Session()
    46. 

    47. 

  47. # session.add(Group(caption=‘dba‘))
    48. 

  48. # session.add(Group(caption=‘ddd‘))
    49. 

  49. # session.commit()
    50. 

    51. 

  51. # session.add_all([
    52. 

  52. #     User(username=‘alex1‘,group_id=1),
    53. 

  53. #     User(username=‘alex2‘,group_id=2)
    54. 

  54. # ])
    55. 

  55. # session.commit()
    56. 

    57. 

  57. # 只是获取用户
    58. 

  58. # ret = session.query(User).filter(User.username == ‘alex1‘).all()
    59. 

  59. # print(ret)
    60. 

  60. # ret = session.query(User).all()
    61. 

  61. # obj = ret[0]
    62. 

  62. # print(ret)
    63. 

  63. # print(obj)
    64. 

  64. # print(obj.nid)
    65. 

  65. # print(obj.username)
    66. 

  66. # print(obj.group_id)
    67. 

    68. 

  68. # ret = session.query(User.username).all()
    69. 

  69. # print(ret)
    70. 

  70. # sql = session.query(User,Group).join(Group, isouter=True)
    71. 

  71. # print(sql)
    72. 

  72. # ret = session.query(User,Group).join(Group, isouter=True).all()
    73. 

  73. # print(ret)
    74. 

  74. # select * from user left join group on user.group_id = group.nid
    75. 

    76. 

  76. # 原始方式
    77. 

  77. # ret = session.query(User.username,Group.caption).join(Group, isouter=True).all()
    78. 

    79. 

  79. # 新方式（正向查询）
    80. 

  80. # ret = session.query(User).all()
    81. 

  81. # for obj in ret:
    82. 

  82.     # obj代指user表的每一行数据
    83. 

  83.     # obj.group代指group对象
    84. 

  84.     # print(obj.nid,obj.username,obj.group_id,obj.group,obj.group.nid,obj.group.caption)
    85. 

    86. 

    87. 

  87. # 原始方式
    88. 

  88. # ret = session.query(User.username,Group.caption).join(Group,isouter=True).filter(Group.caption == ‘DBA‘).all()
    89. 

    90. 

    91. 

  91. # 新方式（反向查询）
    92. 

  92. # obj = session.query(Group).filter(Group.caption == ‘DBA‘).first()
    93. 

  93. # print(obj.nid)
    94. 

  94. # print(obj.caption)
    95. 

  95. # print(obj.uuu)
    96.

多对多：

1、创建表——额外的关系表

2、filter()

==

in_(都可以是另外一个查询)

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

    6. 

  6. from sqlalchemy import create_engine
    7. 

  7. from sqlalchemy.ext.declarative import declarative_base
    8. 

  8. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
    9. 

  9. from sqlalchemy.orm import sessionmaker, relationship
    10. 

  10. engine = create_engine("mysql+pymysql://root:[email protected]:3306/s13", max_overflow=5)
    11. 

    12. 

  12. Base = declarative_base()
    13. 

    14. 

  14. ##############多对多######################
    15. 

    16. 

  16. class Host(Base):
    17. 

  17.     __tablename__ = ‘host‘
    18. 

  18.     nid = Column(Integer, primary_key=True,autoincrement=True)
    19. 

  19.     hostname = Column(String(32))
    20. 

  20.     port = Column(String(32))
    21. 

  21.     ip = Column(String(32))
    22. 

    23. 

  23. class HostUser(Base):
    24. 

  24.     __tablename__ = ‘host_user‘
    25. 

  25.     nid = Column(Integer, primary_key=True,autoincrement=True)
    26. 

  26.     username = Column(String(32))
    27. 

    28. 

  28. class HostToHostUser(Base):
    29. 

  29.     __tablename__ = ‘host_to_host_user‘
    30. 

  30.     nid = Column(Integer, primary_key=True,autoincrement=True)
    31. 

    32. 

  32.     host_id = Column(Integer,ForeignKey(‘host.nid‘))
    33. 

  33.     host_user_id = Column(Integer,ForeignKey(‘host_user.nid‘))
    34. 

    35. 

  35. def init_db():
    36. 

  36.     Base.metadata.create_all(engine)
    37. 

    38. 

  38. def drop_db():
    39. 

  39.     Base.metadata.drop_all(engine)
    40. 

    41. 

  41. # init_db() # 创建表
    42. 

    43. 

    44. 

  44. Session = sessionmaker(bind=engine)
    45. 

  45. session = Session()
    46. 

    47. 

  47. # session.add_all([
    48. 

  48. #     Host(hostname=‘c1‘,port=‘22‘,ip=‘1.1.1.1‘),
    49. 

  49. #     Host(hostname=‘c2‘,port=‘22‘,ip=‘1.1.1.2‘),
    50. 

  50. #     Host(hostname=‘c3‘,port=‘22‘,ip=‘1.1.1.3‘),
    51. 

  51. #     Host(hostname=‘c4‘,port=‘22‘,ip=‘1.1.1.4‘),
    52. 

  52. #     Host(hostname=‘c5‘,port=‘22‘,ip=‘1.1.1.5‘),
    53. 

  53. # ])
    54. 

  54. # session.commit()
    55. 

    56. 

    57. 

  57. # session.add_all([
    58. 

  58. #     HostUser(username=‘root‘),
    59. 

  59. #     HostUser(username=‘db‘),
    60. 

  60. #     HostUser(username=‘nb‘),
    61. 

  61. #     HostUser(username=‘sb‘),
    62. 

  62. # ])
    63. 

  63. # session.commit()
    64. 

    65. 

  65. # session.add_all([
    66. 

  66. #     HostToHostUser(host_id=1,host_user_id=1),
    67. 

  67. #     HostToHostUser(host_id=1,host_user_id=2),
    68. 

  68. #     HostToHostUser(host_id=1,host_user_id=3),
    69. 

  69. #     HostToHostUser(host_id=2,host_user_id=2),
    70. 

  70. #     HostToHostUser(host_id=2,host_user_id=4),
    71. 

  71. #     HostToHostUser(host_id=2,host_user_id=3),
    72. 

  72. # ])
    73. 

  73. # session.commit()
    74. 

    75. 

  75. # 获取主机1中所有用户
    76. 

    77. 

  77. host_obj = session.query(Host).filter(Host.hostname == ‘c1‘).first()
    78. 

  78. # host_obj.nid
    79. 

    80. 

  80. host_2_host_user = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id == host_obj.nid).all()
    81. 

    82. 

  82. print(host_2_host_user)
    83. 

  83. r = zip(*host_2_host_user)
    84. 

  84. # print(list(r)[0])
    85. 

    86. 

  86. users = session.query(HostUser.username).filter(HostUser.nid.in_(list(r)[0])).all()
    87. 

  87. print(users)
    88.
3、relationship

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

    6. 

  6. from sqlalchemy import create_engine
    7. 

  7. from sqlalchemy.ext.declarative import declarative_base
    8. 

  8. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
    9. 

  9. from sqlalchemy.orm import sessionmaker, relationship
    10. 

  10. engine = create_engine("mysql+pymysql://root:[email protected]:3306/s13", max_overflow=5)
    11. 

    12. 

  12. Base = declarative_base()
    13. 

    14. 

    15. 

  15. ##############多对多######################
    16. 

    17. 

  17. class Host(Base):
    18. 

  18.     __tablename__ = ‘host‘
    19. 

  19.     nid = Column(Integer, primary_key=True,autoincrement=True)
    20. 

  20.     hostname = Column(String(32))
    21. 

  21.     port = Column(String(32))
    22. 

  22.     ip = Column(String(32))
    23. 

    24. 

  24. class HostUser(Base):
    25. 

  25.     __tablename__ = ‘host_user‘
    26. 

  26.     nid = Column(Integer, primary_key=True,autoincrement=True)
    27. 

  27.     username = Column(String(32))
    28. 

    29. 

  29. class HostToHostUser(Base):
    30. 

  30.     __tablename__ = ‘host_to_host_user‘
    31. 

  31.     nid = Column(Integer, primary_key=True,autoincrement=True)
    32. 

    33. 

  33.     host_id = Column(Integer,ForeignKey(‘host.nid‘))
    34. 

  34.     host_user_id = Column(Integer,ForeignKey(‘host_user.nid‘))
    35. 

    36. 

  36.     host = relationship(‘Host‘,backref = ‘h‘)
    37. 

  37.     host_user = relationship(‘HostUser‘,backref = ‘u‘)
    38. 

    39. 

  39. def init_db():
    40. 

  40.     Base.metadata.create_all(engine)
    41. 

    42. 

  42. def drop_db():
    43. 

  43.     Base.metadata.drop_all(engine)
    44. 

    45. 

  45. # init_db() # 创建表
    46. 

    47. 

    48. 

  48. Session = sessionmaker(bind=engine)
    49. 

  49. session = Session()
    50. 

    51. 

  51. # session.add_all([
    52. 

  52. #     Host(hostname=‘c1‘,port=‘22‘,ip=‘1.1.1.1‘),
    53. 

  53. #     Host(hostname=‘c2‘,port=‘22‘,ip=‘1.1.1.2‘),
    54. 

  54. #     Host(hostname=‘c3‘,port=‘22‘,ip=‘1.1.1.3‘),
    55. 

  55. #     Host(hostname=‘c4‘,port=‘22‘,ip=‘1.1.1.4‘),
    56. 

  56. #     Host(hostname=‘c5‘,port=‘22‘,ip=‘1.1.1.5‘),
    57. 

  57. # ])
    58. 

  58. #
    59. 

  59. #
    60. 

  60. # session.add_all([
    61. 

  61. #     HostUser(username=‘root‘),
    62. 

  62. #     HostUser(username=‘db‘),
    63. 

  63. #     HostUser(username=‘nb‘),
    64. 

  64. #     HostUser(username=‘sb‘),
    65. 

  65. # ])
    66. 

  66. #
    67. 

  67. # session.add_all([
    68. 

  68. #     HostToHostUser(host_id=1,host_user_id=1),
    69. 

  69. #     HostToHostUser(host_id=1,host_user_id=2),
    70. 

  70. #     HostToHostUser(host_id=1,host_user_id=3),
    71. 

  71. #     HostToHostUser(host_id=2,host_user_id=2),
    72. 

  72. #     HostToHostUser(host_id=2,host_user_id=4),
    73. 

  73. #     HostToHostUser(host_id=2,host_user_id=3),
    74. 

  74. # ])
    75. 

  75. # session.commit()
    76. 

    77. 

  77. # 获取主机1中所有用户
    78. 

    79. 

  79. # host_obj = session.query(Host).filter(Host.hostname == ‘c1‘).first()
    80. 

  80. # host_obj.nid
    81. 

    82. 

  82. # host_2_host_user = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id == host_obj.nid).all()
    83. 

    84. 

  84. # print(host_2_host_user)
    85. 

  85. # r = zip(*host_2_host_user)
    86. 

  86. # print(list(r)[0])
    87. 

    88. 

  88. # users = session.query(HostUser.username).filter(HostUser.nid.in_(list(r)[0])).all()
    89. 

  89. # print(users)
    90. 

    91. 

  91. host_obj = session.query(Host).filter(Host.hostname == ‘c1‘).first()
    92. 

  92. for item in host_obj.h:
    93. 

  93.     print(item.host_user.username)
    94.
4、更简单的方式

A    关系(B，AB Table对象)

AB == > fk

B

操作时，简单

SQLAlchemy总结：

1、创建表

2、操作表

单表操作

连表操作

.join

关系：

一对多

fk，关系

多对多

多一张表，fk

1、关系表：关系

2、在某一张表：关系；A：关系，（B，AB）


二、Paramiko模块

使用Paramiko模块连接远程服务器并执行命令：

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

  5. # paramiko模块
    6. 

    7. 

  7. import paramiko
    8. 

    9. 

    10. 

  10. # 普通连接远程主机并执行一条命令
    11. 

    12. 

  12. # 创建SSH对象
    13. 

  13. ssh = paramiko.SSHClient()
    14. 

  14. # 允许连接不在know_hosts文件中的主机
    15. 

  15. ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    16. 

  16. # 连接服务器
    17. 

  17. ssh.connect(hostname=‘192.168.111.2‘, port=22, username=‘root‘, password=‘111111‘)
    18. 

  18. # 执行命令
    19. 

  19. stdin, stdout, stderr = ssh.exec_command(‘ls -l‘)
    20. 

  20. # 获取命令结果
    21. 

  21. result = stdout.read()
    22. 

  22. print(result)
    23. 

  23. # 关闭连接
    24. 

  24. ssh.close()
    25.

通过Paramiko模块一次连接服务器实现执行命令，上传文件等多次操作：

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

  5. import paramiko
    6. 

  6. import uuid
    7. 

    8. 

  8. # 实现一次链接执行命令、上传文件、执行命令
    9. 

    10. 

  10. class SSHConnection(object):
    11. 

    12. 

  12.     def __init__(self, host=‘192.168.111.2‘, port=22, username=‘root‘,pwd=‘111111‘):
    13. 

  13.         self.host = host
    14. 

  14.         self.port = port
    15. 

  15.         self.username = username
    16. 

  16.         self.pwd = pwd
    17. 

  17.         self.__k = None
    18. 

    19. 

  19.     def run(self):
    20. 

  20.         self.connect()
    21. 

  21.         pass
    22. 

  22.         self.close()
    23. 

    24. 

  24.     def connect(self):
    25. 

  25.         transport = paramiko.Transport((self.host,self.port))
    26. 

  26.         transport.connect(username=self.username,password=self.pwd)
    27. 

  27.         self.__transport = transport
    28. 

    29. 

  29.     def close(self):
    30. 

  30.         self.__transport.close()
    31. 

    32. 

  32.     def cmd(self, command):
    33. 

  33.         ssh = paramiko.SSHClient()
    34. 

  34.         ssh._transport = self.__transport
    35. 

  35.         # 执行命令
    36. 

  36.         stdin, stdout, stderr = ssh.exec_command(command)
    37. 

  37.         # 获取命令结果
    38. 

  38.         result = stdout.read()
    39. 

  39.         return result
    40. 

    41. 

  41.     def upload(self,local_path, target_path):
    42. 

  42.         # 连接，上传
    43. 

  43.         sftp = paramiko.SFTPClient.from_transport(self.__transport)
    44. 

  44.         # 将location.py 上传至服务器 /tmp/test.py
    45. 

  45.         sftp.put(local_path, target_path)
    46. 

    47. 

  47. ssh = SSHConnection()
    48. 

  48. ssh.connect()
    49. 

    50. 

  50. r1 = ssh.cmd(‘df‘)
    51. 

  51. print(r1)
    52. 

    53. 

  53. ssh.upload(‘s1.py‘, "/root/s7.py")
    54. 

    55. 

  55. ssh.close()
    56.

堡垒机，通过回车确定输入内容，并返回结果

（一次输入一条命令返回结果，只可以在Linux上执行）：

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

  5. # 堡垒机，通过回车确定输入内容，并返回结果
    6. 

    7. 

  7. import paramiko
    8. 

  8. import sys
    9. 

  9. import os
    10. 

  10. import socket
    11. 

  11. import select
    12. 

  12. import getpass
    13. 

  13. from paramiko.py3compat import u
    14. 

    15. 

  15. tran = paramiko.Transport((‘192.168.111.2‘, 22,))
    16. 

  16. tran.start_client()
    17. 

  17. tran.auth_password(‘root‘, ‘111111‘)
    18. 

    19. 

  19. # 打开一个通道
    20. 

  20. chan = tran.open_session()
    21. 

  21. # 获取一个终端
    22. 

  22. chan.get_pty()
    23. 

  23. # 激活器
    24. 

  24. chan.invoke_shell()
    25. 

    26. 

  26. while True:
    27. 

  27.     # 监视用户输入和服务器返回数据
    28. 

  28.     # sys.stdin 处理用户输入
    29. 

  29.     # chan 是之前创建的通道，用于接收服务器返回信息
    30. 

  30.     readable, writeable, error = select.select([chan, sys.stdin, ], [], [], 1)
    31. 

  31.     if chan in readable:
    32. 

  32.         try:
    33. 

  33.             x = u(chan.recv(1024))
    34. 

  34.             if len(x) == 0:
    35. 

  35.                 print(‘\r\n*** EOF\r\n‘)
    36. 

  36.                 break
    37. 

  37.             sys.stdout.write(x)
    38. 

  38.             sys.stdout.flush()
    39. 

  39.         except socket.timeout:
    40. 

  40.             pass
    41. 

  41.     if sys.stdin in readable:
    42. 

  42.         inp = sys.stdin.readline()
    43. 

  43.         chan.sendall(inp)
    44. 

    45. 

  45. chan.close()
    46. 

  46. tran.close()
    47.

堡垒机，通过回车确定输入内容，并返回结果

（一次输入一个字符，可以通过tab补全，只可以在Linux上执行）：

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

  5. import paramiko
    6. 

  6. import sys
    7. 

  7. import os
    8. 

  8. import socket
    9. 

  9. import select
    10. 

  10. import getpass
    11. 

  11. import termios
    12. 

  12. import tty
    13. 

  13. from paramiko.py3compat import u
    14. 

    15. 

  15. tran = paramiko.Transport((‘192.168.111.2‘, 22,))
    16. 

  16. tran.start_client()
    17. 

  17. tran.auth_password(‘root‘, ‘111111‘)
    18. 

    19. 

  19. # 打开一个通道
    20. 

  20. chan = tran.open_session()
    21. 

  21. # 获取一个终端
    22. 

  22. chan.get_pty()
    23. 

  23. # 激活器
    24. 

  24. chan.invoke_shell()
    25. 

    26. 

  26. # 获取原tty属性
    27. 

  27. oldtty = termios.tcgetattr(sys.stdin)
    28. 

  28. try:
    29. 

  29.     # 为tty设置新属性
    30. 

  30.     # 默认当前tty设备属性：
    31. 

  31.     #   输入一行回车，执行
    32. 

  32.     #   CTRL+C 进程退出，遇到特殊字符，特殊处理。
    33. 

    34. 

  34.     # 这是为原始模式，不认识所有特殊符号
    35. 

  35.     # 放置特殊字符应用在当前终端，如此设置，将所有的用户输入均发送到远程服务器
    36. 

  36.     tty.setraw(sys.stdin.fileno())
    37. 

  37.     chan.settimeout(0.0)
    38. 

    39. 

  39.     while True:
    40. 

  40.         # 监视 用户输入 和 远程服务器返回数据（socket）
    41. 

  41.         # 阻塞，直到句柄可读
    42. 

  42.         r, w, e = select.select([chan, sys.stdin], [], [], 1)
    43. 

  43.         if chan in r:
    44. 

  44.             try:
    45. 

  45.                 x = u(chan.recv(1024))
    46. 

  46.                 if len(x) == 0:
    47. 

  47.                     print(‘\r\n*** EOF\r\n‘)
    48. 

  48.                     break
    49. 

  49.                 sys.stdout.write(x)
    50. 

  50.                 sys.stdout.flush()
    51. 

  51.             except socket.timeout:
    52. 

  52.                 pass
    53. 

  53.         if sys.stdin in r:
    54. 

  54.             x = sys.stdin.read(1)
    55. 

  55.             if len(x) == 0:
    56. 

  56.                 break
    57. 

  57.             chan.send(x)
    58. 

    59. 

  59. finally:
    60. 

  60.     # 重新设置终端属性
    61. 

  61.     termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
    62. 

    63. 

  63. chan.close()
    64. 

  64. tran.close()
    65.

堡垒机，通过回车确定输入内容，并返回结果

（终极版本，可以在windows和linux上执行）：

    

  1. #!/usr/bin/env python
    2. 

  2. # -.- coding:utf-8 -.-
    3. 

  3. # By Sandler
    4. 

    5. 

  5. import paramiko
    6. 

  6. import sys
    7. 

  7. import os
    8. 

  8. import socket
    9. 

  9. import getpass
    10. 

    11. 

  11. from paramiko.py3compat import u
    12. 

    13. 

  13. # windows does not have termios...
    14. 

  14. try:
    15. 

  15.     import termios
    16. 

  16.     import tty
    17. 

  17.     has_termios = True
    18. 

  18. except ImportError:
    19. 

  19.     has_termios = False
    20. 

    21. 

    22. 

  22. def interactive_shell(chan):
    23. 

  23.     if has_termios:
    24. 

  24.         posix_shell(chan)
    25. 

  25.     else:
    26. 

  26.         windows_shell(chan)
    27. 

    28. 

    29. 

  29. def posix_shell(chan):
    30. 

  30.     import select
    31. 

    32. 

  32.     oldtty = termios.tcgetattr(sys.stdin)
    33. 

  33.     try:
    34. 

  34.         tty.setraw(sys.stdin.fileno())
    35. 

  35.         tty.setcbreak(sys.stdin.fileno())
    36. 

  36.         chan.settimeout(0.0)
    37. 

  37.         log = open(‘handle.log‘, ‘a+‘, encoding=‘utf-8‘)
    38. 

  38.         flag = False
    39. 

  39.         temp_list = []
    40. 

  40.         while True:
    41. 

  41.             r, w, e = select.select([chan, sys.stdin], [], [])
    42. 

  42.             if chan in r:
    43. 

  43.                 try:
    44. 

  44.                     x = u(chan.recv(1024))
    45. 

  45.                     if len(x) == 0:
    46. 

  46.                         sys.stdout.write(‘\r\n*** EOF\r\n‘)
    47. 

  47.                         break
    48. 

  48.                     if flag:
    49. 

  49.                         if x.startswith(‘\r\n‘):
    50. 

  50.                             pass
    51. 

  51.                         else:
    52. 

  52.                             temp_list.append(x)
    53. 

  53.                         flag = False
    54. 

  54.                     sys.stdout.write(x)
    55. 

  55.                     sys.stdout.flush()
    56. 

  56.                 except socket.timeout:
    57. 

  57.                     pass
    58. 

  58.             if sys.stdin in r:
    59. 

  59.                 x = sys.stdin.read(1)
    60. 

  60.                 import json
    61. 

    62. 

  62.                 if len(x) == 0:
    63. 

  63.                     break
    64. 

    65. 

  65.                 if x == ‘\t‘:
    66. 

  66.                     flag = True
    67. 

  67.                 else:
    68. 

  68.                     temp_list.append(x)
    69. 

  69.                 if x == ‘\r‘:
    70. 

  70.                     log.write(‘‘.join(temp_list))
    71. 

  71.                     log.flush()
    72. 

  72.                     temp_list.clear()
    73. 

  73.                 chan.send(x)
    74. 

    75. 

  75.     finally:
    76. 

  76.         termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty)
    77. 

    78. 

    79. 

  79. def windows_shell(chan):
    80. 

  80.     import threading
    81. 

    82. 

  82.     sys.stdout.write("Line-buffered terminal emulation. Press F6 or ^Z to send EOF.\r\n\r\n")
    83. 

    84. 

  84.     def writeall(sock):
    85. 

  85.         while True:
    86. 

  86.             data = sock.recv(256)
    87. 

  87.             if not data:
    88. 

  88.                 sys.stdout.write(‘\r\n*** EOF ***\r\n\r\n‘)
    89. 

  89.                 sys.stdout.flush()
    90. 

  90.                 break
    91. 

  91.             sys.stdout.write(data)
    92. 

  92.             sys.stdout.flush()
    93. 

    94. 

  94.     writer = threading.Thread(target=writeall, args=(chan,))
    95. 

  95.     writer.start()
    96. 

    97. 

  97.     try:
    98. 

  98.         while True:
    99. 

  99.             d = sys.stdin.read(1)
    100. 

  100.             if not d:
    101. 

  101.                 break
    102. 

  102.             chan.send(d)
    103. 

  103.     except EOFError:
    104. 

  104.         # user hit ^Z or F6
    105. 

  105.         pass
    106. 

    107. 

    108. 

  108. def run():
    109. 

  109.     default_username = getpass.getuser()
    110. 

  110.     username = input(‘Username [%s]: ‘ % default_username)
    111. 

  111.     if len(username) == 0:
    112. 

  112.         username = default_username
    113. 

    114. 

    115. 

  115.     hostname = input(‘Hostname: ‘)
    116. 

  116.     if len(hostname) == 0:
    117. 

  117.         print(‘*** Hostname required.‘)
    118. 

  118.         sys.exit(1)
    119. 

    120. 

  120.     tran = paramiko.Transport((hostname, 22,))
    121. 

  121.     tran.start_client()
    122. 

    123. 

  123.     default_auth = "p"
    124. 

  124.     auth = input(‘Auth by (p)assword or (r)sa key[%s] ‘ % default_auth)
    125. 

  125.     if len(auth) == 0:
    126. 

  126.         auth = default_auth
    127. 

    128. 

  128.     if auth == ‘r‘:
    129. 

  129.         default_path = os.path.join(os.environ[‘HOME‘], ‘.ssh‘, ‘id_rsa‘)
    130. 

  130.         path = input(‘RSA key [%s]: ‘ % default_path)
    131. 

  131.         if len(path) == 0:
    132. 

  132.             path = default_path
    133. 

  133.         try:
    134. 

  134.             key = paramiko.RSAKey.from_private_key_file(path)
    135. 

  135.         except paramiko.PasswordRequiredException:
    136. 

  136.             password = getpass.getpass(‘RSA key password: ‘)
    137. 

  137.             key = paramiko.RSAKey.from_private_key_file(path, password)
    138. 

  138.         tran.auth_publickey(username, key)
    139. 

  139.     else:
    140. 

  140.         pw = getpass.getpass(‘Password for %[email protected]%s: ‘ % (username, hostname))
    141. 

  141.         tran.auth_password(username, pw)
    142. 

    143. 

  143.     # 打开一个通道
    144. 

  144.     chan = tran.open_session()
    145. 

  145.     # 获取一个终端
    146. 

  146.     chan.get_pty()
    147. 

  147.     # 激活器
    148. 

  148.     chan.invoke_shell()
    149. 

    150. 

  150.     interactive_shell(chan)
    151. 

    152. 

  152.     chan.close()
    153. 

  153.     tran.close()
    154. 

    155. 

    156. 

  156. if __name__ == ‘__main__‘:
    157. 

  157.     run()
    158.

链接：

堡垒机

来自为知笔记(Wiz)

时间： 2024-11-10 07:02:51

Python之路_Day13的相关文章

Python之路【第十七篇】：Django【进阶篇 】

Python之路[第十七篇]:Django[进阶篇 ] Model 到目前为止,当我们的程序涉及到数据库相关操作时,我们一般都会这么搞: 创建数据库,设计表结构和字段 使用 MySQLdb 来连接数据库,并编写数据访问层代码 业务逻辑层去调用数据访问层执行数据库操作 import MySQLdb def GetList(sql): db = MySQLdb.connect(user='root', db='wupeiqidb', passwd='1234', host='localhost')

Python之路【第九篇】：Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

Python之路[第九篇]:Python操作 RabbitMQ.Redis.Memcache.SQLAlchemy Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.Memcached基于一个存储键/值对的hashmap.其守护进程(daemon )是用C写的,但是客户端可以用任何语言来编写,并通过memcached协议与守护进程通信. Memc

七日Python之路--第十二天（Django Web 开发指南）

<Django Web 开发指南>.貌似使用Django1.0版本,基本内容差不多,细读无妨.地址:http://www.jb51.net/books/76079.html (一)第一部分 入门 (1)内置数字工厂函数 int(12.34)会创建一个新的值为12的整数对象,而float(12)则会返回12.0. (2)其他序列操作符 连接(+),复制(*),以及检查是否是成员(in, not in) '**'.join('**')   或  '***%s***%d' % (str, int)

七日Python之路--第九天

众所周知,代码这东西不是看出来的.程序这东西只哟一个标准. 下面找点开源的东西看看,学习一下大婶们的犀利编码...... 推荐一下: 虽然有点老了:http://www.iteye.com/topic/405150,还有就是GitHub上面搜索一下Django就能出来很多,当然还有OSChina.只是有个问题,就是Django版本不同,具体的内容可能会有些不同,但大概还是相同的.领略即可,然后书写自己的代码. 首要的还是官方文档. 看着还是有些难度的.偶然发现一个不错的Blog:http://w

Python之路【第三篇】：Python基础（二）

Python之路[第三篇]:Python基础(二) 内置函数 一 详细见python文档,猛击这里 文件操作 操作文件时,一般需要经历如下步骤: 打开文件 操作文件 一.打开文件 1 文件句柄 = file('文件路径', '模式') 注:python中打开文件有两种方式,即:open(...) 和  file(...) ,本质上前者在内部会调用后者来进行文件操作,推荐使用 open. 打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作.

Python之路【第二篇】：Python基础（一）

Python之路[第二篇]:Python基础(一) 入门知识拾遗 一.作用域 对于变量的作用域,执行声明并在内存中存在,该变量就可以在下面的代码中使用. 1 2 3 if 1==1:     name = 'wupeiqi' print  name 下面的结论对吗? 外层变量,可以被内层变量使用 内层变量,无法被外层变量使用 二.三元运算 1 result = 值1 if 条件 else 值2 如果条件为真:result = 值1如果条件为假:result = 值2 三.进制 二进制,01 八进

Python之路【第十九篇】：爬虫

Python之路[第十九篇]:爬虫 网络爬虫(又被称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的规则,自动地抓取万维网信息的程序或者脚本.另外一些不常使用的名字还有蚂蚁.自动索引.模拟程序或者蠕虫. Requests Python标准库中提供了:urllib.urllib2.httplib等模块以供Http请求,但是,它的 API 太渣了.它是为另一个时代.另一个互联网所创建的.它需要巨量的工作,甚至包括各种方法覆盖,来完成最简单的任务. import

Python之路【第七篇】：线程、进程和协程

Python之路[第七篇]:线程.进程和协程 Python线程 Threading用于提供线程相关的操作,线程是应用程序中工作的最小单元. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 #!/usr/bin/env python # -*- coding:utf-8 -*- import threading import time   def show(arg):     time.sleep(1)     print 'thread'+str(arg)   for i in

Python之路【第八篇】：堡垒机实例以及数据库操作

Python之路[第八篇]:堡垒机实例以及数据库操作 堡垒机前戏 开发堡垒机之前,先来学习Python的paramiko模块,该模块机遇SSH用于连接远程服务器并执行相关操作 SSHClient 用于连接远程服务器并执行基本命令 基于用户名密码连接: + import paramiko transport = paramiko.Transport(('hostname', 22)) transport.connect(username='wupeiqi', password='123') ssh