Remove IPC

Author: NickSeagull

app/Main.hs

@@ -1,5 +1,5 @@
 name: aws-lambda-haskell-runtime
-version: 1.1.1
+version: 2.0.0
 github: "theam/aws-lambda-haskell-runtime"
 license: Apache-2.0
 author: Nikita Tchayka
@@ -23,11 +23,8 @@ library:
     - bytestring
     - http-client
     - http-types
-    - optparse-generic
-    - process
     - template-haskell
     - text
-    - uuid
     - safe-exceptions-checked
     - path
     - path-io
@@ -36,14 +33,6 @@ library:
     - Aws.Lambda
     - Aws.Lambda.Runtime
 
-executables:
-  bootstrap-lol:
-    source-dirs: app
-    main: Main.hs
-    dependencies:
-      - aws-lambda-haskell-runtime
-      - http-client
-
 tests:
   aws-lambda-haskell-runtime-test:
     main: Spec.hs

package.yaml

@@ -1,36 +1,22 @@
 {-# OPTIONS_GHC -fno-warn-unused-pattern-binds #-}
 module Aws.Lambda.Configuration
   ( Main.LambdaOptions(..)
-  , Main.getRecord
   , configureLambda
-  , bootstrapLambda
-  , IPC.returnAndFail
-  , IPC.returnAndSucceed
   , Dispatch.decodeObj
-  , DispatchNoIPC.encodeObj
+  , Dispatch.encodeObj
   )
 where
 
 import qualified Language.Haskell.TH as Meta
 
 import qualified Aws.Lambda.Meta.Dispatch as Dispatch
-import qualified Aws.Lambda.Meta.DispatchNoIPC as DispatchNoIPC
 import qualified Aws.Lambda.Meta.Main as Main
 import qualified Aws.Lambda.Meta.Run as Run
-import qualified Aws.Lambda.Runtime.IPC as IPC
 
-{-| Generates a @main@ function to be used with the
-AWS Lambda layer.
+{-| Generates a @main@ function that acts as a dispatcher
 -}
 configureLambda :: Meta.DecsQ
 configureLambda = do
-  main <- Main.generateIPC
+  main <- Main.generate
   run <- Run.generate
   return (main <> [run])
-
-{-| -}
-bootstrapLambda :: Meta.DecsQ
-bootstrapLambda = do
-  main <- Main.generateDirectCall
-  run <- Run.generateNoIPC
-  return (main <> [run])

src/Aws/Lambda/Configuration.hs

@@ -2,6 +2,8 @@
 module Aws.Lambda.Meta.Dispatch
   ( generate
   , decodeObj
+  , encodeObj
+  , Runtime.LambdaResult(..)
   ) where
 
 import Data.Function ((&))
@@ -13,6 +15,7 @@ import qualified Data.ByteString.Lazy.Char8 as LazyByteString
 import qualified Language.Haskell.TH as Meta
 
 import Aws.Lambda.Meta.Common
+import qualified Aws.Lambda.Runtime.Common as Runtime
 
 {-| Helper function that the dispatcher will use to
 decode the JSON that comes as an AWS Lambda event into the
@@ -24,6 +27,14 @@ decodeObj x =
     Left e  -> error e
     Right v -> v
 
+{-| Helper function that the dispatcher will use to
+decode the JSON that comes as an AWS Lambda event into the
+appropriate type expected by the handler.
+-}
+encodeObj :: ToJSON a => a -> String
+encodeObj x = LazyByteString.unpack (encode x)
+
+
 {-| Generates the dispatcher out of a list of
 handler names in the form @src/Foo/Bar.handler@
 
@@ -43,7 +54,7 @@ handlerCase lambdaHandler = do
   let pat = Meta.LitP (Meta.StringL $ Text.unpack lambdaHandler)
   body <- [e|do
     result <- $(expressionName qualifiedName) (decodeObj $(expressionName "eventObject")) (decodeObj $(expressionName "contextObject"))
-    either (returnAndFail $(expressionName "executionUuid")) (returnAndSucceed $(expressionName "executionUuid")) result |]
+    either (pure . Left . encodeObj) (pure . Right . $(constructorName "LambdaResult") . encodeObj) result |]
   pure $ Meta.Match pat (Meta.NormalB body) []
  where
   qualifiedName =
@@ -56,6 +67,6 @@ unmatchedCase :: Meta.MatchQ
 unmatchedCase = do
   let pattern = Meta.WildP
   body <- [e|
-    returnAndFail $(expressionName "executionUuid") ("Handler " <> $(expressionName "functionHandler") <> " does not exist on project")
+    pure $ Left ("Handler " <> $(expressionName "functionHandler") <> " does not exist on project")
     |]
   pure $ Meta.Match pattern (Meta.NormalB body) []

src/Aws/Lambda/Meta/Dispatch.hs

@@ -1,29 +1,21 @@
 {-| main function generation for interoperation with the layer -}
 module Aws.Lambda.Meta.Main
   ( Runtime.LambdaOptions(..)
-  , generateIPC
-  , generateDirectCall
-  , Options.getRecord
+  , generate
   ) where
 
 import qualified Language.Haskell.TH as Meta
-import qualified Options.Generic as Options
 
 import Aws.Lambda.Meta.Common
 import qualified Aws.Lambda.Runtime.Common as Runtime
 
--- | Generate the main function that the layer will call
-generateIPC :: Meta.DecsQ
-generateIPC = [d|
-  $(declarationName "main") = getRecord "" >>= run
-  |]
-
-generateDirectCall :: Meta.DecsQ
-generateDirectCall = [d|
+-- | Generate the main function with the dispatcher
+generate :: Meta.DecsQ
+generate = [d|
   $(declarationName "main") = $(directCallBody)
   |]
  where
   directCallBody =
     [e|do
-    runLambda $ $(constructorName "DirectCall") run
+    runLambda run
     |]

src/Aws/Lambda/Meta/DispatchNoIPC.hs

@@ -1,31 +1,16 @@
 module Aws.Lambda.Meta.Run
   ( generate
-  , generateNoIPC
   ) where
 
 import qualified Language.Haskell.TH as Meta
 
 import Aws.Lambda.Meta.Common
 import qualified Aws.Lambda.Meta.Discover as Discover
 import qualified Aws.Lambda.Meta.Dispatch as Dispatch
-import qualified Aws.Lambda.Meta.DispatchNoIPC as DispatchNoIPC
 
-{-| Generate the run function
-
-It will create a dispatcher that is a huge @case@ expression that
-expects the name of the handler provided by AWS Lambda, and will
-execute the appropriate user function
- -}
 generate :: Meta.DecQ
 generate = do
   handlers <- Meta.runIO Discover.handlers
   clause' <- getFieldsFrom "LambdaOptions" ["functionHandler", "contextObject", "eventObject", "executionUuid"]
   body <- Dispatch.generate handlers
   pure $ Meta.FunD (Meta.mkName "run") [Meta.Clause [clause'] (Meta.NormalB body) []]
-
-generateNoIPC :: Meta.DecQ
-generateNoIPC = do
-  handlers <- Meta.runIO Discover.handlers
-  clause' <- getFieldsFrom "LambdaOptions" ["functionHandler", "contextObject", "eventObject", "executionUuid"]
-  body <- DispatchNoIPC.generate handlers
-  pure $ Meta.FunD (Meta.mkName "run") [Meta.Clause [clause'] (Meta.NormalB body) []]

src/Aws/Lambda/Meta/Main.hs

@@ -1,6 +1,5 @@
 module Aws.Lambda.Runtime
   ( runLambda
-  , Runtime.Mode(..)
   , Runtime.LambdaResult(..)
   ) where
 
@@ -15,20 +14,19 @@ import qualified Aws.Lambda.Runtime.ApiInfo as ApiInfo
 import qualified Aws.Lambda.Runtime.Context as Context
 import qualified Aws.Lambda.Runtime.Environment as Environment
 import qualified Aws.Lambda.Runtime.Error as Error
-import qualified Aws.Lambda.Runtime.IPC as IPC
 import qualified Aws.Lambda.Runtime.Publish as Publish
 import qualified Aws.Lambda.Runtime.Common as Runtime
 
 -- | Runs the user @haskell_lambda@ executable and posts back the
 -- results. This is called from the layer's @main@ function.
-runLambda :: Runtime.Mode -> IO ()
-runLambda mode = do
+runLambda :: Runtime.RunCallback -> IO ()
+runLambda callback = do
   manager <- Http.newManager httpManagerSettings
   forever $ do
     lambdaApi <- Environment.apiEndpoint `catch` variableNotSet
     event     <- ApiInfo.fetchEvent manager lambdaApi `catch` errorParsing
     context   <- Context.initialize event `catch` errorParsing `catch` variableNotSet
-    ((invokeAndRun mode manager lambdaApi event context
+    ((invokeAndRun callback manager lambdaApi event context
       `catch` \err -> Publish.parsingError err lambdaApi context manager)
       `catch` \err -> Publish.invocationError err lambdaApi context manager)
       `catch` \(err :: Error.EnvironmentVariableNotSet) -> Publish.runtimeInitError err lambdaApi context manager
@@ -41,45 +39,40 @@ httpManagerSettings =
   }
 
 invokeAndRun
-  :: Throws Error.Parsing
-  => Throws Error.Invocation
+  :: Throws Error.Invocation
   => Throws Error.EnvironmentVariableNotSet
-  => Runtime.Mode
+  => Runtime.RunCallback
   -> Http.Manager
   -> String
   -> ApiInfo.Event
   -> Context.Context
   -> IO ()
-invokeAndRun mode manager lambdaApi event context = do
-  result    <- invokeWithMode mode event context
+invokeAndRun callback manager lambdaApi event context = do
+  result    <- invokeWithMode callback event context
   Publish.result result lambdaApi context manager
     `catch` \err -> Publish.invocationError err lambdaApi context manager
 
 invokeWithMode
   :: Throws Error.Invocation
-  => Throws Error.Parsing
   => Throws Error.EnvironmentVariableNotSet
-  => Runtime.Mode
+  => Runtime.RunCallback
   -> ApiInfo.Event
   -> Context.Context
   -> IO Runtime.LambdaResult
-invokeWithMode mode event context =
-  case mode of
-    Runtime.IPC -> IPC.invoke (ApiInfo.event event) context
-    (Runtime.DirectCall f) -> do
-      handlerName <- Environment.handlerName
-      let lambdaOptions = Runtime.LambdaOptions
-                          { eventObject = LazyByteString.unpack $ ApiInfo.event event
-                          , contextObject = LazyByteString.unpack . encode $ context
-                          , functionHandler = handlerName
-                          , executionUuid = ""  -- DirectCall doesnt use UUID
-                          }
-      result <- f lambdaOptions
-      case result of
-        Left err ->
-          throw $ Error.Invocation err
-        Right value ->
-          pure value
+invokeWithMode callback event context = do
+  handlerName <- Environment.handlerName
+  let lambdaOptions = Runtime.LambdaOptions
+                      { eventObject = LazyByteString.unpack $ ApiInfo.event event
+                      , contextObject = LazyByteString.unpack . encode $ context
+                      , functionHandler = handlerName
+                      , executionUuid = ""  -- DirectCall doesnt use UUID
+                      }
+  result <- callback lambdaOptions
+  case result of
+    Left err ->
+      throw $ Error.Invocation err
+    Right value ->
+      pure value
 
 variableNotSet :: Error.EnvironmentVariableNotSet -> IO a
 variableNotSet (Error.EnvironmentVariableNotSet env) =