Week5_C1M5_Object_Oriented_Programming_V7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assessment - Object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this exercise, we'll create a few classes to simulate a server that's taking connections from the outside and then a load balancer that ensures that there are enough servers to serve those connections. \n",
    "<br><br>\n",
    "To represent the servers that are taking care of the connections, we'll use a Server class. Each connection is represented by an id, that could, for example, be the IP address of the computer connecting to the server.  For our simulation, each connection creates a random amount of load in the server, between 1 and 10.\n",
    "<br><br>\n",
    "Run the following code that defines this Server class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Begin Portion 1#\n",
    "import random\n",
    "\n",
    "class Server:\n",
    "    def __init__(self):\n",
    "        \"\"\"Creates a new server instance, with no active connections.\"\"\"\n",
    "        self.connections = {}\n",
    "\n",
    "    def add_connection(self, connection_id):\n",
    "        \"\"\"Adds a new connection to this server.\"\"\"\n",
    "        connection_load = random.random()*10+1\n",
    "        # Add the connection to the dictionary with the calculated load\n",
    "        self.connections[connection_id] = connection_load\n",
    "    def close_connection(self, connection_id):\n",
    "        \"\"\"Closes a connection on this server.\"\"\"\n",
    "        # Remove the connection from the dictionary\n",
    "        if connection_id in self.connections:\n",
    "            del self.connections[connection_id]\n",
    "    def load(self):\n",
    "        \"\"\"Calculates the current load for all connections.\"\"\"\n",
    "        total = 0\n",
    "        for load in self.connections.values():\n",
    "            total += load\n",
    "        # Add up the load for each of the connections\n",
    "        return total\n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"Returns a string with the current load of the server\"\"\"\n",
    "        return \"{:.2f}%\".format(self.load())\n",
    "    \n",
    "#End Portion 1#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now run the following cell to create a Server instance and add a connection to it, then check the load:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.084033090248539\n"
     ]
    }
   ],
   "source": [
    "server = Server()\n",
    "server.add_connection(\"192.168.1.1\")\n",
    "\n",
    "print(server.load())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running the above code cell, if you get a **<font color =red>NameError</font>** message, be sure to run the Server class definition code block first.\n",
    "\n",
    "The output should be 0.  This is because some things are missing from the Server class. So, you'll need to go back and fill in the blanks to make it behave properly. \n",
    "<br><br>\n",
    "Go back to the Server class definition and fill in the missing parts for the `add_connection` and `load` methods to make the cell above print a number different than zero.  As the load is calculated randomly, this number should be different each time the code is executed.\n",
    "<br><br>\n",
    "**Hint:** Recall that you can iterate through the values of your connections dictionary just as you would any sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! If your output is a random number between 1 and 10, you have successfully coded the `add_connection` and `load` methods of the Server class.  Well done!\n",
    "<br><br>\n",
    "What about closing a connection? Right now the `close_connection` method doesn't do anything. Go back to the Server class definition and fill in the missing code for the `close_connection` method to make the following code work correctly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "server.close_connection(\"192.168.1.1\")\n",
    "print(server.load())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have successfully coded the `close_connection` method if the cell above prints 0.\n",
    "<br><br>\n",
    "**Hint:** Remember that `del` dictionary[key] removes the item with key *key* from the dictionary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alright, we now have a basic implementation of the server class. Let's look at the basic LoadBalancing class. This class will start with only one server available. When a connection gets added, it will randomly select a server to serve that connection, and then pass on the connection to the server. The LoadBalancing class also needs to keep track of the ongoing connections to be able to close them. This is the basic structure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Begin Portion 2#\n",
    "class LoadBalancing:\n",
    "    def __init__(self):\n",
    "        \"\"\"Initialize the load balancing system with one server\"\"\"\n",
    "        self.connections = {}\n",
    "        self.servers = [Server()]\n",
    "\n",
    "    def add_connection(self, connection_id):\n",
    "        \"\"\"Randomly selects a server and adds a connection to it.\"\"\"\n",
    "        server = random.choice(self.servers)\n",
    "        # Add the connection to the dictionary with the selected server\n",
    "        # Add the connection to the server\n",
    "        server.add_connection(connection_id)\n",
    "        self.ensure_availability()\n",
    "\n",
    "    def close_connection(self, connection_id):\n",
    "        \"\"\"Closes the connection on the the server corresponding to connection_id.\"\"\"\n",
    "        # Find out the right server\n",
    "        # Close the connection on the server\n",
    "        # Remove the connection from the load balancer\n",
    "        for server in self.servers:\n",
    "            if connection_id in server.connections:\n",
    "                server.close_connection(connection_id)\n",
    "                break\n",
    "           \n",
    "    def avg_load(self):\n",
    "        \"\"\"Calculates the average load of all servers\"\"\"\n",
    "        # Sum the load of each server and divide by the amount of servers\n",
    "        total_load = 0\n",
    "        total_server = 0\n",
    "        for server in self.servers:\n",
    "            total_load += server.load()\n",
    "            total_server += 1\n",
    "        return total_load/total_server\n",
    "\n",
    "    def ensure_availability(self):\n",
    "        \"\"\"If the average load is higher than 50, spin up a new server\"\"\"\n",
    "        if self.avg_load() > 50:\n",
    "            self.servers.append(Server())\n",
    "\n",
    "    def __str__(self):\n",
    "        \"\"\"Returns a string with the load for each server.\"\"\"\n",
    "        loads = [str(server) for server in self.servers]\n",
    "        return \"[{}]\".format(\",\".join(loads))\n",
    "#End Portion 2#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with the Server class, this class is currently incomplete. You need to fill in the gaps to make it work correctly. For example, this snippet should create a connection in the load balancer, assign it to a running server and then the load should be more than zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.88706898665605\n"
     ]
    }
   ],
   "source": [
    "l = LoadBalancing()\n",
    "l.add_connection(\"fdca:83d2::f20d\")\n",
    "print(l.avg_load())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After running the above code, the output is 0.  Fill in the missing parts for the `add_connection` and `avg_load` methods of the LoadBalancing class to make this print the right load. Be sure that the load balancer now has an average load more than 0 before proceeding."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we add a new server?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.443534493328025\n"
     ]
    }
   ],
   "source": [
    "l.servers.append(Server())\n",
    "print(l.avg_load())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The average load should now be half of what it was before. If it's not, make sure you correctly fill in the missing gaps for the `add_connection` and `avg_load` methods so that this code works correctly. \n",
    "<br><br>\n",
    "**Hint:** You can iterate through the all servers in the *self.servers* list to get the total server load amount and then divide by the length of the *self.servers* list to compute the average load amount."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fantastic! Now what about closing the connection?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "l.close_connection(\"fdca:83d2::f20d\")\n",
    "print(l.avg_load())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fill in the code of the LoadBalancing class to make the load go back to zero once the connection is closed.\n",
    "<br><br>\n",
    "Great job! Before, we added a server manually. But we want this to happen automatically when the average load is more than 50%. To make this possible, fill in the missing code for the `ensure_availability` method and call it from the `add_connection` method after a connection has been added. You can test it with the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50.70%,51.14%,22.51%]\n"
     ]
    }
   ],
   "source": [
    "for connection in range(20):\n",
    "    l.add_connection(connection)\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code above adds 20 new connections and then prints the loads for each server in the load balancer.  If you coded correctly, new servers should have been added automatically to ensure that the average load of all servers is not more than 50%.\n",
    "<br><br>\n",
    "Run the following code to verify that the average load of the load balancer is not more than 50%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "41.45121370431007\n"
     ]
    }
   ],
   "source": [
    "print(l.avg_load())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Awesome! If the average load is indeed less than 50%, you are all done with this assessment."
   ]
  }
 ],
 "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.4"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}