Pods-Demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import json\n",
    "import pprint as pp\n",
    "import requests as r\n",
    "import datetime\n",
    "from getpass import getpass\n",
    "from tapipy.tapis import Tapis\n",
    "\n",
    "def show(res):\n",
    "    try:\n",
    "        pp.pprint(res.json())\n",
    "    except:\n",
    "        pp.pprint(res.text)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "\n",
    "# Base URL for Tapis\n",
    "base_url = \"https://icicle.tapis.io\"\n",
    "username = \"cgarcia\"\n",
    "\n",
    "# Checks for valid token and if one is not found it'll be created.\n",
    "try:\n",
    "    t\n",
    "    if t.base_url == base_url and t.username == username and t.access_token:\n",
    "        print(\"Tapis object already exists.\")\n",
    "        if t.access_token.expires_at < datetime.datetime.now(pytz.utc):\n",
    "            print(\"Existing Tapis token expired, getting new token.\")\n",
    "            raise\n",
    "    else:\n",
    "        print(\"Creating new Tapis object.\")\n",
    "        raise\n",
    "except:\n",
    "    try:\n",
    "        t = Tapis(base_url = base_url,\n",
    "                  username = username,\n",
    "                  password = getpass('password'))\n",
    "        t.get_tokens()\n",
    "    except Exception as e:\n",
    "        print(f\"\\nBROKEN! timeout: {time.time() - start}\\n\")\n",
    "        raise\n",
    "\n",
    "# V3 Headers\n",
    "header_dat = {\"X-Tapis-token\": t.access_token.access_token, \"Content-Type\": \"application/json\"}\n",
    "\n",
    "# Service URL\n",
    "url = \"http://192.168.49.2:30876/v3/pods\"     # To pods-traefik\n",
    "url = f\"{base_url}/v3/pods\"                  # remote\n",
    "\n",
    "# Some timing and urls being used\n",
    "print(time.time() - start)\n",
    "# URL to authenticate with using Tapipy.\n",
    "print(f\"base_url: {base_url}\")\n",
    "# URL to make requests with.\n",
    "print(f\"serv_url: {url}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Pods - Using Python Requests library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Assign pod name to use.\n",
    "pod_id = \"neo4j-demo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get pods.\n",
    "res = r.get(f\"{url}\",\n",
    "            headers=header_dat)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "## Create a pod - Neo example\n",
    "pod = json.dumps({\"pod_id\": pod_id,\n",
    "                  \"pod_template\": \"postgres\",\n",
    "                  \"description\": \"Postgres test\",\n",
    "                  \"time_to_stop_instance\": 5000})\n",
    "\n",
    "res = r.post(f'{url}',\n",
    "             headers=header_dat,\n",
    "             data=pod)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get pod.\n",
    "res = r.get(f\"{url}/{pod_id}\",\n",
    "                  headers=header_dat)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get pod credentials\n",
    "res = r.get(f\"{url}/{pod_id}/credentials\",\n",
    "                  headers=header_dat)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get pod logs\n",
    "get_actor = r.get(f\"{url}/{pod_id}/logs\",\n",
    "                  headers=header_dat)\n",
    "show(get_actor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get pod permissions\n",
    "res = r.get(f\"{url}/{pod_id}/permissions\",\n",
    "                  headers=header_dat)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set pod permissions\n",
    "res = r.post(f\"{url}/{pod_id}/permissions\",\n",
    "                   data=json.dumps({\"user\": \"username\", \"level\": \"READ\"}),\n",
    "                   headers=header_dat)\n",
    "show(get_actor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Delete pod permissions\n",
    "res = r.delete(f\"{url}/{pod_id}/permissions/dop\",\n",
    "             headers=header_dat)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Stop pod.\n",
    "get_actor = r.get(f\"{url}/{pod_id}/stop\",\n",
    "                  headers=header_dat)\n",
    "show(get_actor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start pod.\n",
    "get_actor = r.get(f\"{url}/{pod_id}/start\",\n",
    "                  headers=header_dat)\n",
    "show(get_actor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Delete pod.\n",
    "res = r.delete(f\"{url}/{pod_id}\",\n",
    "               headers=header_dat)\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Pods using Tapipy and creating a Neo4j Pod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pod_id = \"demopod\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pods()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "command: None\n",
       "creation_ts: 2022-10-18T13:54:36.060024\n",
       "data_attached: []\n",
       "data_requests: []\n",
       "description: \n",
       "environment_variables: \n",
       "\n",
       "persistent_volume: \n",
       "\n",
       "pod_id: demopod\n",
       "pod_template: neo4j\n",
       "roles_inherited: []\n",
       "roles_required: []\n",
       "routing_port: 7687\n",
       "start_instance_ts: None\n",
       "status: REQUESTED\n",
       "status_container: \n",
       "\n",
       "status_requested: ON\n",
       "time_to_stop_default: 43200\n",
       "time_to_stop_instance: None\n",
       "time_to_stop_ts: None\n",
       "update_ts: 2022-10-18T13:54:36.060045\n",
       "url: demopod.pods.icicle.tapis.io"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.create_pod(pod_id=pod_id, pod_template=\"neo4j\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "permissions: ['cgarcia:ADMIN']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod_permissions(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "permissions: ['cgarcia:ADMIN', 'steve:ADMIN']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.set_pod_permission(pod_id=pod_id, user='steve', level='ADMIN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "user_password: yJGBC0mplOtVu6s6YpY9c2bnDGii2h\n",
       "user_username: demopod"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod_credentials(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "logs: Fetching versions.json for Plugin 'apoc' from https://neo4j-contrib.github.io/neo4j-apoc-procedures/versions.json\n",
       "Installing Plugin 'apoc' from https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases/download/4.4.0.9/apoc-4.4.0.9-all.jar to /var/lib/neo4j/plugins/apoc.jar \n",
       "Applying default values for plugin apoc to neo4j.conf\n",
       "Fetching versions.json for Plugin 'n10s' from https://neo4j-labs.github.io/neosemantics/versions.json\n",
       "Installing Plugin 'n10s' from https://github.com/neo4j-labs/neosemantics/releases/download/4.4.0.2/neosemantics-4.4.0.2.jar to /var/lib/neo4j/plugins/n10s.jar \n",
       "Applying default values for plugin n10s to neo4j.conf\n",
       "2022-10-18 14:35:27.794+0000 INFO  Starting...\n",
       "2022-10-18 14:35:29.355+0000 INFO  This instance is ServerId{9d0f98b4} (9d0f98b4-f2fa-471f-a0be-26a859673151)\n",
       "2022-10-18 14:35:31.433+0000 INFO  ======== Neo4j 4.4.12 ========\n",
       "2022-10-18 14:35:37.368+0000 INFO  [system/00000000] successfully initialized: CREATE USER podsservice SET PLAINTEXT PASSWORD '6sR17d1QKFX3xKnugvadvO5Pkgeogh' SET PASSWORD CHANGE NOT REQUIRED\n",
       "2022-10-18 14:35:37.416+0000 INFO  [system/00000000] successfully initialized: CREATE USER demopod SET PLAINTEXT PASSWORD 'yJGBC0mplOtVu6s6YpY9c2bnDGii2h' SET PASSWORD CHANGE NOT REQUIRED\n",
       "2022-10-18 14:35:44.499+0000 INFO  Upgrading security graph to latest version\n",
       "2022-10-18 14:35:44.500+0000 INFO  Setting version for 'security-users' to 2\n",
       "2022-10-18 14:35:44.502+0000 INFO  Upgrading 'security-users' version property from 2 to 3\n",
       "2022-10-18 14:35:44.882+0000 INFO  Called db.clearQueryCaches(): Query caches successfully cleared of 1 queries.\n",
       "2022-10-18 14:35:45.074+0000 INFO  Bolt enabled on [0:0:0:0:0:0:0:0%0]:7687.\n",
       "2022-10-18 14:35:47.062+0000 INFO  Remote interface available at http://pods-tacc-icicle-demopod:7474/\n",
       "2022-10-18 14:35:47.071+0000 INFO  id: 8EA4B6FAF42A50B0A71FAB3E8D4F7339DED35B42B6051D4D3E4B997F59FF0495\n",
       "2022-10-18 14:35:47.071+0000 INFO  name: system\n",
       "2022-10-18 14:35:47.071+0000 INFO  creationDate: 2022-10-18T14:35:32.585Z\n",
       "2022-10-18 14:35:47.071+0000 INFO  Started."
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod_logs(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "command: None\n",
       "creation_ts: 2022-10-18T13:54:36.060024\n",
       "data_attached: []\n",
       "data_requests: []\n",
       "description: \n",
       "environment_variables: \n",
       "\n",
       "persistent_volume: \n",
       "\n",
       "pod_id: demopod\n",
       "pod_template: neo4j\n",
       "roles_inherited: []\n",
       "roles_required: []\n",
       "routing_port: 7687\n",
       "start_instance_ts: 2022-10-18T14:35:16.739284\n",
       "status: RUNNING\n",
       "status_container: \n",
       "message: Pod is running.\n",
       "phase: Running\n",
       "start_time: 2022-10-18 14:34:59+00:00\n",
       "status_requested: ON\n",
       "time_to_stop_default: 43200\n",
       "time_to_stop_instance: None\n",
       "time_to_stop_ts: 2022-10-19T02:35:16.739562\n",
       "update_ts: 2022-10-18T13:54:36.060045\n",
       "url: demopod.pods.icicle.tapis.io"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Connect to new Neo4j pod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Credentials\n",
    "url = \"bolt+s://demopod.pods.icicle.tapis.io:443\"\n",
    "user = \"demopod\"\n",
    "passw = \"yJGBC0mplOtVu6s6YpY9c2bnDGii2h\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Record n=<Node id=0 labels=frozenset({'Person'}) properties={}>>\n",
      "<Record n=<Node id=1 labels=frozenset({'Person'}) properties={}>>\n",
      "<Record n=<Node id=2 labels=frozenset({'Person'}) properties={}>>\n"
     ]
    }
   ],
   "source": [
    "from neo4j import GraphDatabase\n",
    "\n",
    "neo = GraphDatabase.driver(url,\n",
    "                           auth = (user, passw),\n",
    "                           max_connection_lifetime=30)\n",
    "\n",
    "with neo.session() as session:\n",
    "    query = 'CREATE (n:Person)'\n",
    "    session.run(query)\n",
    "    \n",
    "    result = session.run(\"MATCH (n) RETURN n\")\n",
    "    for record in result:\n",
    "        print(record)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Record n=<Node id=0 labels=frozenset({'Person'}) properties={}>>\n",
      "<Record n=<Node id=1 labels=frozenset({'Person'}) properties={}>>\n",
      "<Record n=<Node id=2 labels=frozenset({'Person'}) properties={}>>\n",
      "<Record n=<Node id=3 labels=frozenset({'Person'}) properties={}>>\n"
     ]
    }
   ],
   "source": [
    "# Let's run it again!\n",
    "from neo4j import GraphDatabase\n",
    "\n",
    "neo = GraphDatabase.driver(url,\n",
    "                           auth = (user, passw),\n",
    "                           max_connection_lifetime=30)\n",
    "\n",
    "with neo.session() as session:\n",
    "    query = 'CREATE (n:Person)'\n",
    "    session.run(query)\n",
    "    \n",
    "    result = session.run(\"MATCH (n) RETURN n\")\n",
    "    for record in result:\n",
    "        print(record)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Pods using Tapipy and creating a Postgres Pod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "pod_id = \"demopostgres\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\n",
       " command: None\n",
       " creation_ts: 2022-10-18T13:54:36.060024\n",
       " data_attached: []\n",
       " data_requests: []\n",
       " description: \n",
       " environment_variables: \n",
       " \n",
       " persistent_volume: \n",
       " \n",
       " pod_id: demopod\n",
       " pod_template: neo4j\n",
       " roles_inherited: []\n",
       " roles_required: []\n",
       " routing_port: 7687\n",
       " start_instance_ts: 2022-10-18T14:35:16.739284\n",
       " status: RUNNING\n",
       " status_container: \n",
       " message: Pod is running.\n",
       " phase: Running\n",
       " start_time: 2022-10-18 14:34:59+00:00\n",
       " status_requested: ON\n",
       " time_to_stop_default: 43200\n",
       " time_to_stop_instance: None\n",
       " time_to_stop_ts: 2022-10-19T02:35:16.739562\n",
       " update_ts: 2022-10-18T13:54:36.060045\n",
       " url: demopod.pods.icicle.tapis.io]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pods()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "command: None\n",
       "creation_ts: 2022-10-18T13:54:36.060024\n",
       "data_attached: []\n",
       "data_requests: []\n",
       "description: \n",
       "environment_variables: \n",
       "\n",
       "persistent_volume: \n",
       "\n",
       "pod_id: demopostgres\n",
       "pod_template: postgres\n",
       "roles_inherited: []\n",
       "roles_required: []\n",
       "routing_port: 5432\n",
       "start_instance_ts: None\n",
       "status: REQUESTED\n",
       "status_container: \n",
       "\n",
       "status_requested: ON\n",
       "time_to_stop_default: 43200\n",
       "time_to_stop_instance: None\n",
       "time_to_stop_ts: None\n",
       "update_ts: 2022-10-18T13:54:36.060045\n",
       "url: demopostgres.pods.icicle.tapis.io"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.create_pod(pod_id=pod_id, pod_template=\"postgres\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "user_password: 7jSmQ39zoDl5PNUppnL1HV5q7ntrRt\n",
       "user_username: demopostgres"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod_credentials(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "logs: The files belonging to this database system will be owned by user \"postgres\".\n",
       "This user must also own the server process.\n",
       "\n",
       "The database cluster will be initialized with locale \"en_US.utf8\".\n",
       "The default database encoding has accordingly been set to \"UTF8\".\n",
       "The default text search configuration will be set to \"english\".\n",
       "\n",
       "Data page checksums are disabled.\n",
       "\n",
       "fixing permissions on existing directory /var/lib/postgresql/data ... ok\n",
       "creating subdirectories ... ok\n",
       "selecting dynamic shared memory implementation ... posix\n",
       "selecting default max_connections ... 100\n",
       "selecting default shared_buffers ... 128MB\n",
       "selecting default time zone ... Etc/UTC\n",
       "creating configuration files ... ok\n",
       "running bootstrap script ... ok\n",
       "performing post-bootstrap initialization ... ok\n",
       "initdb: warning: enabling \"trust\" authentication for local connections\n",
       "initdb: hint: You can change this by editing pg_hba.conf or using the option -A, or --auth-local and --auth-host, the next time you run initdb.\n",
       "syncing data to disk ... ok\n",
       "\n",
       "\n",
       "Success. You can now start the database server using:\n",
       "\n",
       "    pg_ctl -D /var/lib/postgresql/data -l logfile start\n",
       "\n",
       "waiting for server to start....2022-10-18 14:54:08.097 UTC [48] LOG:  starting PostgreSQL 15.0 (Debian 15.0-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit\n",
       "2022-10-18 14:54:08.098 UTC [48] LOG:  listening on Unix socket \"/var/run/postgresql/.s.PGSQL.5432\"\n",
       "2022-10-18 14:54:08.102 UTC [51] LOG:  database system was shut down at 2022-10-18 14:54:07 UTC\n",
       "2022-10-18 14:54:08.109 UTC [48] LOG:  database system is ready to accept connections\n",
       " done\n",
       "server started\n",
       "CREATE DATABASE\n",
       "\n",
       "\n",
       "/usr/local/bin/docker-entrypoint.sh: ignoring /docker-entrypoint-initdb.d/*\n",
       "\n",
       "2022-10-18 14:54:08.357 UTC [48] LOG:  received fast shutdown request\n",
       "waiting for server to shut down....2022-10-18 14:54:08.357 UTC [48] LOG:  aborting any active transactions\n",
       "2022-10-18 14:54:08.359 UTC [48] LOG:  background worker \"logical replication launcher\" (PID 54) exited with exit code 1\n",
       "2022-10-18 14:54:08.360 UTC [49] LOG:  shutting down\n",
       "2022-10-18 14:54:08.360 UTC [49] LOG:  checkpoint starting: shutdown immediate\n",
       "2022-10-18 14:54:08.416 UTC [49] LOG:  checkpoint complete: wrote 918 buffers (5.6%); 0 WAL file(s) added, 0 removed, 0 recycled; write=0.022 s, sync=0.033 s, total=0.056 s; sync files=250, longest=0.029 s, average=0.001 s; distance=4217 kB, estimate=4217 kB\n",
       "2022-10-18 14:54:08.430 UTC [48] LOG:  database system is shut down\n",
       " done\n",
       "server stopped\n",
       "\n",
       "PostgreSQL init process complete; ready for start up.\n",
       "\n",
       "2022-10-18 14:54:08.491 UTC [1] LOG:  starting PostgreSQL 15.0 (Debian 15.0-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit\n",
       "2022-10-18 14:54:08.491 UTC [1] LOG:  listening on IPv4 address \"0.0.0.0\", port 5432\n",
       "2022-10-18 14:54:08.492 UTC [1] LOG:  listening on IPv6 address \"::\", port 5432\n",
       "2022-10-18 14:54:08.492 UTC [1] LOG:  listening on Unix socket \"/var/run/postgresql/.s.PGSQL.5432\"\n",
       "2022-10-18 14:54:08.496 UTC [63] LOG:  database system was shut down at 2022-10-18 14:54:08 UTC\n",
       "2022-10-18 14:54:08.500 UTC [1] LOG:  database system is ready to accept connections"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod_logs(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "command: None\n",
       "creation_ts: 2022-10-18T13:54:36.060024\n",
       "data_attached: []\n",
       "data_requests: []\n",
       "description: \n",
       "environment_variables: \n",
       "\n",
       "persistent_volume: \n",
       "\n",
       "pod_id: demopostgres\n",
       "pod_template: postgres\n",
       "roles_inherited: []\n",
       "roles_required: []\n",
       "routing_port: 5432\n",
       "start_instance_ts: 2022-10-18T14:54:08.548675\n",
       "status: RUNNING\n",
       "status_container: \n",
       "message: Pod is running.\n",
       "phase: Running\n",
       "start_time: 2022-10-18 14:53:41+00:00\n",
       "status_requested: ON\n",
       "time_to_stop_default: 43200\n",
       "time_to_stop_instance: None\n",
       "time_to_stop_ts: 2022-10-19T02:54:08.548741\n",
       "update_ts: 2022-10-18T13:54:36.060045\n",
       "url: demopostgres.pods.icicle.tapis.io"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.pods.get_pod(pod_id=pod_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Connect to new Postgres pod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import psycopg2\n",
    "\n",
    "params1 = {\"host\": \"demopostgres.pods.icicle.tapis.io\",\n",
    "           \"port\":  443,\n",
    "           \"database\": \"postgres\",\n",
    "           \"user\": \"demopostgres\",\n",
    "           \"password\": \"7jSmQ39zoDl5PNUppnL1HV5q7ntrRt\"}\n",
    "\n",
    "conn = psycopg2.connect(**params1)\n",
    "pg_cursor = conn.cursor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "# get all tables\n",
    "pg_cursor.execute(\"select relname from pg_class where relkind='r' and relname !~ '^(pg_|sql_)';\")\n",
    "print(pg_cursor.fetchall())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get all tables\n",
    "pg_cursor.execute(\"\"\"\n",
    "CREATE TABLE distributors (\n",
    "    did     integer,\n",
    "    name    varchar(40),\n",
    "    PRIMARY KEY(did)\n",
    ");\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('distributors',)]\n"
     ]
    }
   ],
   "source": [
    "# get all tables\n",
    "pg_cursor.execute(\"select relname from pg_class where relkind='r' and relname !~ '^(pg_|sql_)';\")\n",
    "print(pg_cursor.fetchall())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visual Analytics\n",
    "The following section is a complex Pods service example used by one of our working groups.  \n",
    "The example will create two seperate Neo4J instances, neo1 and neo2. These db instances  \n",
    "will then be ingested by a custom Python Flask server that'll act as the server backend. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'Pod created successfully.',\n",
      " 'metadata': {},\n",
      " 'result': {'container_status': {},\n",
      "            'creation_ts': None,\n",
      "            'data_requests': [],\n",
      "            'description': 'VisualAnalytics PPOD Data',\n",
      "            'environment_variables': {},\n",
      "            'pod_id': 'neo1',\n",
      "            'pod_template': 'neo4j',\n",
      "            'roles_required': [],\n",
      "            'status': 'REQUESTED',\n",
      "            'update_ts': None,\n",
      "            'url': 'neo1.develop.tapis.io'},\n",
      " 'status': 'success',\n",
      " 'version': 'dev'}\n"
     ]
    }
   ],
   "source": [
    "## Create a pod - neo4j 1\n",
    "res = r.post(f'{url}',\n",
    "             headers=header_dat,\n",
    "             data=json.dumps({\"pod_id\": \"neo1\",\n",
    "                              \"pod_template\": \"neo4j\",\n",
    "                              \"description\": \"VisualAnalytics PPOD Data\"}))\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'Pod created successfully.',\n",
      " 'metadata': {},\n",
      " 'result': {'container_status': {},\n",
      "            'creation_ts': None,\n",
      "            'data_requests': [],\n",
      "            'description': 'VisualAnalytics ColdChain Data',\n",
      "            'environment_variables': {},\n",
      "            'pod_id': 'neo2',\n",
      "            'pod_template': 'neo4j',\n",
      "            'roles_required': [],\n",
      "            'status': 'REQUESTED',\n",
      "            'update_ts': None,\n",
      "            'url': 'neo2.develop.tapis.io'},\n",
      " 'status': 'success',\n",
      " 'version': 'dev'}\n"
     ]
    }
   ],
   "source": [
    "## Create a pod - neo4j 2\n",
    "res = r.post(f'{url}',\n",
    "             headers=header_dat,\n",
    "             data=json.dumps({\"pod_id\": \"neo2\",\n",
    "                              \"pod_template\": \"neo4j\",\n",
    "                              \"description\": \"VisualAnalytics ColdChain Data\"}))\n",
    "show(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'The request was successful',\n",
      " 'metadata': {},\n",
      " 'result': {'user_password': '1froUwrQD6qhc99qbIrreVBLkleei2',\n",
      "            'user_username': 'neo1'},\n",
      " 'status': 'success',\n",
      " 'version': 'dev'}\n"
     ]
    }
   ],
   "source": [
    "# Get pod credentials 1\n",
    "get_actor = r.get(f\"{url}/{pod_id}/credentials\",\n",
    "                  headers=header_dat)\n",
    "show(get_actor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'The request was successful',\n",
      " 'metadata': {},\n",
      " 'result': {'user_password': 'MkapUiVfZeFIjZ8GY6gO4WsTYqWIR5',\n",
      "            'user_username': 'neo2'},\n",
      " 'status': 'success',\n",
      " 'version': 'dev'}\n"
     ]
    }
   ],
   "source": [
    "# Get pod credentials 2\n",
    "get_actor = r.get(f\"{url}/neo2/credentials\",\n",
    "                  headers=header_dat)\n",
    "show(get_actor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'Pod created successfully.',\n",
      " 'metadata': {},\n",
      " 'result': {'container_status': {},\n",
      "            'creation_ts': None,\n",
      "            'data_requests': [],\n",
      "            'description': 'Just a test!',\n",
      "            'environment_variables': {'db_password1': '1froUwrQD6qhc99qbIrreVBLkleei2',\n",
      "                                      'db_password2': 'MkapUiVfZeFIjZ8GY6gO4WsTYqWIR5',\n",
      "                                      'db_url1': 'bolt://neo1.develop.tapis.io:443',\n",
      "                                      'db_url2': 'bolt://neo2.develop.tapis.io:443',\n",
      "                                      'db_user1': 'neo1',\n",
      "                                      'db_user2': 'neo2'},\n",
      "            'pod_id': 'vaapi',\n",
      "            'pod_template': 'custom-tuyamei/smartfoodshed-server',\n",
      "            'roles_required': [],\n",
      "            'status': 'REQUESTED',\n",
      "            'update_ts': None,\n",
      "            'url': 'vaapi.develop.tapis.io'},\n",
      " 'status': 'success',\n",
      " 'version': 'dev'}\n"
     ]
    }
   ],
   "source": [
    "## Create a pod - complex webserver\n",
    "res = r.post(f'{url}',\n",
    "             headers=header_dat,\n",
    "             data=json.dumps({\"pod_id\": \"vaapi\",\n",
    "                              \"pod_template\": \"custom-tuyamei/smartfoodshed-server\",\n",
    "                              \"description\": \"foodshedsserver\",\n",
    "                              \"environment_variables\": {\"db_url1\": \"bolt://neo1.develop.tapis.io:443\",\n",
    "                                                        \"db_user1\": \"neo1\",\n",
    "                                                        \"db_password1\": \"password_here - 1\",\n",
    "                                                        \"db_url2\": \"bolt://neo2.develop.tapis.io:443\",\n",
    "                                                        \"db_user2\": \"neo2\",\n",
    "                                                        \"db_password2\": \"password_here - 2\"}}))\n",
    "show(res)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}