fdk 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8958c018c5730c72cf314b69f19e7930ba7995fb3b1dddb3b012ebcf66dc6171
-  data.tar.gz: 915b07e47c9f919333e380d919f46abcc50a624bdae77153c503246f2ef61576
+  metadata.gz: aac4d4c8971ca0678bd3e99b95be2c87fc4aea50b9419535aee57bb09d4c0b73
+  data.tar.gz: 3fdf4848e9e940facde5a247ffdaf8b418079e65dbb0ac23ae3ed7c622c1f41e
 SHA512:
-  metadata.gz: 235b4bcf982c408099fa2f1713a4cc658af7c9ff86b61cf1e21bbd72645a39594a063f12b9d34c8e73a4b61931e6825f3f8411cd92dc0ede3d03406cd1e201d7
-  data.tar.gz: 5f506adf41f2df8e0d719b96162c438f8fec6dc118ea10bb8e08927cf9cda73b58ed3a9b35cae8ae7ca01f04e365a5ead1df5969b584e25519c600dbedb50e96
+  metadata.gz: 021b616d4b4cfd8c49b45f4d6c97d52fc04aaa2dab3756c5d927f76f54dbce304f32cf4a2bdba2ef43462fe0038e3bcab0ddbec53d12a3217fdba7a77c0baaf2
+  data.tar.gz: c07e62e577f503dc5ca974be179dc878aac12306fde3603c6623709d68c46fea09811ed3606a949123dc14be2110f653f1682650568c05e85bea00abe4e6253c

data/README.md

@@ -13,7 +13,7 @@ require 'fdk`
 Then create a function with with the following syntax:
 
 ```ruby
-def myfunc(context, input) 
+def myfunc(context, input)
     # Do some work here
     return output
 end
@@ -28,7 +28,7 @@ end
 Then simply pass that function to the FDK:
 
 ```ruby
-FDK.call(myfunc)
+FDK.handle(myfunction)
 ```
 
 ## Full Example
@@ -36,22 +36,39 @@ FDK.call(myfunc)
 ```ruby
 require 'fdk'
 
-def myhandler(context, input)
+def myfunction(context:, input:)
     STDERR.puts "request_url: " + context.protocol['request_url']
     STDERR.puts "call_id: " + context.call_id
     STDERR.puts "input: " + input.to_s
-    return {message: "Hello " + input['name'].to_s + "!"}
+    { message: "Hello #{input['name']}!" }
 end
 
-FDK.handle(:myhandler)
+FDK.handle(:myfunction)
 ```
 
 ## Running the example that is in the root directory of this repo
 
 ```sh
-echo '{"name":"coolio"}' | fn run
+$ echo '{"name":"coolio"}' | fn run
+{"message":"Hello coolio!"}
 ```
 
+You can also specify the format (the default is JSON)
+
+```sh
+$ echo '{"name":"coolio"}' | fn run --format json
+{"message":"Hello coolio!"}
+```
+
+If you want to just pass plain text to the function, specify a format of __default__:
+
+```sh
+$ echo 'coolio' | fn run --format default
+{"message":"Hello coolio!"}
+```
+
+Deploy:
+
 ```sh
 fn deploy --app myapp --local && echo '{"name":"coolio"}' | fn call myapp /fdk-ruby
 ```

data/lib/fdk/context.rb

@@ -1,52 +1,56 @@
 module FDK
 
-    # Config looks up values in the env vars
-    class Config
-        def [](key)
-            return ENV[key.upcase]
-        end
+  # Config looks up values in the env vars
+  class Config
+    def [](key)
+      ENV[key.upcase]
     end
+  end
 
-    class Context
+  class Context
 
-        # TODO: Rethink FN_PATH, if it's a reference to the route, maybe it should be FN_ROUTE? eg: if it's a dynamic path, this env var would 
-        #    show the route's path (ie: route identifier), eg: /users/:name, not the actual path.
+    # TODO: Rethink FN_PATH, if it's a reference to the route, maybe it should be FN_ROUTE? eg: if it's a dynamic path, this env var would
+    #    show the route's path (ie: route identifier), eg: /users/:name, not the actual path.
 
-        # FN_REQUEST_URL - the full URL for the request (parsing example)
-        # FN_APP_NAME - the name of the application that matched this route, eg: myapp
-        # FN_PATH - the matched route, eg: /hello
-        # FN_METHOD - the HTTP method for the request, eg: GET or POST
-        # FN_CALL_ID - a unique ID for each function execution.
-        # FN_FORMAT - a string representing one of the function formats, currently either default or http. Default is default.
-        # FN_MEMORY - a number representing the amount of memory available to the call, in MB
-        # FN_TYPE - the type for this call, currently 'sync' or 'async'
-        # FN_HEADER_$X - the HTTP headers that were set for this request. Replace $X with the upper cased name of the header and replace dashes in the header with underscores.
-        # $X - any configuration values you've set for the Application or the Route. Replace X with the upper cased name of the config variable you set. Ex: minio_secret=secret will be exposed via MINIO_SECRET env var.
-        # FN_PARAM_$Y
+    # FN_REQUEST_URL - the full URL for the request (parsing example)
+    # FN_APP_NAME - the name of the application that matched this route, eg: myapp
+    # FN_PATH - the matched route, eg: /hello
+    # FN_METHOD - the HTTP method for the request, eg: GET or POST
+    # FN_CALL_ID - a unique ID for each function execution.
+    # FN_FORMAT - a string representing one of the function formats, currently either default or http. Default is default.
+    # FN_MEMORY - a number representing the amount of memory available to the call, in MB
+    # FN_TYPE - the type for this call, currently 'sync' or 'async'
+    # FN_HEADER_$X - the HTTP headers that were set for this request. Replace $X with the upper cased name of the header and replace dashes in the header with underscores.
+    # $X - any configuration values you've set for the Application or the Route. Replace X with the upper cased name of the config variable you set. Ex: minio_secret=secret will be exposed via MINIO_SECRET env var.
+    # FN_PARAM_$Y
 
-        attr_reader :payload, :config
+    # CloudEvent format: https://github.com/cloudevents/spec/blob/master/serialization.md#json
 
-        def initialize(payload)
-            @payload = payload
-        end
+    attr_reader :event
 
-        def config
-            return @config if @config
-            @config = Config.new
-            return @config
-        end
+    def initialize(event)
+      @event = event
+    end
+
+    # If it's a CNCF CloudEvent
+    def cloud_event?
+      ENV['FN_FORMAT'] == "cloudevent"
+    end
 
-        def call_id
-            payload['call_id']
-        end
+    def config
+      @config ||= Config.new
+    end
 
-        def content_type
-            payload['content_type']
-        end
+    def call_id
+      cloud_event? ? event['eventID'] : event['call_id']
+    end
 
-        def protocol
-            payload['protocol']
-        end
+    def content_type
+      cloud_event? ? event['contentType'] : event['content_type']
+    end
 
+    def protocol
+      cloud_event? ? event['extensions']['protocol'] : event['protocol']
     end
+  end
 end

data/lib/fdk/runner.rb

@@ -3,123 +3,74 @@
 # Responds with output
 
 require 'json'
+require 'yajl'
 
 module FDK
+  def self.handle(func)
+    format = ENV['FN_FORMAT']
+    if format == 'cloudevent'
+      parser = Yajl::Parser.new
 
-    def self.handle(func)
-        # STDERR.puts `env`
-        format = ENV['FN_FORMAT']
-        if format == "json"
-            obs = ""
-            first_bracket = false
-            # end_bracket=false
-            stack_count = 0
-            STDIN.each_char do |c|
-                # STDERR.puts "c: #{c}"
-                if c == '{'
-                    if !first_bracket
-                        # STDERR.puts "setting first_bracket"
-                        first_bracket = true
-                    end
-                    stack_count += 1
-                elsif c == '}'
-                    stack_count -= 1
-                end
-                if first_bracket
-                    # STDERR.puts "in first_bracket stack_count: #{stack_count}"
-                    obs += c
-                    if stack_count == 0 # found last bracket, so close this out
-                        # STDERR.puts "OBJECT: #{obs}"
-                        payload = JSON.parse(obs)
-                        # STDERR.puts "payload: #{payload.inspect}"
-                        ctx = Context.new(payload)
-                        # STDERR.puts "context: " + ctx.inspect
-                        # STDERR.flush
-                        body = payload['body']
-                        if ctx.content_type == 'application/json' && body != ""
-                            body = JSON.parse(body)
-                        end
-                        # TODO: begin/rescue so we can respond with proper error response and code
-                        se = FDK.single_event(func, ctx, body)
-                        response = {
-                            headers: {
-                                'Content-Type' => 'application/json'
-                            },
-                            'status_code' => 200,
-                            body: se.to_json,
-                        }
-                        STDOUT.puts response.to_json
-                        STDOUT.puts
-                        STDOUT.flush
-                        first_bracket = false
-                        obs = ""
-                    end
-                end
-            end
+      parser.on_parse_complete = lambda do |event|
+        context = Context.new(event)
+        body = event['data']
+        # Skipping json parsing of body because it would already be a parsed map according to the format spec defined here: https://github.com/cloudevents/spec/blob/master/serialization.md#json
+        se = FDK.single_event(function: func, context: context, input: body)
 
-            # STDIN.each do |line|
-            #     STDERR.puts "LINE: --#{line}--"
-            #     STDERR.flush
-            #     ls = line.strip
-            #     STDERR.puts "ls: #{ls}"
-            #     if ls == "}"
-            #         # STDERR.puts "endbracket true"
-            #         endbracket=true
-            #     elsif ls == "" && endbracket
-            #         # TODO: this isn't very robust, probably needs to be better :/
-            #         STDERR.puts "OBJECT: #{obs}"
-            #         payload = JSON.parse(obs)
-            #         STDERR.puts "payload: #{payload.inspect}"
-            #         c = Context.new(payload)
-            #         STDERR.puts "context: " + c.inspect
-            #         STDERR.flush
-            #         body = payload['body']
-            #         if c.content_type == 'application/json'
-            #             body = JSON.parse(body)
-            #         end
-            #         # TODO: begin/rescue so we can respond with proper error response and code
-            #         s = FDK.single_event(func, c, body)
-            #         response = {
-            #             headers: {
-            #                 'Content-Type' => 'application/json'
-            #             },
-            #             'status_code' => 200,
-            #             body: s.to_json,
-            #         }
-            #         STDOUT.puts response.to_json
-            #         STDOUT.puts
-            #         STDOUT.flush
-            #         obs = ""
-            #         next
-            #     else 
-            #         endbracket = false
-            #     end
-            #     obs += line
-            # end
-        elsif format == "default"
-            # TODO: check if content type json, and if so, parse it before passing it in
-            body = STDIN.read
-            payload = {}
-            payload['call_id'] = ENV['FN_CALL_ID']
-            payload['content_type'] = ENV['FN_HEADER_Content_Type']
-            payload['protocol'] = {
-                'type' => 'http',
-                'request_url' => ENV['FN_REQUEST_URL']
-            }
-            # STDERR.puts "payload: #{payload}"
-            c = Context.new(payload)
-            if c.content_type == "application/json"
-                # STDERR.puts "parsing json"
-                body = JSON.parse(body)
-            end
-            puts FDK.single_event(func, c, body).to_json
-        else
-            raise "Format '#{format}' not supported in Ruby FDK."
+        # Respond with modified event
+        event['data'] = se
+        event['extensions']['protocol'] = {
+          headers: {
+              'Content-Type' => ['application/json']
+          },
+          'status_code' => 200,
+        }
+        STDOUT.puts event.to_json
+        STDOUT.puts
+        STDOUT.flush
+      end
+
+      STDIN.each_line { |line| parser.parse_chunk(line) }
+
+    elsif format == 'json'
+      parser = Yajl::Parser.new
+
+      parser.on_parse_complete = lambda do |event|
+        context = Context.new(event)
+        body = event['body']
+        if context.content_type == 'application/json' && body != ''
+          body = Yajl::Parser.parse(body)
         end
-    end
+        se = FDK.single_event(function: func, context: context, input: body)
+        response = {
+          headers: {
+            'Content-Type' => ['application/json']
+          },
+          'status_code' => 200,
+          body: se.to_json
+        }
+        STDOUT.puts response.to_json
+        STDOUT.puts
+        STDOUT.flush
+      end
+
+      STDIN.each_line { |line| parser.parse_chunk(line) }
 
-    def self.single_event(func, c, i)
-        s = send func, c, i
-        return s
+    elsif format == 'default'
+      event = {}
+      event['call_id'] = ENV['FN_CALL_ID']
+      event['protocol'] = {
+        'type' => 'http',
+        'request_url' => ENV['FN_REQUEST_URL']
+      }
+      c = Context.new(event)
+      puts FDK.single_event(function: func, context: c, input: STDIN.read).to_json
+    else
+      raise "Format '#{format}' not supported in Ruby FDK."
     end
+  end
+
+  def self.single_event(function:, context:, input:)
+    send function, context: context, input: input
+  end
 end

data/lib/fdk/version.rb

@@ -1,5 +1,3 @@
 module FDK
-
-    VERSION = "0.0.8"
-
-end
+  VERSION = "0.0.10"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fdk
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.10
 platform: ruby
 authors:
 - Travis Reeder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-02 00:00:00.000000000 Z
+date: 2018-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json