Merge pull request #36 from cceckman/slongfield/coffee

Implement minimal RFC2324 🫖

Author: slongfield

http_server/parse_start.py

@@ -37,6 +37,7 @@ class ParseStart(Component):
     METHOD_NO_MATCH = 0
     METHOD_GET = 1
     METHOD_POST = 2
+    METHOD_BREW = 3
 
     PROTOCOL_NO_MATCH = 0
     PROTOCOL_HTTP1_0 = 1
@@ -46,7 +47,7 @@ def __init__(self, paths):
             "input": In(stream.Signature(8)),
             "reset": In(1),
             "done": Out(1),
-            "method": Out(3),
+            "method": Out(4),
             "path": Out(len(paths)+1),
             "protocol": Out(2),
         })
@@ -68,12 +69,16 @@ def elaborate(self, _platform):
         resets.append(post_matcher.reset)
         m.d.comb += self.method[self.METHOD_POST].eq(post_matcher.accepted)
 
+        brew_matcher = m.submodules.brew_matcher = StringContainsMatch("BREW")
+        resets.append(brew_matcher.reset)
+        m.d.comb += self.method[self.METHOD_BREW].eq(brew_matcher.accepted)
+
         any_method_match = stream_utils.tree_or(
-            m, [get_matcher.accepted, post_matcher.accepted])
+            m, [get_matcher.accepted, post_matcher.accepted, brew_matcher.accepted])
         m.d.comb += self.method[0].eq(~any_method_match)
 
         stream_utils.fanout_stream(
-            m, method_stream, [get_matcher.input, post_matcher.input])
+            m, method_stream, [get_matcher.input, post_matcher.input, brew_matcher.input])
 
         path_stream = stream.Signature(8).create()
         path_streams = []

http_server/simple_led_http.py

@@ -47,10 +47,10 @@ def elaborate(self, _platform):
         parser_demux = m.submodules.parser_demux = StreamDemux(mux_width=4, stream_width=8)
         connect(m, self.session.inbound.data, parser_demux.input)
 
-        # TODO: #4 - Add packet count and RFC2324 endpoints
         MATCHED_LED_PATH = 1 # start_matcher path match is in the order the paths are connected.
         MATCHED_COUNT_PATH = 2
-        start_matcher = m.submodules.start_matcher = ParseStart(["/led", "/count"])
+        MATCHED_COFFEE_PATH = 3
+        start_matcher = m.submodules.start_matcher = ParseStart(["/led", "/count", "/coffee"])
         HTTP_PARSER_START = 0
         connect(m, start_matcher.input, parser_demux.outs[HTTP_PARSER_START])
 
@@ -72,7 +72,7 @@ def elaborate(self, _platform):
         m.d.comb += parser_demux.outs[HTTP_PARSER_SINK].ready.eq(1)
 
         ## Responders
-        response_mux = m.submodules.response_mux = StreamMux(mux_width=4, stream_width=8)
+        response_mux = m.submodules.response_mux = StreamMux(mux_width=5, stream_width=8)
         connect(m, response_mux.out, self.session.outbound.data)
         count_body = m.submodules.count_body = CountBody()
 
@@ -130,7 +130,25 @@ def elaborate(self, _platform):
                 count_body.inc_error.eq(1),
         ]
 
-        RESPONSE_COUNT = 3
+        teapot_response = "\r\n".join(
+                ["HTTP/1.0 418 I'm a teapot",
+                    "Host: Fomu",
+                    "Content-Type: text/plain; charset=utf-8",
+                    "",
+                    "",
+                    "short and stout"]) + "\r\n"
+        teapot_response = teapot_response.encode("utf-8")
+        teapot_printer = m.submodules.teapot_printer = Printer(teapot_response)
+        RESPONSE_TEAPOT = 3
+        connect(m, teapot_printer.output, response_mux.input[RESPONSE_TEAPOT])
+        send_teapot = [
+                response_mux.select.eq(RESPONSE_TEAPOT),
+                parser_demux.select.eq(HTTP_PARSER_SINK),
+                teapot_printer.en.eq(1),
+                count_body.inc_error.eq(1),
+        ]
+
+        RESPONSE_COUNT = 4
         connect(m, count_body.output, response_mux.input[RESPONSE_COUNT])
         send_count = [
                 response_mux.select.eq(RESPONSE_COUNT),
@@ -185,6 +203,14 @@ def elaborate(self, _platform):
                         with m.Else():
                             m.next = "writing"
                             m.d.sync += send_405
+                    with m.Elif(start_matcher.path[MATCHED_COFFEE_PATH]):
+                        with m.If(start_matcher.method[start_matcher.METHOD_GET] 
+                                  | start_matcher.method[start_matcher.METHOD_BREW]): 
+                            m.next = "writing"
+                            m.d.sync += send_teapot
+                        with m.Else():
+                            m.next = "writing"
+                            m.d.sync += send_405
                     with m.Else():
                         m.next = "writing"
                         m.d.sync += send_404
@@ -218,6 +244,7 @@ def elaborate(self, _platform):
                         ok_printer.en.eq(0),
                         not_found_printer.en.eq(0),
                         not_allowed_printer.en.eq(0),
+                        teapot_printer.en.eq(0),
                         count_body.en.eq(0),
                         self.session.outbound.active.eq(1),
                         count_body.inc_ok.eq(0),
@@ -226,7 +253,8 @@ def elaborate(self, _platform):
                 with m.If(  ((response_mux.select == RESPONSE_OK) & ok_printer.done)
                           | ((response_mux.select == RESPONSE_404) & not_found_printer.done)
                           | ((response_mux.select == RESPONSE_405) & not_allowed_printer.done)
-                          | ((response_mux.select == RESPONSE_COUNT) & count_body.done)):
+                          | ((response_mux.select == RESPONSE_COUNT) & count_body.done)
+                          | ((response_mux.select == RESPONSE_TEAPOT) & teapot_printer.done)):
                     m.d.sync += self.session.outbound.active.eq(0)
                     # Can finish writing before all the input is collected,
                     # since a bad request migh trigger an early 404. Wait

http_server/simple_led_http_test.py

@@ -177,6 +177,13 @@ def test_count_handling():
              "\r\n"
              "\r\n"
              "123456\r\n")
+    error_input = ("BREW /cocoa HTTP/1.0\r\n"
+             "Host: test\r\n"
+             "User-Agent: test-agent\r\n"
+             "Content-Type: text/plain\r\n"
+             "\r\n"
+             "\r\n"
+             "With marshmallows, please\r\n")
     count_input = ("GET /count HTTP/1.0\r\n"
              "Host: test\r\n"
              "User-Agent: test-agent\r\n"
@@ -191,13 +198,19 @@ def test_count_handling():
                        "\r\n"
                        "\r\n"
                        "👍\r\n"
+                       "HTTP/1.0 404 Not Found\r\n"
+                       "Host: Fomu\r\n"
+                       "Content-Type: text/plain; charset=utf-8\r\n"
+                       "\r\n"
+                       "\r\n"
+                       "👎\r\n"
                        "HTTP/1.0 200 OK\r\n"
                        "Host: Fomu\r\n"
                        "Content-Type: text/plain; charset=utf-8\r\n"
                        "\r\n"
                        "\r\n"
                        "👍\r\n"
-                       "requests: 0002 ok_responses: 0002 error_responses: 0000")
+                       "requests: 0003 ok_responses: 0002 error_responses: 0001")
 
     async def driver(ctx):
 
@@ -220,6 +233,7 @@ async def send_data(data):
             # assert not ctx.get(dut.session.outbound.data.valid)
 
         await send_data(led_input)
+        await send_data(error_input)
         await send_data(count_input)
 
         assert ctx.get(dut.red) == 0x12
@@ -238,3 +252,53 @@ async def send_data(data):
 
     # Now that the test is done:
     collector.assert_eq(expected_output)
+
+def test_coffee_handling():
+    dut = SimpleLedHttp()
+    sim = Simulator(dut)
+    sim.add_clock(1e-6)
+
+    input = ("BREW /coffee HTTP/1.0\r\n"
+             "Host: curious_test\r\n"
+             "User-Agent: evil-agent\r\n"
+             "Content-Type: text/bad\r\n"
+             "\r\n"
+             "\r\n"
+             "Black, medium roast Ethiopian, pour over\r\n")
+    expected_output = ("HTTP/1.0 418 I'm a teapot\r\n"
+                       "Host: Fomu\r\n"
+                       "Content-Type: text/plain; charset=utf-8\r\n"
+                       "\r\n"
+                       "\r\n"
+                       "short and stout\r\n")
+
+    async def driver(ctx):
+        ctx.set(dut.session.inbound.active, 1)
+        await ctx.tick().until(dut.session.outbound.active)
+
+        in_stream = dut.session.inbound.data
+        ctx.set(in_stream.valid, 1)
+        idx = 0
+        while idx < len(input):
+            ctx.set(in_stream.payload, ord(input[idx]))
+            if ctx.get(in_stream.ready):
+                idx += 1
+            await ctx.tick()
+        # After all input data is read, deassert inbound session
+        ctx.set(dut.session.inbound.active, 0)
+        # Keep driving clock until the outbound session is deasserted
+        await ctx.tick().until(~dut.session.outbound.active)
+        assert not ctx.get(dut.session.outbound.data.valid)
+
+        # Add some nice margins for our vcd
+        await ctx.tick()
+
+    sim.add_testbench(driver)
+
+    collector = StreamCollector(stream=dut.session.outbound.data)
+    sim.add_process(collector.collect())
+
+    sim.run_until(0.001)
+
+    # Now that the test is done:
+    collector.assert_eq(expected_output)