opener-webservice 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d3c9e68800786848df8f2c1310b2063edbf58939
+  data.tar.gz: e3b445eb8a225c5811663fc7dc5b0077c9e16077
+SHA512:
+  metadata.gz: 2f8b4978233d0f11a62828388c425e535be83c4dd8de2a78b06d1fec9b74c322a752dcf0ad5a65a3f365cf318837e0b7fa49d95eac38c10dcf1672c4658e946b
+  data.tar.gz: 7980a3858ddfaf44d0c24c89097ee025352dbea0108b06085634f7df316d04e90c0fb5128705126919d8fb53e8cdff8fcb54b2abc93d7d12eb6b491ed2c951ee

data/README.md

@@ -0,0 +1,29 @@
+# Opener::Webservice
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'opener-webservice'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opener-webservice
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/opener/webservice/version.rb

@@ -0,0 +1,7 @@
+require 'sinatra/base'
+
+module Opener
+  class Webservice < Sinatra::Base
+    VERSION = "1.0.0"
+  end
+end

data/lib/opener/webservice.rb

@@ -0,0 +1,274 @@
+require "uuidtools"
+require "sinatra/base"
+require "json"
+require "opener/webservice/version"
+
+module Opener
+  class Webservice < Sinatra::Base
+    configure do
+      enable :logging
+    end
+
+    configure :development do
+      set :raise_errors, true
+      set :dump_errors, true
+    end
+
+    ##
+    # Presents a simple form that can be used for getting the NER of a KAF
+    # document.
+    #
+    get '/' do
+      erb :index
+    end
+
+    ##
+    # Puts the text through the primary processor
+    #
+    # @param [Hash] params The POST parameters.
+    #
+    # @option params [String] :input the input to send to the processor
+    # @option params [Array<String>] :callbacks A collection of callback URLs
+    #  that act as a chain. The results are posted to the first URL which is
+    #  then shifted of the list.
+    # @option params [String] :error_callback Callback URL to send errors to
+    #  when using the asynchronous setup.
+    #
+    post '/' do
+      if !params[:input] or params[:input].strip.empty?
+        logger.error('Failed to process the request: no input specified')
+
+        halt(400, 'No input specified')
+      end
+
+      callbacks = extract_callbacks(params[:callbacks])
+      error_callback = params[:error_callback]
+
+      if callbacks.empty?
+        process_sync
+      else
+        process_async(callbacks, error_callback)
+      end
+    end
+
+    ##
+    # @return [HTTPClient]
+    #
+    def self.http_client
+      return @http_client || new_http_client
+    end
+
+    ##
+    # @return [HTTPClient]
+    #
+    def self.new_http_client
+      client = HTTPClient.new
+      client.connect_timeout = 120
+
+      return client
+    end
+
+    ##
+    # Specifies the text processor to use or returns it if no parameter is
+    # given.
+    #
+    # @param [Class] processor
+    # @return [Class]
+    #
+    def self.text_processor(processor=nil)
+      if processor.nil?
+        return @processor
+      else
+        @processor = processor
+      end
+    end
+
+    ##
+    # Specifies what parameters are accepted.
+    #
+    # @param [Array] array The parameters to accept.
+    #
+    def self.accepted_params(*array)
+      if array.empty?
+        return @accepted_params
+      else
+        @accepted_params = array
+      end
+    end
+
+    ##
+    # @return [Class]
+    #
+    def text_processor
+      self.class.text_processor
+    end
+
+    ##
+    # @return [Array]
+    #
+    def accepted_params
+      self.class.accepted_params
+    end
+
+    ##
+    # Processes the request synchronously.
+    #
+    def process_sync
+      output, type = analyze(filtered_params)
+      content_type(type)
+      body(output)
+    end
+
+    ##
+    # Filter the params hash based on the accepted_params
+    #
+    # @return [Hash] accepted params
+    #
+    def filtered_params
+      options = params.select{|k,v| accepted_params.include?(k.to_sym)}
+      cleaned = {}
+      options.each_pair do |k, v|
+        v = true  if v == "true"
+        v = false if v == "false"
+        cleaned[k.to_sym] = v
+      end
+
+      return cleaned
+    end
+
+    ##
+    # Processes the request asynchronously.
+    #
+    # @param [Array] callbacks The callback URLs to use.
+    #
+    def process_async(callbacks, error_callback)
+      request_id = get_request_id
+      output_url = callbacks.last
+      Thread.new do
+        analyze_async(filtered_params, request_id, callbacks, error_callback)
+      end
+
+      content_type :json
+
+      {
+        :request_id => request_id.to_s,
+        :output_url => [output_url, request_id].join("/")
+      }.to_json
+    end
+
+    ##
+    # Gets the Analyzed output of an input.
+    #
+    # @param [Hash] options The options for the text_processor
+    # @return [String] output the output of the text_processor
+    # @return [Symbol] type the output type ot the text_processor
+    #
+    # @raise RunetimeError Raised when the tagging process failed.
+    #
+    def analyze(options)
+      processor             = text_processor.new(options)
+      output, error, status = processor.run(options[:input])
+
+      if processor.respond_to?(:output_type)
+        type = processor.output_type
+      else
+        type = :xml
+      end
+
+      raise(error) if !status.nil? && !status.success?
+
+      return output, type
+    end
+
+    ##
+    # Gets the NER of a KAF document and submits it to a callback URL.
+    #
+    # @param [String] text
+    # @param [String] request_id
+    # @param [Array] callbacks
+    # @param [String] error_callback
+    #
+    def analyze_async(options, request_id, callbacks, error_callback = nil)
+      begin
+        output, _ = analyze(options)
+      rescue => error
+        logger.error("Failed to process input: #{error.inspect}")
+
+        submit_error(error_callback, error.message) if error_callback
+      end
+
+      url = callbacks.shift
+
+      logger.info("Submitting results to #{url}")
+
+      begin
+        process_callback(url, output, request_id, callbacks, error_callback)
+      rescue => error
+        logger.error("Failed to submit the results: #{error.inspect}")
+
+        submit_error(error_callback, error.message) if error_callback
+      end
+    end
+
+    ##
+    # @param [String] url
+    # @param [String] text
+    # @param [String] request_id
+    # @param [Array] callbacks
+    #
+    def process_callback(url, text, request_id, callbacks, error_callback)
+      # FIXME: this is a bit of a hack to prevent the webservice from clogging
+      # Airbrake during the hackathon. For whatever reason somebody is posting
+      # internal server errors from *somewhere*. Validation? What's that?
+      return if text =~ /^internal server error/i
+
+      output = {
+        :input          => text,
+        :request_id     => request_id,
+        :'callbacks[]'  => callbacks,
+        :error_callback => error_callback
+      }
+
+      http_client.post_async(
+        url,
+        :body => filtered_params.merge(output)
+      )
+    end
+
+    ##
+    # @param [String] url
+    # @param [String] message
+    #
+    def submit_error(url, message)
+      http_client.post_async(url, :body => {:error => message})
+    end
+
+    ##
+    # Returns an Array containing the callback URLs, ignoring empty values.
+    #
+    # @param [Array|String] input
+    # @return [Array]
+    #
+    def extract_callbacks(input)
+      return [] if input.nil? || input.empty?
+
+      callbacks = input.compact.reject(&:empty?)
+
+      return callbacks
+    end
+
+    ##
+    # @return [String]
+    #
+    def get_request_id
+      return params[:request_id] || UUIDTools::UUID.random_create
+    end
+
+    ##
+    # @see Opener::Webservice.http_client
+    #
+    def http_client
+      return self.class.http_client
+    end
+  end
+end

data/opener-webservice.gemspec

@@ -0,0 +1,23 @@
+require File.expand_path('../lib/opener/webservice/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "opener-webservice"
+  spec.version       = Opener::Webservice::VERSION
+  spec.authors       = ["development@olery.com"]
+  spec.summary       = %q{Basic webservice hooks for the opener toolchain}
+  spec.description   = spec.summary
+
+  spec.files = Dir.glob([
+    'lib/**/*',
+    '*.gemspec',
+    'README.md'
+  ]).select { |file| File.file?(file) }
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+
+  spec.add_dependency "sinatra", "~> 1.4.3"
+  spec.add_dependency "uuidtools"
+  spec.add_dependency "json"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: opener-webservice
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- development@olery.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.3
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Basic webservice hooks for the opener toolchain
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/opener/webservice.rb
+- lib/opener/webservice/version.rb
+- opener-webservice.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Basic webservice hooks for the opener toolchain
+test_files: []
+has_rdoc: