Lesson6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Socket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 打印设备名和 IPv4 地址"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket\n",
    "\n",
    "def print_machine_info():\n",
    "    host_name = socket.gethostname()\n",
    "    print host_name\n",
    "    #ip_address = socket.gethostbyname(host_name)\n",
    "    print \"Host name: %s\" % host_name\n",
    "    #print \"IP address: %s\" % ip_address\n",
    "    print socket.gethostbyname_ex(host_name)\n",
    "\n",
    "print_machine_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 获取远程设备的 IP 地址"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket\n",
    "\n",
    "def get_remote_machine_info():\n",
    "    remote_host = 'www.qq.com'\n",
    "    try:\n",
    "        print \"IP address: %s\" % socket.gethostbyname(remote_host)\n",
    "        print socket.gethostbyname_ex(remote_host)\n",
    "    except socket.error, err_msg:\n",
    "        print \"%s: %s\" % (remote_host, err_msg)\n",
    "\n",
    "get_remote_machine_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 通过指定的端口和协议找到服务名"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket\n",
    "\n",
    "def find_service_name():\n",
    "    protocolname = 'tcp'\n",
    "    for port in [80, 25]:\n",
    "        print \"Port: %s => service name: %s\" % (port, socket.getservbyport(port, protocolname))\n",
    "    print \"Port: %s => service name: %s\" % (53, socket.getservbyport(53, 'udp'))\n",
    "\n",
    "find_service_name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IP地址转换"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 将 IPv4 地址转换成不同的格式\n",
    "# socket.inet_aton()    将一个字符串 IP 地址转换为一个 32 位的网络序列IP地址\n",
    "# socket.inet_ntoa()    将一个十进制网络字节序转换为点分十进制 IP 格式的字符串\n",
    "\n",
    "import socket\n",
    "from binascii import hexlify\n",
    "\n",
    "def convert_ipv4_address():\n",
    "    for ip_addr in ['127.0.0.1', '192.168.0.1']:\n",
    "        packed_ip_addr = socket.inet_aton(ip_addr)\n",
    "        unpacked_ip_addr = socket.inet_ntoa(packed_ip_addr)\n",
    "        print \"IP address: %s => packed: %s, unpacked: %s\" % (ip_addr, hexlify(packed_ip_addr), unpacked_ip_addr)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    convert_ipv4_address()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NTP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# pip install ntplib\n",
    "import ntplib\n",
    "from time import ctime\n",
    "\n",
    "def print_time():\n",
    "    ntp_client = ntplib.NTPClient()\n",
    "    response = ntp_client.request('time.nist.gov')\n",
    "    print ctime(response.tx_time)\n",
    "\n",
    "print_time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Socket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 把套接字改成阻塞或非阻塞模式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 把套接字改成阻塞或非阻塞模式\n",
    "\n",
    "import socket\n",
    "\n",
    "def test_socket_modes():\n",
    "    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "\n",
    "    # 1    阻塞模式\n",
    "    # 0    非阻塞模式\n",
    "    s.setblocking(1)\n",
    "    \n",
    "    s.settimeout(0.5)\n",
    "    s.bind((\"127.0.0.1\", 0))\n",
    "\n",
    "    socket_address = s.getsockname()\n",
    "    print \"Trivial Server launched on socket: %s\" % str(socket_address)\n",
    "    while(1):\n",
    "        s.listen(1)\n",
    "\n",
    "test_socket_modes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Echo Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket\n",
    "import sys\n",
    "import argparse\n",
    "\n",
    "host = 'localhost'\n",
    "\n",
    "def echo_client(port):\n",
    "    \"\"\"A simple echo client\"\"\"\n",
    "    # Create a TCP socket\n",
    "    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "    # Connect the socket to the Server\n",
    "    server_address = (host, port)\n",
    "    print \"Connecting to %s port %s\" % server_address\n",
    "    sock.connect(server_address)\n",
    "\n",
    "    # Send data\n",
    "    try:\n",
    "        # Send data\n",
    "        # Test message. This will be echoed1111.\n",
    "        message = \"bye\"\n",
    "        print \"Sending: %s\" % message\n",
    "        sock.sendall(message)\n",
    "        # Look for the response\n",
    "        amount_received = 0\n",
    "        amount_expected = len(message)\n",
    "        while amount_received < amount_expected:\n",
    "            data = sock.recv(2048)\n",
    "            amount_received += len(data)\n",
    "            print \"Received: %s\" % data\n",
    "    except socket.error, e:\n",
    "        print \"Socket error: %s\" % str(e)\n",
    "    except Exception, e:\n",
    "        print \"Other exception: %s\" % str(e)\n",
    "    finally:\n",
    "        print \"Closing connection to the server\"\n",
    "        sock.close()\n",
    "echo_client(9999)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 文件传输"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket\n",
    "sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "server_address = ('localhost', 9999)\n",
    "print \"Connecting to %s port %s\" % server_address\n",
    "sock.connect(server_address)\n",
    "\n",
    "with open('data/ft_test_client.txt', 'r') as fp:\n",
    "    sock.sendall(fp.read())\n",
    "    print 'sending file'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TCPServer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from SocketServer import TCPServer, BaseRequestHandler \n",
    "class MyBaseRequestHandlerr(BaseRequestHandler):  \n",
    "    \"\"\" \n",
    "    #从BaseRequestHandler继承，并重写handle方法 \n",
    "    \"\"\"  \n",
    "    def handle(self):  \n",
    "        while True:  \n",
    "            try:  \n",
    "                data = self.request.recv(1024).strip()  \n",
    "                print \"receive from (%r):%r\" % (self.client_address, data)   \n",
    "                self.request.sendall(data.upper())  \n",
    "                if data == 'y':\n",
    "                    print 'server exit'\n",
    "                    break\n",
    "            except:  \n",
    "                break\n",
    "host = \"0.0.0.0\"\n",
    "port = 9997\n",
    "addr = (host, port)  \n",
    "server = TCPServer(addr, MyBaseRequestHandlerr) \n",
    "print 'server is started'\n",
    "server.serve_forever()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ThreadingMixIn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 在套接字服务器程序中使用 ThreadingMixIn\n",
    "\n",
    "import os\n",
    "import socket\n",
    "import threading\n",
    "import SocketServer\n",
    "\n",
    "SERVER_HOST = 'localhost'\n",
    "SERVER_PORT = 0    # Tells the kernel to pick up a port dynamically\n",
    "BUF_SIZE = 1024\n",
    "\n",
    "def client(ip, port, message):\n",
    "    \"\"\"A client to test threading mixin server\"\"\"\n",
    "    # Connect to the server\n",
    "    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "    sock.connect((ip, port))\n",
    "    try:\n",
    "        sock.sendall(message)\n",
    "        response = sock.recv(BUF_SIZE)\n",
    "        print \"Client received: %s\" % response\n",
    "    finally:\n",
    "        sock.close()\n",
    "\n",
    "class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):\n",
    "    \"\"\"A example of threaded TCP request handler\"\"\"\n",
    "    def handle(self):\n",
    "        data = self.request.recv(BUF_SIZE)\n",
    "        current_thread = threading.current_thread()\n",
    "        response = '%s: %s' % (current_thread.name, data)\n",
    "        # print \"Server sending response [current_thread name: data] = %s\" % response\n",
    "        self.request.send(response)\n",
    "\n",
    "class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):\n",
    "    \"\"\"Nothing to add here, inherited everything necessary from parents\"\"\"\n",
    "    pass\n",
    "\n",
    "def main():\n",
    "    # Launch the server\n",
    "    server = ThreadedTCPServer((SERVER_HOST, SERVER_PORT), ThreadedTCPRequestHandler)\n",
    "    ip, port = server.server_address    # Retrieve the port number\n",
    "    print ip, port, 'server'\n",
    "    # Start a thread with the server -- one thread per request\n",
    "    server_thread = threading.Thread(target=server.serve_forever)\n",
    "    # Exit the server thread when the main thread exits\n",
    "    server_thread.daemon = True\n",
    "    server_thread.start()\n",
    "    print 'Server loop runing thread: %s' % server_thread.name\n",
    "\n",
    "    # Run clients\n",
    "    client(ip, port, \"Hello from client 1\")\n",
    "    client(ip, port, \"Hello from client 2\")\n",
    "    client(ip, port, \"Hello from client 3\")\n",
    "\n",
    "    # Server cleanup\n",
    "    server.shutdown()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ForkingMixIn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 在套接字服务器程序中使用 ForkingMixIn\n",
    "\n",
    "import os\n",
    "import socket\n",
    "import threading\n",
    "import SocketServer\n",
    "\n",
    "SERVER_HOST = 'localhost'\n",
    "SERVER_PORT = 0    # Pick up a port dynamically\n",
    "BUF_SIZE = 1024\n",
    "ECHO_MSG = 'Hello echo server!'\n",
    "\n",
    "class ForkingClient():\n",
    "    \"\"\"TCP 客户端来检测ForkingProcess服务端\"\"\"\n",
    "    def __init__(self, ip, port):\n",
    "        # Create a socket\n",
    "        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
    "        # Connect to the server\n",
    "        self.sock.connect((ip, port))\n",
    "\n",
    "    def run(self):\n",
    "        \"\"\"Client playing with the server\"\"\"\n",
    "        # Send the data to server\n",
    "        current_process_id = os.getpid()\n",
    "        print 'PID %s sending echo message to the server: %s' % (current_process_id, ECHO_MSG)\n",
    "        send_data_length = self.sock.send(ECHO_MSG)\n",
    "        print \"Sent: %d characters, so far...\" % send_data_length\n",
    "\n",
    "        # Display server response\n",
    "        response = self.sock.recv(BUF_SIZE)\n",
    "        print \"PID %s received: %s\" % (current_process_id, response[5:])\n",
    "\n",
    "    def shutdown(self):\n",
    "        \"\"\"Cleanup the client socket\"\"\"\n",
    "        self.sock.close()\n",
    "\n",
    "class ForkingServerRequestHandler(SocketServer.BaseRequestHandler):\n",
    "    def handle(self):\n",
    "        # Send the echo back to the client\n",
    "        data = self.request.recv(BUF_SIZE)\n",
    "        current_process_id = os.getpid()\n",
    "        response = '%s: %s' % (current_process_id, data)\n",
    "        print \"Server sending response [current_process_id: data] = %s\" % response\n",
    "        self.request.send(response)\n",
    "        return\n",
    "\n",
    "class ForkingServer(SocketServer.ForkingMixIn, SocketServer.TCPServer):\n",
    "    \"\"\"Nothing to add here, inherited everything necessary from parents\"\"\"\n",
    "    pass\n",
    "\n",
    "def main():\n",
    "    # 封装服务端\n",
    "    server = ForkingServer((SERVER_HOST, SERVER_PORT), ForkingServerRequestHandler)\n",
    "    ip, port = server.server_address    # Retrieve the port number\n",
    "    server_thread = threading.Thread(target=server.serve_forever)\n",
    "    server_thread.setDaemon(True)   # Don't hang on exit\n",
    "    server_thread.start()\n",
    "    print 'Server loop runing PID: %s' % os.getpid()\n",
    "\n",
    "    # Launch the client(s)\n",
    "    client1 = ForkingClient(ip, port)\n",
    "    client1.run()\n",
    "\n",
    "    client2 = ForkingClient(ip, port)\n",
    "    client2.run()\n",
    "\n",
    "    # Clean them up\n",
    "    server.shutdown()\n",
    "    client1.shutdown()\n",
    "    client2.shutdown()\n",
    "    server.socket.close()\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## UDP Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import socket  \n",
    "  \n",
    "address = ('127.0.0.1', 31500)  \n",
    "s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  \n",
    "  \n",
    "while True:  \n",
    "    msg = raw_input()  \n",
    "    if not msg:  \n",
    "        break  \n",
    "    s.sendto(msg, address)\n",
    "    if msg == 'exit':\n",
    "        print 'client exit'\n",
    "        break\n",
    "  \n",
    "s.close()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HTTP\n",
    "### httplib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import httplib\n",
    "import urlparse\n",
    "import re\n",
    "import urllib\n",
    "\n",
    "DEFAULT_URL = 'http://www.qq.com'\n",
    "HTTP_GOOD_CODES = [httplib.OK, httplib.FOUND, httplib.MOVED_PERMANENTLY]\n",
    "\n",
    "def get_server_status_code(url):\n",
    "    \"\"\"Download just the header of a URL and return the server's status code\"\"\"\n",
    "    print urlparse.urlparse(url)\n",
    "    host, path = urlparse.urlparse(url)[1:3]\n",
    "    print host, path\n",
    "    try:\n",
    "        conn = httplib.HTTPConnection(host)\n",
    "        conn.request('GET', path)\n",
    "        return conn.getresponse().status\n",
    "    except StandardError, err:\n",
    "        print err\n",
    "        return None\n",
    "print get_server_status_code(DEFAULT_URL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网页下载数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import httplib\n",
    "\n",
    "REMOTE_SERVER_HOST = 'www.baidu.com'\n",
    "REMOTE_SERVER_PATH = '/'\n",
    "\n",
    "class HTTPClient:\n",
    "    def __init__(self, host):\n",
    "        self.host = host\n",
    "\n",
    "    def fetch(self, path):\n",
    "        http = httplib.HTTP(self.host)\n",
    "        # Prepare header\n",
    "        http.putrequest(\"GET\", path)\n",
    "        http.putheader(\"User-Agent\", 'AGENT')\n",
    "        http.putheader(\"Host\", self.host)\n",
    "        http.putheader(\"Accept\", \"*/*\")\n",
    "        http.endheaders()\n",
    "\n",
    "        try:\n",
    "            errcode, errmsg, headers = http.getreply()\n",
    "        except Exception, e:\n",
    "            print \"Client failed error code: %s message: %s headers: %s\" % (errcode, errmsg, headers)\n",
    "        else:\n",
    "            print \"Got homepage from %s\" % self.host\n",
    "\n",
    "        file = http.getfile()\n",
    "        return file.read()\n",
    "client = HTTPClient(REMOTE_SERVER_HOST)\n",
    "print client.fetch(REMOTE_SERVER_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Urllib2 Header"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import urllib2\n",
    "\n",
    "BROWSER = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:49.0) Gecko/20100101 Firefox/49.0'\n",
    "URL = 'http://www.163.com'\n",
    "\n",
    "def simulate_firefox():\n",
    "    opener = urllib2.build_opener()\n",
    "    opener.addheaders = [('User-agent', BROWSER)]\n",
    "    result = opener.open(URL)\n",
    "    print \"Response headers:\"\n",
    "    for header in result.headers.headers:\n",
    "        print \"\\t\", header\n",
    "\n",
    "simulate_firefox()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 通过代理服务器发送 Web 请求"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Get from http://www.xicidaili.com/\n",
    "import urllib\n",
    "\n",
    "URL = 'https://www.github.com'\n",
    "PROXY_ADDRESS = '1.164.144.107:8080'    \n",
    "\n",
    "if __name__ == '__main__':\n",
    "    resp = urllib.urlopen(URL, proxies = {\"http\": PROXY_ADDRESS})\n",
    "    print \"Proxy server returns response headers: %s\" % resp.headers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cookie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cookielib\n",
    "import urllib\n",
    "import urllib2\n",
    "\n",
    "NORMAL_URL = 'http://www.baidu.com'\n",
    "\n",
    "def extract_cookie_info():\n",
    "    \"\"\"Fake login to a site with cookie\"\"\"\n",
    "    # Setup cookie jar\n",
    "    cj = cookielib.CookieJar()\n",
    "    \n",
    "    # Create url opener\n",
    "    opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))\n",
    "    opener.open(NORMAL_URL)\n",
    "\n",
    "    try:\n",
    "        for cookie in cj:\n",
    "            print cookie.name, cookie.value\n",
    "    except IndexError:\n",
    "        return False, \"No csrftoken\"\n",
    "    \n",
    "extract_cookie_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HTTP Server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import BaseHTTPServer\n",
    "\n",
    "class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):\n",
    "    Page = '''\\\n",
    "        <html>\n",
    "        <body>\n",
    "        <p>Hello, World!</p>\n",
    "        </body>\n",
    "        </html>\n",
    "    '''\n",
    "    def do_GET(self):\n",
    "        self.send_response(200)\n",
    "        self.send_header(\"Content-Type\", \"text/html\")\n",
    "        self.send_header(\"Content-Length\", str(len(self.Page)))\n",
    "        self.end_headers()\n",
    "        self.wfile.write(self.Page)\n",
    "        \n",
    "serverAddress = ('0.0.0.0', 8080)\n",
    "server = BaseHTTPServer.HTTPServer(serverAddress, RequestHandler)\n",
    "server.serve_forever()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple HTTP Server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer\n",
    "\n",
    "DEFAULT_HOST = '0.0.0.0'\n",
    "DEFAULT_PORT = 8800\n",
    "\n",
    "class RequestHandler(BaseHTTPRequestHandler):\n",
    "    \"\"\"Custom request handler\"\"\"\n",
    "    def do_GET(self):\n",
    "        \"\"\"Handler for the GET requests\"\"\"\n",
    "        self.send_response(200)\n",
    "        self.send_header('Content-type', 'text/html')\n",
    "        self.end_headers()\n",
    "        # Send the message to browser\n",
    "        self.wfile.write(\"<h1>Simple HTTP Server</h1>\")\n",
    "        self.wfile.write('<img src=\"http://file06.16sucai.com/2016/0803/2fd023ed4f4d38facf52043d595a0af2.jpg\" />')\n",
    "        return\n",
    "\n",
    "class CustomHTTPServer(HTTPServer):\n",
    "    \"\"\"A custom HTTP server\"\"\"\n",
    "    def __init__(self, host, port):\n",
    "        server_address = (host, port)\n",
    "        HTTPServer.__init__(self, server_address, RequestHandler)\n",
    "\n",
    "def run_server(port):\n",
    "    try:\n",
    "        server = CustomHTTPServer(DEFAULT_HOST, port)\n",
    "        print \"Custom HTTP server started on port: %s\" % port\n",
    "        server.serve_forever()\n",
    "    except Exception, err:\n",
    "        print \"Error: %s\" % err\n",
    "    except KeyboardInterrupt:\n",
    "        print \"Server interrupted and is shutting down...\"\n",
    "        server.socket.close()\n",
    "run_server(8800)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### http server compress data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import string\n",
    "import os\n",
    "import sys\n",
    "import gzip\n",
    "import cStringIO\n",
    "from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer\n",
    "\n",
    "DEFAULT_HOST = '0.0.0.0'\n",
    "DEFAULT_PORT = 8800\n",
    "HTML_CONTENT = \"\"\"<html><body><h1>Compressed Hello World!</h1></body></html>\"\"\"\n",
    "\n",
    "class RequestHandler(BaseHTTPRequestHandler):\n",
    "    \"\"\"Custom request handler\"\"\"\n",
    "    def do_GET(self):\n",
    "        \"\"\"Handler for the GET requests\"\"\"\n",
    "        self.send_response(200)\n",
    "        self.send_header('Content-type', 'text/html')\n",
    "        self.send_header('Content-Encoding', 'gzip')\n",
    "        zbuf = self.compress_buffer(HTML_CONTENT)\n",
    "        sys.stdout.write(\"Content-Encoding: gzip\\r\\n\")\n",
    "        self.send_header('Content-Length', len(zbuf))\n",
    "        self.end_headers()\n",
    "\n",
    "        # Send the message to browser\n",
    "        zbuf = self.compress_buffer(HTML_CONTENT)\n",
    "        sys.stdout.write(\"Content-Encoding: gzip\\r\\n\")\n",
    "        sys.stdout.write(\"Content-Length: %d\\r\\n\" % (len(zbuf)))\n",
    "        sys.stdout.write(\"\\r\\n\")\n",
    "        self.wfile.write(zbuf)\n",
    "        return\n",
    "\n",
    "    def compress_buffer(self, buf):\n",
    "        zbuf = cStringIO.StringIO()\n",
    "        zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=6)\n",
    "        zfile.write(buf)\n",
    "        zfile.close()\n",
    "        return zbuf.getvalue()\n",
    "    \n",
    "server_address = (DEFAULT_HOST, DEFAULT_PORT)\n",
    "server = HTTPServer(server_address, RequestHandler)\n",
    "server.serve_forever()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EMAIL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 3416230579\n",
    "import smtplib\n",
    "from email import encoders\n",
    "from email.header import Header\n",
    "from email.mime.text import MIMEText\n",
    "from email.utils import parseaddr, formataddr\n",
    "\n",
    "def send_email(from_addr, to_addr, subject, password):\n",
    "    msg = MIMEText(\"邮件正文\",'html','utf-8')\n",
    "    msg['From'] = u'<%s>' % from_addr\n",
    "    msg['To'] = u'<%s>' % to_addr\n",
    "    msg['Subject'] = subject\n",
    "\n",
    "    smtp = smtplib.SMTP_SSL('smtp.qq.com', 465)\n",
    "    smtp.set_debuglevel(1)\n",
    "    smtp.ehlo(\"smtp.qq.com\")\n",
    "    smtp.login(from_addr, password)\n",
    "    smtp.sendmail(from_addr, [to_addr], msg.as_string())\n",
    "\n",
    "# 这里的密码是开启smtp服务时输入的客户端登录授权码，并不是邮箱密码\n",
    "# 现在很多邮箱都需要先开启smtp才能这样发送邮件\n",
    "send_email(u\"8745010@qq.com\",u\"3416230579@qq.com\",u\"主题\",\"xxxxxx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import smtplib\n",
    "\n",
    "from email import encoders\n",
    "from email.header import Header\n",
    "from email.mime.text import MIMEText\n",
    "from email.utils import parseaddr, formataddr\n",
    "from email.mime.multipart import MIMEMultipart\n",
    "\n",
    "def send_email(from_addr, to_addr, subject, password):\n",
    "    #msg = MIMEText(\"邮件正文\",'html','utf-8')\n",
    "    msg = MIMEMultipart()\n",
    "    msg['From'] = u'<%s>' % from_addr\n",
    "    msg['To'] = u'<%s>' % to_addr\n",
    "    msg['Subject'] = subject\n",
    "    att1 = MIMEText(open('test.txt', 'rb').read(), 'base64', 'gb2312')\n",
    "    att1[\"Content-Type\"] = 'application/octet-stream'\n",
    "    att1[\"Content-Disposition\"] = 'attachment; filename=\"test.txt\"'\n",
    "\n",
    "    msg.attach(att1)\n",
    "\n",
    "    smtp = smtplib.SMTP_SSL('smtp.qq.com', 465)\n",
    "    smtp.set_debuglevel(1)\n",
    "    smtp.ehlo(\"smtp.qq.com\")\n",
    "    smtp.login(from_addr, password)\n",
    "    smtp.sendmail(from_addr, [to_addr], msg.as_string())\n",
    "\n",
    "# 这里的密码是开启smtp服务时输入的客户端登录授权码，并不是邮箱密码\n",
    "# 现在很多邮箱都需要先开启smtp才能这样发送邮件\n",
    "send_email(u\"8745010@qq.com\",u\"3416230579@qq.com\",u\"主题\",\"xxxxxx\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### POP3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os, sys, string\n",
    "import poplib\n",
    "\n",
    "# pop3服务器地址\n",
    "host = \"pop3.163.com\"\n",
    "username = \"xxxxxx@163.com\"\n",
    "password = \"xxxxxxx\"\n",
    "pp = poplib.POP3(host)\n",
    "pp.set_debuglevel(1)\n",
    "pp.user(username)\n",
    "pp.pass_(password)\n",
    "# 获取服务器上信件信息，返回是一个列表，第一项是一共有多上封邮件，第二项是共有多少字节\n",
    "ret = pp.stat()\n",
    "print ret\n",
    "# 需要取出所有信件的头部，信件id是从1开始的。\n",
    "for i in range(1, ret[0]+1):\n",
    "    # 取出信件头部。注意：top指定的行数是以信件头为基数的，也就是说当取0行，\n",
    "    # 其实是返回头部信息，取1行其实是返回头部信息之外再多1行。\n",
    "    mlist = pp.top(i, 0)\n",
    "    print 'line: ', len(mlist[1])\n",
    "# 列出服务器上邮件信息，这个会对每一封邮件都输出id和大小。不象stat输出的是总的统计信息\n",
    "ret = pp.list()\n",
    "print ret\n",
    "# 取第一封邮件完整信息，在返回值里，是按行存储在down[1]的列表里的。down[0]是返回的状态信息\n",
    "down = pp.retr(1)\n",
    "print 'lines:', len(down)\n",
    "# 输出邮件\n",
    "for line in down[1]:\n",
    "    print line\n",
    "# 退出\n",
    "pp.quit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FTP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FTP Client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from ftplib import FTP \n",
    "import os\n",
    "\n",
    "def ftp_up(filename): \n",
    "    ftp=FTP() \n",
    "    ftp.set_debuglevel(2)#打开调试级别2，显示详细信息;0为关闭调试信息 \n",
    "    ftp.connect('127.0.0.1','2121')#连接 \n",
    "    ftp.login('user','12345')#登录，如果匿名登录则用空串代替即可 \n",
    "    print ftp.getwelcome()#显示ftp服务器欢迎信息 \n",
    "    ftp.cwd('ftp/') #选择操作目录 \n",
    "    bufsize = 1024#设置缓冲块大小 \n",
    "    file_handler = open(filename,'rb')#以读模式在本地打开文件 \n",
    "    ftp.storbinary('STOR %s' % os.path.basename(filename),file_handler,bufsize)#上传文件\n",
    "    ftp.set_debuglevel(0) \n",
    "    file_handler.close() \n",
    "    ftp.quit() \n",
    "    print \"ftp up OK\" \n",
    " \n",
    "def ftp_down(filename): \n",
    "    ftp=FTP() \n",
    "    ftp.set_debuglevel(2) \n",
    "    ftp.connect('127.0.0.1','2121') \n",
    "    ftp.login('user','12345') \n",
    "    print ftp.getwelcome()#显示ftp服务器欢迎信息 \n",
    "    ftp.cwd('/') #选择操作目录 \n",
    "    bufsize = 1024 \n",
    "    filename = \"ftp_down.txt\" \n",
    "    file_handler = open(filename,'wb').write\n",
    "    ftp.retrbinary('RETR %s' % os.path.basename(filename),file_handler,bufsize)#接收服务器上文件并写入本地文件 \n",
    "    ftp.set_debuglevel(0) \n",
    "    ftp.quit() \n",
    "    print \"ftp down OK\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ftp_up(filename='test.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ftp_down(filename='test.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XML RPC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import xmlrpclib  \n",
    "proxy = xmlrpclib.ServerProxy(\"http://localhost:8000/\")  \n",
    "candidate = proxy.is_even(3)  \n",
    "print \"the even is %d\" % candidate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import xmlrpclib  \n",
    "proxy = xmlrpclib.ServerProxy(\"http://localhost:8002/\")  \n",
    "  \n",
    "candidate = proxy.ret_a()  \n",
    "print \"the variable 'a' in server is \"+ str((proxy.from_string(candidate))) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import xmlrpclib\n",
    "proxy = xmlrpclib.ServerProxy(\"http://localhost:9999/\")\n",
    "handle = open(\"xmlrpc_logo.jpg\", \"wb\")\n",
    "handle.write(proxy.logo().data)\n",
    "handle.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}