attempt fixing content type issue (#83)

buggy headers look like:

```
{Fn-Http-Status=[200], Opc-Request-Id=[/01DBJASGQY1BT1AHGZJ000PC8D/01DBJASGQY1BT1AHGZJ000PC8E], Connection=[keep-alive], Fn-Call-Id=[01DBJASGRW1BT1AHGZJ000PC8F], Fn-Http-H-Content-Type=[application/json], Content-Length=[462], Date=[Thu, 23 May 2019 12:31:35 GMT], Content-Type=[None]}
```

but should have `Content-Type: [application/json]` and not
`Content-Type:[None]` nor `Fn-Http-H-Content-Type`

* removes content type from encap headers, which was just ripping content type
out of the headers bucket anyway - just leave in the headers bucket, since it
wasn't removing it from the header bucket for usage, it was a confusing
contract.
* actually use the gateway headers if Fn-Intent=httprequest ("the contract"),
we weren't checking this at all or stripping gateway headers when we need to
* only encap the headers for gateway responses instead of for both invoke and
gateway responses
* no more default of `Content-Type: text/plain`
* fix up test fixtures

we should probably have separate types of contexts like things were before
this, but we should maybe use inheritance - I tried this, but didn't get it
working, though now I think it was a separate issue why I didn't get it
working. anyway, this fixes the bug(s) in invoke. gateway headers were not
being used nor well tested anyway (well, because it was defaulting to them
confusingly), so we could patch later.

Author: rdallman

fdk/async_http/server.py

@@ -186,8 +186,8 @@ def serve(
 
     # Register signals for graceful termination
     if register_sys_signals:
-        _singals = (SIGTERM,) if run_multiple else (SIGINT, SIGTERM)
-        for _signal in _singals:
+        _signals = (SIGTERM,) if run_multiple else (SIGINT, SIGTERM)
+        for _signal in _signals:
             try:
                 loop.add_signal_handler(_signal, loop.stop)
             except NotImplementedError:

fdk/constants.py

@@ -17,8 +17,10 @@
 ASYNC_IO_READ_BUFFER = 65536
 DEFAULT_DEADLINE = 30
 HTTPSTREAM = "http-stream"
+INTENT_HTTP_REQUEST = "httprequest"
 FN_FORMAT = "FN_FORMAT"
 FN_LISTENER = "FN_LISTENER"
+FN_INTENT = "Fn-Intent"
 FN_HTTP_PREFIX = "Fn-Http-H-"
 FN_HTTP_STATUS = "Fn-Http-Status"
 FN_DEADLINE = "fn-deadline"
@@ -27,7 +29,7 @@
 FN_HTTP_METHOD = "fn-http-method"
 FN_APP_ID = "FN_APP_ID"
 FN_ID = "FN_FN_ID"
-CONTENT_TYPE = "content-type"
+CONTENT_TYPE = "Content-Type"
 CONTENT_LENGTH = "Content-Length"
 FN_ENFORCED_RESPONSE_CODES = [200, 502, 504]
 FN_DEFAULT_RESPONSE_CODE = 200

fdk/context.py

@@ -20,33 +20,6 @@
 from fdk import headers as hs
 
 
-def set_response_headers(
-        current_headers: dict, new_headers: dict,
-        status_code: int, content_type: str=None):
-    """
-    Sets Fn-readable headers
-    :param current_headers: current HTTP headers
-    :type current_headers: dict
-    :param new_headers: new HTTP headers to add
-    :type new_headers: dict
-    :param status_code: HTTP status code
-    :type status_code: int
-    :param content_type: response content type
-    :type content_type: str
-    :return: updated headers
-    :rtype: dict
-    """
-    new_headers = hs.encap_headers(
-        new_headers,
-        status=status_code,
-        content_type=content_type
-    )
-    for k, v in new_headers.items():
-        current_headers[k] = v
-
-    return current_headers
-
-
 class InvokeContext(object):
 
     def __init__(self, app_id, fn_id, call_id,
@@ -90,6 +63,9 @@ def __init__(self, app_id, fn_id, call_id,
         self.__response_headers = {}
         self.__fn_format = fn_format
 
+        if self.__is_gateway():
+            self.__headers = hs.decap_headers(self.__headers)
+
     def AppID(self):
         return self.__app_id
 
@@ -115,48 +91,26 @@ def Deadline(self):
             return now.isoformat()
         return self.__deadline
 
-    def SetResponseHeaders(self, headers, status_code, content_type=None):
-        self.__response_headers = set_response_headers(
-            self.GetResponseHeaders(), headers, status_code,
-            content_type=content_type)
+    def SetResponseHeaders(self, headers, status_code):
+        if self.__is_gateway():
+            headers = hs.encap_headers(headers, status=status_code)
+
+        for k, v in headers.items():
+            self.__response_headers[k] = v
 
     def GetResponseHeaders(self):
         return self.__response_headers
 
-    def HTTPContext(self):
-        return HTTPGatewayContext(self)
-
-
-class HTTPGatewayContext(object):
-    def __init__(self, invoke_context: InvokeContext):
-        """
-        Creates an instance of an HTTP context
-        :param invoke_context: invoke context:
-        :type invoke_context: fdk.context.InvokeContext
-        """
-        self.__headers = hs.decap_headers(invoke_context.Headers())
-        self.__invoke_context = invoke_context
-        self.__response_headers = {}
-
     def RequestURL(self):
         return self.__invoke_context._request_url
 
     def Method(self):
         return self.__invoke_context._method
 
-    def Headers(self):
-        return self.__headers
-
-    def SetResponseHeaders(self, headers, status_code, content_type=None):
-        self.__response_headers = set_response_headers(
-            self.GetResponseHeaders(), headers, status_code,
-            content_type=content_type)
-
-    def GetResponseHeaders(self):
-        return self.__response_headers
-
-    def Format(self):
-        return self.__invoke_context.Format()
+    def __is_gateway(self):
+        return (constants.FN_INTENT in self.__headers and
+                self.__headers.get(constants.FN_INTENT) ==
+                constants.INTENT_HTTP_REQUEST)
 
 
 def context_from_format(format_def: str, **kwargs) -> (

fdk/fixtures.py

@@ -15,31 +15,24 @@
 import datetime as dt
 
 from fdk import constants
-from fdk import headers as hs
 from fdk import runner
+from fdk import headers as hs
 
 
 async def process_response(fn_call_coro):
-    new_headers = {}
     resp = await fn_call_coro
     response_data = resp.body()
     response_status = resp.status()
     response_headers = resp.context().GetResponseHeaders()
-    for k, v in response_headers.items():
-        new_headers.update({
-            k.lstrip(constants.FN_HTTP_PREFIX): v
-        })
     print(response_headers)
-    resp_headers = hs.decap_headers(response_headers)
-    del resp_headers[constants.FN_HTTP_STATUS]
 
-    return response_data, response_status, resp_headers
+    return response_data, response_status, response_headers
 
 
 class fake_request(object):
 
-    def __init__(self):
-        self.headers = setup_headers()
+    def __init__(self, gateway=False):
+        self.headers = setup_headers(gateway=gateway)
         self.body = b''
 
 
@@ -53,35 +46,43 @@ def handler(self):
 
 
 def setup_headers(deadline=None, headers=None,
-                  request_url="/", method="POST"):
+                  request_url="/", method="POST", gateway=False):
     new_headers = {}
-    if headers is not None:
+
+    if gateway:
+        new_headers = hs.encap_headers(headers)
+        new_headers.update({
+            constants.FN_INTENT: constants.INTENT_HTTP_REQUEST,
+            constants.FN_HTTP_REQUEST_URL: request_url,
+            constants.FN_HTTP_METHOD: method,
+        })
+    elif headers is not None:
         for k, v in headers.items():
-            new_headers.update({constants.FN_HTTP_PREFIX + k: v})
+            new_headers.update({k: v})
 
     if deadline is None:
         now = dt.datetime.now(dt.timezone.utc).astimezone()
         now += dt.timedelta(0, float(constants.DEFAULT_DEADLINE))
         deadline = now.isoformat()
 
-    new_headers.update({
-        constants.FN_DEADLINE: deadline,
-        constants.FN_HTTP_REQUEST_URL: request_url,
-        constants.FN_HTTP_METHOD: method,
-    })
+    new_headers.update({constants.FN_DEADLINE: deadline})
     return new_headers
 
 
 async def setup_fn_call(
         handle_func, request_url="/",
         method="POST", headers=None,
-        content=None, deadline=None):
+        content=None, deadline=None,
+        gateway=False):
 
     new_headers = setup_headers(
         deadline=deadline, headers=headers,
-        method=method, request_url=request_url
+        method=method, request_url=request_url,
+        gateway=gateway
     )
 
+    # don't decap headers, so we can test them
+    # (just like they come out of fdk)
     return process_response(runner.handle_request(
         code(handle_func), constants.HTTPSTREAM,
         headers=new_headers, data=content,

fdk/headers.py

@@ -17,23 +17,25 @@
 
 def decap_headers(hdsr):
     ctx_headers = {}
-    for k, v in hdsr.items():
-        if k.startswith(constants.FN_HTTP_PREFIX):
-            ctx_headers[k.lstrip(constants.FN_HTTP_PREFIX)] = v
-        else:
-            ctx_headers[k] = v
+    if hdsr is not None:
+        for k, v in hdsr.items():
+            if k.startswith(constants.FN_HTTP_PREFIX):
+                ctx_headers[k.lstrip(constants.FN_HTTP_PREFIX)] = v
+            else:
+                ctx_headers[k] = v
     return ctx_headers
 
 
-def encap_headers(headers, status=None, content_type=None):
+def encap_headers(headers, status=None):
     new_headers = {}
-    for k, v in headers.items():
-        if (not k.startswith(constants.CONTENT_TYPE) and
-                not k.startswith(constants.CONTENT_TYPE)):
-            new_headers[constants.FN_HTTP_PREFIX + k] = v
+    if headers is not None:
+        for k, v in headers.items():
+            if (k == constants.CONTENT_TYPE or
+                    k.startswith(constants.FN_HTTP_PREFIX)):
+                new_headers[k] = v
+            else:
+                new_headers[constants.FN_HTTP_PREFIX + k] = v
 
     if status is not None:
         new_headers[constants.FN_HTTP_STATUS] = str(status)
-    if content_type is not None:
-        new_headers[constants.CONTENT_TYPE] = content_type
     return new_headers

fdk/response.py

@@ -13,7 +13,6 @@
 #    under the License.
 
 from fdk import context
-from fdk import constants
 
 
 class Response(object):
@@ -38,11 +37,7 @@ def __init__(self, ctx: context.InvokeContext,
         self.response_data = response_data if response_data else ""
         if headers is None:
             headers = {}
-        ctx.SetResponseHeaders(
-            headers, status_code,
-            content_type=headers.get(
-                constants.CONTENT_TYPE, "text/plain")
-        )
+        ctx.SetResponseHeaders(headers, status_code)
         self.ctx = ctx
 
     def status(self):

fdk/tests/funcs.py

@@ -51,19 +51,15 @@ def dummy_func(ctx, data=None):
 
 
 def encaped_header(ctx, **kwargs):
-    httpctx = ctx.HTTPContext()
-    hs = httpctx.Headers()
-    v = hs.get("custom-header-maybe")
     return response.Response(
-        httpctx, response_data="OK", status_code=200,
-        headers={"Content-Type": "text/plain",
-                 "custom-header-maybe": v})
+        ctx, response_data="OK", status_code=200,
+        headers=ctx.Headers())
 
 
 def content_type(ctx, data=None):
     return response.Response(
         ctx, response_data="OK", status_code=200,
-        headers={"Content-Type": "text/plain"})
+        headers={"Content-Type": "application/json"})
 
 
 def custom_response(ctx, data=None):
@@ -118,12 +114,11 @@ def verify_request_headers(ctx, **kwargs):
 
 
 def access_request_url(ctx, **kwargs):
-    httpctx = ctx.HTTPContext()
-    hs = httpctx.Headers()
-    method = httpctx.Method()
+    hs = ctx.Headers()
+    method = ctx.Method()
     request_url = hs.get("Fn-Http-Request-Url")
     return response.Response(
-        httpctx, response_data="OK", headers={
+        ctx, response_data="OK", headers={
             "Response-Request-URL": request_url,
             "Request-Method": method,
         }