fdk 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cd1f63ae8fc93bda3870e3ce780994e84b99e386
-  data.tar.gz: 045eebb796bd9eaae7a190dbd10c3bbb390c61a6
+SHA256:
+  metadata.gz: a50737dfa816cbaa0d9de365617db0b1c393d47984529e6de1ac3fdf6e1f9167
+  data.tar.gz: 8e843ba19e95fc057ec571ec05dc6e4460761bfc5aa2f3bce81a4f068bfb31ed
 SHA512:
-  metadata.gz: 31677d766e3ae7d1dff6ccca614e5be549e5704dd2747406206496f3c2ec886fa48735d3fde66989b4840606b692f6b4cc2bde95da5c717f7ab5dedd2b70da57
-  data.tar.gz: 7a4d3a7d572e94f752ec2be0eacc44bcc49936643d7c9a63faf7ee57d4a832fa362a95c2daf095d5ad4718a06e469a853f1f2442bac21d6434157928983af2c3
+  metadata.gz: 67c53e7e572ca2a7f3c894ebe111b07fbf86df79e407ab10e2484e0479a0f67d02f45e504b46af9c5a2c81763994c6986e7f9a7d768ee8c341d175800b2bf013
+  data.tar.gz: ef3b16817052b5eee6ea90d7c0bbd8158446097a87df2db0d2dfad071beed80044c6bad14a8731064340909b3f9ae5ca6338498874864fae1d2709f6a3559f7e

data/README.md

@@ -26,7 +26,7 @@ an FDK::Response object instead of a string.
 Then simply pass that function to the FDK:
 
 ```ruby
-FDK.handle(:myfunction)
+FDK.handle(target: :myfunction)
 ```
 
 ## Examples
@@ -46,7 +46,7 @@ def myfunction(context:, input:)
   { message: "Hello #{name}!" }
 end
 
-FDK.handle(function: :myfunction)
+FDK.handle(target: :myfunction)
 ```
 
 ## Deploying functions
@@ -85,15 +85,7 @@ $ fn invoke examples hello
 To get a more personal message, send a name in a JSON format and set the
 `content-type 'application/json'`:
 ```
-echo '{"name":"Joe"}' | fn invoke examples hello --content-type
-'application/json'
+echo '{"name":"Joe"}' | fn invoke examples hello --content-type 'application/json'
 {"message":"Hello Joe!"}
 ```
 
-## Compare cold and hot functions
-
-Run [loop.rb](examples/loop.rb)
-
-```sh
-ruby loop.rb
-```

data/Rakefile

@@ -0,0 +1,5 @@
+task default: %w[test]
+
+task :test do
+	  ruby "tests/test_fdk.rb"
+end

data/lib/fdk/context.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 module FDK
 
   # Config looks up values in the env vars
@@ -7,50 +9,146 @@ module FDK
     end
   end
 
-  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.
+  class InHeaders
+    def initialize (h, key_fn)
+      @headers = h
+      @key_fn = key_fn
+
+    end
+
+    def headerKey(key)
+      if @key_fn
+        key = @key_fn.call(key)
+      end
+      key.downcase
+    end
+
+    def [](key)
+      h = @headers[headerKey(key)]
+      unless h.nil?
+        return h[0]
+      end
+      nil
+    end
+
+    def each (&block)
+      @headers.each &block
+    end
+  end
+
+  class OutHeaders < InHeaders
+
+    def initialize(h, key_in_fn)
+      super(h, key_in_fn)
+    end
+
 
+    def []=(key, value)
+      if value.is_a? Array
+        h = []
+        value.each {|x| h.push(x.to_s)}
+        @headers[headerKey(key)] = h
+      else
+        @headers[headerKey(key)] = [value.to_s]
+      end
+    end
+
+    def delete(key)
+      @headers.delete headerKey(key)
+    end
+  end
+
+
+  class Context
+
+    # FN_CALL_ID - a unique ID for each function execution.
     # FN_REQUEST_URL - the full URL for the request (parsing example)
+    # 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_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
 
-    # CloudEvent format: https://github.com/cloudevents/spec/blob/master/serialization.md#json
 
-    attr_reader :event
+    attr_reader :headers
+    attr_reader :response_headers
 
-    def initialize(event)
-      @event = event
+    def initialize(headers_in, headers_out)
+      @headers = headers_in
+      @response_headers = headers_out
+      @config ||= Config.new
     end
 
-    # If it's a CNCF CloudEvent
-    def cloud_event?
-      ENV['FN_FORMAT'] == "cloudevent"
+
+    def call_id
+      @headers['fn-call-id']
     end
 
-    def config
-      @config ||= Config.new
+
+    def app_id
+      @config['FN_APP_ID']
     end
 
-    def call_id
-      cloud_event? ? event['eventID'] : event['call_id']
+
+    def fn_id
+      @config['FN_FN_ID']
+    end
+
+    def deadline
+      DateTime.iso8601(@headers['fn-deadline'])
+    end
+
+    def memory
+      @config['FN_MEMORY'].to_i
     end
 
     def content_type
-      cloud_event? ? event['contentType'] : event['content_type']
+      @headers['content-type']
+    end
+
+    def http_context
+      HTTPContext.new(self)
+    end
+  end
+
+
+  class HTTPContext
+
+    attr_reader :headers
+    attr_reader :response_headers
+
+    def initialize(ctx)
+
+      @ctx = ctx
+
+
+      http_headers = {}
+      ctx.headers.each {|k, v|
+        if k.downcase.start_with?('fn-http-h-')
+          new_key = k['fn-http-h-'.length..k.length]
+          http_headers[new_key] = v
+        end
+      }
+
+      @headers = InHeaders.new(http_headers, nil)
+      @response_headers = OutHeaders.new(ctx.response_headers, lambda {|s| 'fn-http-h-' + s})
     end
 
-    def protocol
-      cloud_event? ? event['extensions']['protocol'] : event['protocol']
+
+    def request_url
+      @ctx.headers['fn-http-request-url']
     end
+
+    def method
+      @ctx.headers['fn-http-method']
+    end
+
+
+    def status_code=(val)
+      @ctx.response_headers['fn-http-status'] = val.to_i
+    end
+
   end
 end
+

data/lib/fdk/runner.rb

@@ -1,75 +1,150 @@
+require "webrick"
+require "fileutils"
+require "json"
+require "set"
+
 # Looks for call(context, input) function
 # Executes it with input
 # Responds with output
+module FDK
+  @filter_headers = Set["content-length", "te", "transfer-encoding",
+                        "upgrade", "trailer"]
 
-require 'json'
-require 'yajl'
+  def self.check_format
+    f = ENV["FN_FORMAT"]
+    raise "'#{f}' not supported in Ruby FDK." unless f == "http-stream"
 
-module FDK
-  def self.handle(function, input_stream: STDIN, output_stream: STDOUT)
-    format = ENV['FN_FORMAT']
-    if format == 'cloudevent'
-      parser = Yajl::Parser.new
-
-      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: function, context: context, input: body)
-
-        # Respond with modified event
-        event['data'] = se
-        event['extensions']['protocol'] = {
-          headers: {
-            'Content-Type' => ['application/json']
-          },
-          'status_code' => 200
-        }
-        output_stream.puts event.to_json
-        output_stream.puts
-        output_stream.flush
-      end
+    f
+  end
+  private_class_method :check_format
+
+  def self.listener
+    l = ENV["FN_LISTENER"]
+    if l.nil? || !l.start_with?("unix:/")
+      raise "Missing or invalid socket URL in FN_LISTENER."
+    end
 
-      input_stream.each_line { |line| parser.parse_chunk(line) }
+    l
+  end
+  private_class_method :listener
 
-    elsif format == 'json'
-      parser = Yajl::Parser.new
+  @dbg = ENV["FDK_DEBUG"]
 
-      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)
+  def self.debug(msg)
+    STDERR.puts(msg) if @dbg
+  end
+  private_class_method :debug
+
+  def self.handle(target:)
+    # To avoid Fn trying to connect to the socket before
+    # it's ready, the FDK creates a socket on (tmp_file).
+    #
+    # When the socket is ready to accept connections,
+    # the FDK links the tmp_file to the socket_file.
+    #
+    # Fn waits for the socket_file to be created and then connects
+    check_format
+    l = listener
+    socket_file = l[5..l.length]
+    tmp_file = socket_file + ".tmp"
+
+    debug tmp_file
+    debug socket_file
+    UNIXServer.open(tmp_file) do |serv|
+      File.chmod(0o666, tmp_file)
+      debug "listening on #{tmp_file}->#{socket_file}"
+      FileUtils.ln_s(File.basename(tmp_file), socket_file)
+
+      loop do
+        s = serv.accept
+        begin
+          loop do
+            req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+            req.parse s
+            debug "got request #{req}"
+            resp = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+            resp.status = 200
+            handle_call(target, req, resp)
+            resp.send_response s
+            debug "sending resp  #{resp.status}, #{resp.header}"
+            break unless req.keep_alive?
+          end
+        rescue StandardError => e
+          STDERR.puts "Error in request handling #{e}"
+          STDERR.puts e.backtrace
         end
-        se = FDK.single_event(function: function, context: context, input: body)
-        response = {
-          headers: {
-            'Content-Type' => ['application/json']
-          },
-          'status_code' => 200,
-          body: se.to_json
-        }
-        output_stream.puts response.to_json
-        output_stream.puts
-        output_stream.flush
+        s.close
       end
+    end
+  end
 
-      input_stream.each_line { |line| parser.parse_chunk(line) }
+  def self.set_error(resp, error)
+    STDERR.puts "Error in function: \"#{error}\""
+    STDERR.puts error.backtrace
 
-    elsif format == 'default'
-      event = {}
-      event['call_id'] = ENV['FN_CALL_ID']
-      event['protocol'] = {
-        'type' => 'http',
-        'request_url' => ENV['FN_REQUEST_URL']
-      }
-      output_stream.puts FDK.single_event(function: function, context: Context.new(event), input: input_stream.read.chomp).to_json
+    resp["content-type"] = "application/json"
+    resp.status = 502
+    resp.body = { message: "An error occurred in the function",
+                  detail: error.to_s }.to_json
+  end
+  private_class_method :set_error
+
+  def self.handle_call(target, req, resp)
+    headers = {}
+    req.header.map do |k, v|
+      headers[k] = v unless @filter_headers.include? k
+    end
+
+    headers_out_hash = {}
+    headers_out = FDK::OutHeaders.new(headers_out_hash, nil)
+    headers_in = FDK::InHeaders.new(headers, nil)
+    context = FDK::Context.new(headers_in, headers_out)
+    input = ParsedInput.new(raw_input: req.body.to_s)
+
+    begin
+      rv = if target.respond_to? :call
+             target.call(context: context, input: input.parsed)
+           else
+             send(target, context: context, input: input.parsed)
+           end
+    rescue StandardError => e
+      set_error(resp, e)
+      return
+    end
+
+    resp.status = 200
+    headers_out_hash.map do |k, v|
+      resp[k] = v.join(",") unless @filter_headers.include? k
+    end
+
+    # TODO: gimme a bit me flexibility on response handling
+    # binary, streams etc
+    if !rv.nil? && rv.respond_to?("to_json")
+      resp.body = rv.to_json
+      # don't override content type if already set
+      resp["content-type"] = "application/json" unless resp["content-type"]
     else
-      raise "Format '#{format}' not supported in Ruby FDK."
+      resp.body = rv.to_s
     end
   end
 
-  def self.single_event(function:, context:, input:)
-    send(function, context: context, input: input)
+  # Stores raw input and can parse it as
+  # JSON (add extra formats as required)
+  class ParsedInput
+    attr_reader :raw
+
+    def initialize(raw_input:)
+      @raw = raw_input
+    end
+
+    def as_json
+      @json ||= JSON.parse(raw)
+    rescue JSON::ParserError
+      @json = false
+    end
+
+    def parsed
+      as_json || raw
+    end
   end
 end

data/lib/fdk/version.rb

@@ -1,3 +1,3 @@
 module FDK
-  VERSION = "0.0.13"
+  VERSION = "0.0.14"
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: fdk
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Travis Reeder
 - Ewan Slater
+- Owen Cliffe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-13 00:00:00.000000000 Z
+date: 2018-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -32,35 +33,37 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.1.0
 - !ruby/object:Gem::Dependency
-  name: yajl-ruby
+  name: net_http_unix
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
-  type: :runtime
+        version: 0.2.1
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 0.2.1
 description: Ruby Function Developer Kit for Fn Project.
 email:
 - treeder@gmail.com
 - ewan.slater@gmail.com
+- owen.cliffe@oracle.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- Rakefile
 - lib/fdk.rb
 - lib/fdk/context.rb
 - lib/fdk/runner.rb
@@ -77,7 +80,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -85,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Ruby FDK for Fn Project