fdk 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: a50737dfa816cbaa0d9de365617db0b1c393d47984529e6de1ac3fdf6e1f9167
-  data.tar.gz: 8e843ba19e95fc057ec571ec05dc6e4460761bfc5aa2f3bce81a4f068bfb31ed
+SHA1:
+  metadata.gz: 54156518eff40553f0490bcf437fa82daf307ce4
+  data.tar.gz: 73e6aed064fa66529f22777f8788e9292828ff90
 SHA512:
-  metadata.gz: 67c53e7e572ca2a7f3c894ebe111b07fbf86df79e407ab10e2484e0479a0f67d02f45e504b46af9c5a2c81763994c6986e7f9a7d768ee8c341d175800b2bf013
-  data.tar.gz: ef3b16817052b5eee6ea90d7c0bbd8158446097a87df2db0d2dfad071beed80044c6bad14a8731064340909b3f9ae5ca6338498874864fae1d2709f6a3559f7e
+  metadata.gz: b47e349ed1fcc96d5ab2170ad2bafeddeba810246c4457149fd160cb164e4f1dae32b8172ddff9307a11707010a3657770417e6176fe058ba267ebe21431d1bb
+  data.tar.gz: dc5ba5aaadb49d99ee180098700970f36b8bb258086c723c058d4a8f0718077cf6dfc9898e704fd974c4aec649ef94a310ba8fcfb32591f3bd3ef41f902e199e

data/README.md

@@ -1,6 +1,8 @@
 # Ruby Function Developer Kit (FDK)
 This provides a Ruby framework for developing functions for use with [Fn](https://fnproject.github.io).
 
+[![CircleCI](https://circleci.com/gh/fnproject/fdk-ruby.svg?style=svg)](https://circleci.com/gh/fnproject/fdk-ruby)
+
 ## Function Handler
 To use this FDK, you simply need to require this gem.
 

data/Rakefile

@@ -3,3 +3,9 @@ task default: %w[test]
 task :test do
 	  ruby "tests/test_fdk.rb"
 end
+
+require 'rubocop/rake_task'
+desc "run RuboCop on lib directory"
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.patterns = ["lib/**/*.rb"]
+end

data/lib/fdk/call.rb

@@ -0,0 +1,61 @@
+module FDK
+  # Call represents a call to the target function or lambda
+  class Call
+    FILTER_HEADERS = ["content-length", "te", "transfer-encoding",
+                      "upgrade", "trailer"].freeze
+
+    attr_reader :request, :response
+    attr_accessor :error
+
+    def initialize(request:, response:)
+      @request = request
+      @response = response
+    end
+
+    def context
+      @context ||= FDK::Context.new(headers_in, headers_out)
+    end
+
+    def input
+      @input ||= ParsedInput.new(raw_input: request.body.to_s)
+    end
+
+    def headers_out
+      @headers_out ||= FDK::OutHeaders.new({}, nil)
+    end
+
+    def headers_in
+      @headers_in ||= FDK::InHeaders.new(filtered_request_header, nil)
+    end
+
+    def filtered_request_header
+      request.header.reject { |k| FILTER_HEADERS.include? k }
+    end
+
+    def process
+      format_response_body(fn_return: yield(context: context, input: input.parsed))
+      good_response
+    rescue StandardError => e
+      error_response(error: e)
+    end
+
+    def format_response_body(fn_return:)
+      return response.body = fn_return.to_s unless fn_return.respond_to?(:to_json)
+
+      response.body = fn_return.to_json
+      response["content-type"] = "application/json" unless response["content-type"]
+    end
+
+    def good_response
+      response.status = 200
+      headers_out.each { |k, v| response[k] = v.join(",") }
+    end
+
+    def error_response(error:)
+      response["content-type"] = "application/json"
+      response.status = 502
+      response.body = { message: "An error occurred in the function",
+                        detail: error.to_s }.to_json
+    end
+  end
+end

data/lib/fdk/context.rb

@@ -1,7 +1,6 @@
-require 'date'
+require "date"
 
 module FDK
-
   # Config looks up values in the env vars
   class Config
     def [](key)
@@ -9,67 +8,59 @@ module FDK
     end
   end
 
-
+  # Represents inbound HTTP headers
   class InHeaders
-    def initialize (h, key_fn)
-      @headers = h
+    def initialize(headers, key_fn)
+      @headers = headers
       @key_fn = key_fn
-
     end
 
-    def headerKey(key)
-      if @key_fn
-        key = @key_fn.call(key)
-      end
+    def header_key(key)
+      key = @key_fn.call(key) if @key_fn
       key.downcase
     end
 
     def [](key)
-      h = @headers[headerKey(key)]
-      unless h.nil?
-        return h[0]
-      end
-      nil
+      h = @headers[header_key(key)]
+      return h[0] unless h.nil?
     end
 
-    def each (&block)
-      @headers.each &block
+    def each(&block)
+      @headers.each(&block)
     end
   end
 
+  # Represents outbound HTTP headers
   class OutHeaders < InHeaders
-
-    def initialize(h, key_in_fn)
-      super(h, key_in_fn)
+    def initialize(headers, key_in_fn)
+      super(headers, 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
+        value.each { |x| h.push(x.to_s) }
+        @headers[header_key(key)] = h
       else
-        @headers[headerKey(key)] = [value.to_s]
+        @headers[header_key(key)] = [value.to_s]
       end
     end
 
     def delete(key)
-      @headers.delete headerKey(key)
+      @headers.delete header_key(key)
     end
   end
 
-
+  # Represents the Fn context for a function execution
   class Context
-
+    # FN_APP_ID -the ID of the application that this function is a member of.
+    # FN_APP_NAME - the name of the application.
     # 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_METHOD - the HTTP method for the request, eg: GET or POST
+    # FN_FN_ID - the ID of this function
     # FN_MEMORY - a number representing the amount of memory available to the call, in MB
-
+    # $X - any configuration values you've set for the Application.
+    #   Replace X with the upper cased name of the config variable you set.
+    #   e.g. minio_secret=secret will be exposed via MINIO_SECRET env var.
 
     attr_reader :headers
     attr_reader :response_headers
@@ -80,31 +71,28 @@ module FDK
       @config ||= Config.new
     end
 
-
     def call_id
-      @headers['fn-call-id']
+      @headers["fn-call-id"]
     end
 
-
     def app_id
-      @config['FN_APP_ID']
+      @config["FN_APP_ID"]
     end
 
-
     def fn_id
-      @config['FN_FN_ID']
+      @config["FN_FN_ID"]
     end
 
     def deadline
-      DateTime.iso8601(@headers['fn-deadline'])
+      DateTime.iso8601(@headers["fn-deadline"])
     end
 
     def memory
-      @config['FN_MEMORY'].to_i
+      @config["FN_MEMORY"].to_i
     end
 
     def content_type
-      @headers['content-type']
+      @headers["content-type"]
     end
 
     def http_context
@@ -112,43 +100,33 @@ module FDK
     end
   end
 
-
+  # Represents the context data (inbound && outbound)
+  # for the execution passed as HTTP headers
   class HTTPContext
-
     attr_reader :headers
     attr_reader :response_headers
 
     def initialize(ctx)
-
+      fn_http_h_ = "fn-http-h-"
       @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
-      }
-
+      ctx.headers.each do |k, v|
+        http_headers[k.sub(fn_http_h_, "")] = v if k.downcase.start_with?(fn_http_h_)
+      end
       @headers = InHeaders.new(http_headers, nil)
-      @response_headers = OutHeaders.new(ctx.response_headers, lambda {|s| 'fn-http-h-' + s})
+      @response_headers = OutHeaders.new(ctx.response_headers, ->(s) { fn_http_h_ + s })
     end
 
-
     def request_url
-      @ctx.headers['fn-http-request-url']
+      @ctx.headers["fn-http-request-url"]
     end
 
     def method
-      @ctx.headers['fn-http-method']
+      @ctx.headers["fn-http-method"]
     end
 
-
     def status_code=(val)
-      @ctx.response_headers['fn-http-status'] = val.to_i
+      @ctx.response_headers["fn-http-status"] = val.to_i
     end
-
   end
 end
-

data/lib/fdk/function.rb

@@ -0,0 +1,22 @@
+module FDK
+  # Function represents a function function or lambda
+  class Function
+    attr_reader :format, :function
+    def initialize(function:, format:)
+      raise "'#{format}' not supported in Ruby FDK." unless format == "http-stream"
+
+      @format = format
+      @function = function
+    end
+
+    def as_proc
+      return function if function.respond_to?(:call)
+
+      ->(context:, input:) { send(function, context: context, input: input) }
+    end
+
+    def call(request:, response:)
+      Call.new(request: request, response: response).process(&as_proc)
+    end
+  end
+end

data/lib/fdk/listener.rb

@@ -0,0 +1,68 @@
+module FDK
+  # Represents the socket that Fn uses to communicate
+  # with the FDK (and thence the function)
+  # To avoid Fn trying to connect to the socket before
+  # it's ready, the Listener creates a socket on (private_socket_path).
+  #
+  # When the socket is ready to accept connections,
+  # the FDK links the private_socket_path to the socket_path.
+  #
+  # Fn waits for the socket_path to be created and then connects
+  class Listener
+    attr_reader :url, :private_socket
+
+    def initialize(url:)
+      if url.nil? || !url.start_with?("unix:/")
+        raise "Missing or invalid socket URL in FN_LISTENER."
+      end
+
+      @url = url
+      @private_socket = UNIXServer.open(private_socket_path)
+    end
+
+    def socket
+      link_socket_file unless @socket
+      @socket ||= private_socket
+    end
+
+    def link_socket_file
+      File.chmod(0o666, private_socket_path)
+      FileUtils.ln_s(File.basename(private_socket_path), socket_path)
+      FDK.debug "listening on #{private_socket_path}->#{socket_path}"
+    end
+
+    def listen(&block)
+      local_socket = socket.accept
+      begin
+        raise StandardError("No block given") unless block_given?
+
+        handle_requests(socket: local_socket, fn_block: block)
+      rescue StandardError => e
+        STDERR.puts "Error in request handling #{e}"
+        STDERR.puts e.backtrace
+      end
+      local_socket.close
+    end
+
+    def handle_requests(socket:, fn_block:)
+      loop do
+        req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+        resp = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+        req.parse(socket)
+        FDK.debug "got request #{req}"
+        fn_block.call(req, resp)
+        resp.send_response(socket)
+        FDK.debug "sending resp  #{resp.status}, #{resp.header}"
+        break unless req.keep_alive?
+      end
+    end
+
+    def socket_path
+      @socket_path ||= url[5..url.length]
+    end
+
+    def private_socket_path
+      socket_path + ".private"
+    end
+  end
+end

data/lib/fdk/runner.rb

@@ -7,144 +7,16 @@ require "set"
 # Executes it with input
 # Responds with output
 module FDK
-  @filter_headers = Set["content-length", "te", "transfer-encoding",
-                        "upgrade", "trailer"]
-
-  def self.check_format
-    f = ENV["FN_FORMAT"]
-    raise "'#{f}' not supported in Ruby FDK." unless f == "http-stream"
-
-    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
-
-    l
-  end
-  private_class_method :listener
-
   @dbg = ENV["FDK_DEBUG"]
 
   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
-        s.close
-      end
-    end
-  end
-
-  def self.set_error(resp, error)
-    STDERR.puts "Error in function: \"#{error}\""
-    STDERR.puts error.backtrace
-
-    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
-      resp.body = rv.to_s
-    end
-  end
-
-  # 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
+    func = Function.new(function: target, format: ENV["FN_FORMAT"])
+    Listener.new(url: ENV["FN_LISTENER"]).listen do |req, resp|
+      func.call(request: req, response: resp)
     end
   end
 end

data/lib/fdk/support_classes.rb

@@ -0,0 +1,21 @@
+module FDK
+  # ParsedInput 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.14"
+  VERSION = "0.0.15".freeze
 end

data/lib/fdk.rb

@@ -1,3 +1,7 @@
-require_relative 'fdk/version'
-require_relative 'fdk/runner'
-require_relative 'fdk/context'
+require_relative "fdk/version"
+require_relative "fdk/runner"
+require_relative "fdk/context"
+require_relative "fdk/call"
+require_relative "fdk/listener"
+require_relative "fdk/function"
+require_relative "fdk/support_classes"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fdk
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - Travis Reeder
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-05 00:00:00.000000000 Z
+date: 2018-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -65,8 +65,12 @@ files:
 - README.md
 - Rakefile
 - lib/fdk.rb
+- lib/fdk/call.rb
 - lib/fdk/context.rb
+- lib/fdk/function.rb
+- lib/fdk/listener.rb
 - lib/fdk/runner.rb
+- lib/fdk/support_classes.rb
 - lib/fdk/version.rb
 homepage: https://github.com/fnproject/fdk-ruby
 licenses:
@@ -88,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
 summary: Ruby FDK for Fn Project