1 Overview

In this MP you will both build and use web service APIs. In particular,

• You’ll build a microservice that reports the weather of the next meeting of a given course
  • It will respond to POST requests with path /weather and one request body field, course
  • It will respond to GET requests with path /weatherCache
• You’ll use a microservice we provide that reports meeting times of a given course
  • It has a less-permissive course identification form than your service will have
  • You’ll need to figure out the date of the next meeting
• You’ll use the National Weather Service API to find the weather at a given time
  • This API uses request caps to prevent it being overrun with requests, so you will cache results to disk to avoid over-querying the API during testing

The code comes with a simple web front-end that lets you interact with your completed service through your web browser.

2 Initial Files

Initial files are available in mp8.zip, including one file you’ll edit:

• classweather.py

3 Courses Microservice

We have fully implemented a course meeting time microservice for you. You can find it in the courses_microservice directory. This, like the microservice you will implement, uses aiohttp to automate many of the tedious parts of running a webserver.

======== Running on http://0.0.0.0:34000 ========
(Press CTRL+C to quit)

{
  "course": "CS 340",
  "Days of Week": "TR",
  "Start Time": "02:00 PM"
}

{
  "course": "CS 300",
  "error": "CS 300 not found in schedule"
}

4 Machine Problem

Complete classweather.py such that

• POST /weather will respond with the weather forecast for the next meeting of the class provided in the request.

  The course will be supplied in a JSON object, inside object key "course". It may be in several forms (CS 340, cs340, or other such combinations). You may assume it is an all-alphabetic course mnemonic followed by a 3-digit course number.

• Meeting times are found from the course microservice.

  You must get the URL of the microservice from the system environment using the following code

  server_url = os.getenv('COURSES_MICROSERVICE_URL')

  This will give a URL with no path, like http://localhost:34000 (no trailing slash). We may change the URL during testing to ensure you are using the microservice correctly.

  The next meeting time is always in the future. If a course meets Tuesday/Thursday 2–3:15pm then on Thursday at 2:01pm the next meeting time is next-week Tuesday at 2 (5 days in the future), not this-week Thursday at 2 (1 minute in the past).

• Weather forecasts are found from the National Weather Service API.

  Use (40.11,-88.24) as the GPS coordinates for all locations.

  Use the forecast for the specific time that a course begins, rounded down to an integer hour. Do not account for holidays, end of semester, or the like.

  If you submit too many requests in a short time, the National Weather Service will see your computer as operating maliciously and will block future requests for several minutes or hours.

  Because of this, use your application sparingly until after you implement caching (see below).

• Cache weather forecasts; if we request the same course again, don’t contact the National Weather Service API for the second request, only the first.

• You must report the data back in a response JSON with the following structure with a status 200 response:

  {
    "course": "CS 340",
    "nextCourseMeeting": "2022-10-25 02:00:00",
    "forecastTime": "2022-10-25 02:00:00",
    "temperature": 60,
    "shortForecast": "Mostly Sunny"
  }

• The national weather service provides slightly less than a full week of hourly forecasts. If the next course meeting time is after the last forecast they have, respond with both "temperature" and "shortForecast" as "forecast unavailable":

  {
    "course": "CS 340",
    "nextCourseMeeting": "2022-10-19 02:00:00",
    "forecastTime": "2022-10-19 02:00:00",
    "temperature": "forecast unavailable",
    "shortForecast": "forecast unavailable"
  }

• On any other sort of error (ex: when the course cannot be found), respond with a status 400 response and a JSON object containing the key "error" and a message describing what went wrong.

• GET /weatherCache must return the current state of the cache as a JSON object. This must be an empty value ([], {}, or "") before any requests are made, and after at least one request is made it must include the forecasts for any course queried so far.

  return json_response(data=your_cache) is the recommended way to achieve this.

5 Tips

aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) # INSECURE!

whatever_you_name_your_cache = {}

def my_cached_function(args):
    global whatever_you_name_your_cache
    if args in whatever_you_name_your_cache:
        return whatever_you_name_your_cache[args]
    result = compute_from(args)
    whatever_you_name_your_cache[args] = result
    return result

6 Testing Your Application

A frontend has been provided for you to test your web application.

To run this front-end, you need to run the courses microservice and your app and give your app the URL of the microservice in an environment variable. We’ve provided a simple make start script to do this for you. Once you make start you can connect to http://localhost:5000/ (possibly replacing localhost with the full name of your VM) to view your app.

python3 courses_microservice/schedules.py &
COURSES_MICROSERVICE_URL=http://localhost:34000 python3 classweather.py