4.Proxy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para entrar no modo apresentação, execute a seguinte célula e pressione `-`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reload_ext slide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span class=\"notebook-slide-start\"/>\n",
    "\n",
    "# Proxy\n",
    "\n",
    "Este notebook apresenta os seguintes tópicos:\n",
    "\n",
    "- [Introdução](#Introdu%C3%A7%C3%A3o)\n",
    "- [Servidor de proxy](#Servidor-de-proxy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introdução\n",
    "\n",
    "Existe muita informação disponível em repositórios software.\n",
    "\n",
    "A seguir temos uma *screenshot* do repositório `gems-uff/sapos`.\n",
    "\n",
    "<img src=\"images/githubexample.png\" alt=\"Página Inicial de Repositório no GitHub\" width=\"auto\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nessa imagem, vemos a organização e nome do repositório\n",
    "\n",
    "<img src=\"images/githubexample1.png\" alt=\"Página Inicial de Repositório no GitHub com nome do repositório selecionado\" width=\"auto\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estrelas, forks, watchers \n",
    "\n",
    "<img src=\"images/githubexample2.png\" alt=\"Página Inicial de Repositório no GitHub com watchers, star e fork selecionados\" width=\"auto\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Número de issues e pull requests \n",
    "\n",
    "<img src=\"images/githubexample3.png\" alt=\"Página Inicial de Repositório no GitHub com numero de issues e pull requests selecionados\" width=\"auto\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Número de commits, branches, releases, contribuidores e licensa <span class=\"notebook-slide-extra\" data-count=\"1\"/>\n",
    "\n",
    "<img src=\"images/githubexample4.png\" alt=\"Página Inicial de Repositório no GitHub com número de commits, branches, releases, contribuidores e licensa selecionados\" width=\"auto\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arquivos\n",
    "\n",
    "<img src=\"images/githubexample5.png\" alt=\"Página Inicial de Repositório no GitHub com arquivos selecionados\" width=\"auto\"/>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mensagem e data dos commits que alteraram esses arquivos por último \n",
    "\n",
    "<img src=\"images/githubexample6.png\" alt=\"Página Inicial de Repositório no GitHub com arquivos selecionados\" width=\"auto\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos extrair informações de repositórios de software de 3 formas:\n",
    "\n",
    "- Crawling do site do repositório\n",
    "- APIs que fornecem dados\n",
    "- Diretamente do sistema de controle de versões\n",
    "\n",
    "Neste minicurso abordaremos as 3 maneiras, porém daremos mais atenção a APIs do GitHub e extração direta do Git."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Servidor de proxy\n",
    "\n",
    "Servidores de repositório costumam limitar a quantidade de requisições que podemos fazer.\n",
    "\n",
    "Em geral, essa limitação não afeta muito o uso esporádico dos serviços para mineração. Porém, quando estamos desenvolvendo algo, pode ser que passemos do limite com requisições repetidas.\n",
    "\n",
    "Para evitar esse problema, vamos configurar um servidor de proxy simples em flask."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando estamos usando um servidor de proxy, ao invés de fazermos requisições diretamente ao site de destino, fazemos requisições ao servidor de proxy, que, em seguida, redireciona as requisições para o site de destino.\n",
    "\n",
    "Ao receber o resultado da requisição, o proxy faz um cache do resultado e nos retorna o resultado.\n",
    "\n",
    "Se uma requisição já tiver sido feita pelo servidor de proxy, ele apenas nos retorna o resultado do cache."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementação do Proxy\n",
    "\n",
    "A implementação do servidor de proxy está no arquivo `proxy.py`. Como queremos executar o proxy em paralelo ao notebook, o servidor precisa ser executado externamente.\n",
    "\n",
    "Entretanto, o código do proxy será explicado aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Começamos o arquivo com os imports necessários. \n",
    "\n",
    "```python\n",
    "import hashlib\n",
    "import requests\n",
    "import simplejson\n",
    "import os\n",
    "import sys\n",
    "from flask import Flask, request, Response\n",
    "```\n",
    "\n",
    "A biblioteca `hashlib` é usada para fazer hash das requisições. A biblioteca `requests` é usada para fazer requisições ao GitHub. A biblioteca `simplejson` é usada para transformar requisiçoes e respostas em JSON. A biblioteca `os` é usada para manipular caminhos de diretórios e verificar a existência de arquivos. A biblioteca `sys` é usada para pegar os argumentos da execução. Por fim, `flask` é usada como servidor.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, definimos o site para qual faremos proxy, os headers excluídos da resposta recebida, e criamos um `app` pro `Flask`. Note que `SITE` está sendo definido como o primeiro argumendo da execução do programa ou como https://github.com/, caso não haja argumento.\n",
    "\n",
    "```python\n",
    "if len(sys.argv) > 1:\n",
    "    SITE = sys.argv[1]\n",
    "else:\n",
    "    SITE = \"https://github.com/\"\n",
    "EXCLUDED_HEADERS = ['content-encoding', 'content-length', 'transfer-encoding', 'connection']\n",
    "\n",
    "app = Flask(__name__)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depois, definimos uma função para tratar todas rotas e métodos possíveis que o servidor pode receber.\n",
    "\n",
    "```python\n",
    "METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE']\n",
    "@app.route('/', defaults={'path': ''}, methods=METHODS)\n",
    "@app.route('/<path:path>', methods=METHODS)\n",
    "def catch_all(path):\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dentro desta função, definimos um dicionário de requisição com base na requisição que foi recebida pelo `flask`.\n",
    "\n",
    "```python\n",
    "    request_dict = {\n",
    "        \"method\": request.method,\n",
    "        \"url\": request.url.replace(request.host_url, SITE),\n",
    "        \"headers\": {key: value for (key, value) in request.headers if key != 'Host'},\n",
    "        \"data\": request.get_data(),\n",
    "        \"cookies\": request.cookies,\n",
    "        \"allow_redirects\": False\n",
    "    }\n",
    "```\n",
    "\n",
    "Nesta requsição, substituímos o host pelo site de destino.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, convertemos o dicionário para JSON e calculamos o hash SHA1 do resultado.\n",
    "\n",
    "```python\n",
    "    request_json = simplejson.dumps(request_dict, sort_keys=True)\n",
    "    sha1 = hashlib.sha1(request_json.encode(\"utf-8\")).hexdigest()\n",
    "    path_req = os.path.join(\"cache\", sha1 + \".req\")\n",
    "    path_resp = os.path.join(\"cache\", sha1 + \".resp\")\n",
    "```\n",
    "\n",
    "No diretório `cache` armazenamos arquivos `{sha1}.req` e `{sha1}.resp` com a requisição e resposta dos resultados em cache."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com isso, ao receber uma requisição, podemos ver se `{sha1}.req` existe. Se existir, podemos comparar com a nossa requisição (para evitar conflitos). Por fim, se forem iguais, podemos retornar a resposta que está em cache.\n",
    "\n",
    "```python\n",
    "    if os.path.exists(path_req):\n",
    "        with open(path_req, \"r\") as req:\n",
    "            req_read = req.read()\n",
    "            if req_read == request_json:\n",
    "                with open(path_resp, \"r\") as dump:\n",
    "                    response = simplejson.load(dump)\n",
    "                    return Response(\n",
    "                        response[\"content\"],\n",
    "                        response[\"status_code\"],\n",
    "                        response[\"headers\"]\n",
    "                    )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se a requisição não estiver em cache, transformamos o dicionário da requisição em uma requisição do `requests` para o GitHub, excluimos os headers populados pelo `flask` e criamos um JSON para a resposta.\n",
    "\n",
    "```python\n",
    "    resp = requests.request(**request_dict)\n",
    "    headers = [(name, value) for (name, value) in resp.raw.headers.items()\n",
    "               if name.lower() not in EXCLUDED_HEADERS]\n",
    "    response = {\n",
    "        \"content\": resp.content,\n",
    "        \"status_code\": resp.status_code,\n",
    "        \"headers\": headers\n",
    "    }\n",
    "    response_json = simplejson.dumps(response, sort_keys=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depois disso, salvamos a resposta no cache e retornamos ela para o cliente original.\n",
    "\n",
    "```python\n",
    "    with open(path_resp, \"w\") as dump:\n",
    "        dump.write(response_json)\n",
    "    with open(path_req, \"w\") as req:\n",
    "        req.write(request_json)\n",
    "    return Response(\n",
    "        response[\"content\"],\n",
    "        response[\"status_code\"],\n",
    "        response[\"headers\"]\n",
    "    )\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No fim do script, iniciamos o servidor.\n",
    "\n",
    "```python\n",
    "if __name__ == '__main__':\n",
    "    app.run(debug=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uso do Proxy\n",
    "\n",
    "Execute a seguinte linha em um terminal:\n",
    "\n",
    "```bash\n",
    "python proxy.py\n",
    "```\n",
    "\n",
    "Agora, toda requisição que faríamos a github.com, passaremos a fazer a localhost:5000. Por exemplo, ao invés de acessar https://github.com/gems-uff/sapos, acessaremos http://localhost:5000/gems-uff/sapos\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Requisição com requests\n",
    "\n",
    "A seguir fazemos uma requisição com requests para o proxy. <span class=\"notebook-slide-extra\" data-count=\"2\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SITE = \"http://localhost:5000/\" # Se não usar o proxy, alterar para https://github.com/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "response = requests.get(SITE + \"gems-uff/sapos\")\n",
    "response.headers['server'], response.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span class=\"notebook-slide-scroll\" data-position=\"-1\"/>\n",
    "\n",
    "Podemos que o resultado foi obtido do GitHub e que a requisição funcionou, dado que o resultado foi 200. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Continua: [5.Crawling.ipynb](5.Crawling.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "&nbsp;\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}