localhook 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ab14906758ff1242dd8322ec1fb39f7f17d9101
+  data.tar.gz: 50e268e4b5d8c5239270fdb32b976577e6c8dd98
+SHA512:
+  metadata.gz: 4333fd6974a59eba698b78d5d97e1fc4c2b3486f4dca0fb8fad13b7f79f4b49b9820b6ac45114e40e5d9b5b0c7e29a120f43998491d0f8e4ac50b203ef8349a3
+  data.tar.gz: c2d435287c5652fb9814fea89aa6ce6d0911356b995538334745981710145856bf3b5458fb92573e5718221a13ec0ef278a5363c74472219fe8295a46d28f5db

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in localhook.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Francis Chong
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Localhook
+
+## What is Localhook?
+
+Localhook let you receive webhooks behind a firewall.
+
+A WebHook is an HTTP callback: an HTTP POST that occurs when something happens. Many popular services (GitHub, Stripe, ActiveCampaign, Papertrail, etc) support updates via webhooks. However, since these webhook requests are made over Internet, it's difficult receive them when testing from behind a firewall.
+
+Localhook lets you host a public endpoint for other services and tunnels requests to a private endpoint on your computer.
+
+## Installation
+
+Install localhook client:
+
+``
+gem install localhook
+``
+
+## Usage
+
+First, you must host your own localhook server on internet. Check [localhook-server](https://github.com/siuying/localhook-server) for details.
+
+To expose a local webhook ``http://localhost:3000/webhook`` to internet:
+
+```
+localhook https://localhook.mydomain.com http://localhost:3000 --token=1234
+```
+
+Instead of giving third party url "http://localhost:3000/webhook", you give them
+``https://localhook.mydomain.com/endpoint1/webhook```.
+
+Any POST request sent to ``https://localhook.mydomain.com/endpoint1/webhook`` will be
+forwarded to ``http://localhost:3000/webhook``.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/localhook/fork )
+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/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/localhook

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'localhook'
+
+Localhook::Command.run(ARGV)

data/lib/localhook.rb

@@ -0,0 +1,5 @@
+module Localhook
+end
+
+require_relative "./localhook/version"
+require_relative './localhook/command'

data/lib/localhook/command.rb

@@ -0,0 +1,51 @@
+require 'claide'
+require 'colored'
+
+require_relative './event_source'
+require_relative './webhook_forwarder'
+
+module Localhook
+  class Command < ::CLAide::Command
+    attr_reader :remote_server, :local_server
+    self.command = 'localhook'
+    self.description = "Localhook let you receive webhooks on localhost."
+    self.arguments   = "<remote-server> <local-server>"
+
+    def initialize(argv)
+      @remote_server = argv.shift_argument
+      @local_server  = argv.shift_argument
+      @token         = argv.option('token')
+      super
+    end
+
+    def self.options
+      [
+        ['--token=<token>', 'Authentication Token']
+      ].concat(super)
+    end
+
+    def validate!
+      if @remote_server.nil?
+        help! "missing remote-server parameter"
+      end
+      if @local_server.nil?
+        help! "missing local-server parameter"
+      end
+      if @token.nil?
+        help! "missing token"
+      end
+    end
+
+    def run
+      EventMachine.run do
+        puts "forward remote server (#{@remote_server}) webhooks to #{@local_server}"
+        @forwarder  = WebhookForwarder.new(@local_server)
+        @source     = EventSource.new(@remote_server, @forwarder, @token)
+        @source.error do |error|
+          puts "error connecting to eventsource: #{error}"
+        end
+        @source.start
+      end
+    end
+  end
+end 

data/lib/localhook/event_source.rb

@@ -0,0 +1,56 @@
+require 'em-eventsource'
+require 'yajl'
+
+module Localhook
+  class EventSource < ::EventMachine::EventSource
+    attr_reader :forwarder
+    attr_reader :endpoint
+
+    VALID_URL = %r{^(https?://[^/]+)/?$}
+
+    def initialize(base_url, forwarder, token)
+      unless base_url =~ VALID_URL
+        raise ArgumentError, "Invalid base_url \"#{base_url}\", it should be in format: (https|http)://<host>(:<port>)?/?"
+      end
+
+      base_url = base_url.match(VALID_URL)[1]
+      super("#{base_url}/_localhook?token=#{token}")
+
+      @forwarder = forwarder
+
+      @parser = Yajl::Parser.new(:symbolize_keys => true)
+      @parser.on_parse_complete = method(:data_parsed)
+      self.on "webhook" do |message|
+        @parser.parse(message)
+      end
+      self.on "endpoint" do |message|
+        @endpoint = message
+        puts "Connected to endpoint: #{message}"
+      end
+      self.on "error" do |error|
+        puts "Error: #{error}"
+        self.close
+        raise "Server response with an error: #{error}"
+      end
+
+      # never timeout
+      self.inactivity_timeout = 0
+    end
+
+    def data_parsed(data)
+      # binding.pry
+      case data[:action]
+      when "post"
+        # convert headers array to Hash, if needed
+        headers = data[:headers]
+        headers = headers.inject({}){|map, v| map[v[0]] = v[1]; map } if headers.is_a?(Array)
+        path = data[:path]
+        query = data[:query_string]
+        body = data[:body]
+        forwarder.post(path, query, headers, body)
+      else
+        raise "unknown action '#{data[:action]}' (#{data}"
+      end
+    end
+  end
+end 

data/lib/localhook/version.rb

@@ -0,0 +1,3 @@
+module Localhook
+  VERSION = "0.1.0"
+end

data/lib/localhook/webhook_forwarder.rb

@@ -0,0 +1,35 @@
+require 'em-http-request'
+
+module Localhook
+  # Forward webhook to destination.
+  # Note: this should be used inside eventmachine
+  class WebhookForwarder
+    attr_reader :url
+    attr_reader :http_options
+
+    VALID_URL = %r{^(https?://[^/]+)/?$}
+    DEFAULT_OPTIONS = {:connect_timeout => 5}
+
+    # Create a WebhookForwarder
+    # url - the base url of the destination webhook
+    # http_options - the http options passed to em
+    def initialize(url, http_options={})
+      unless url =~ VALID_URL
+        raise ArgumentError, "Invalid url \"#{url}\", it should be in format: (https|http)://<host>(:<port>)?/?"
+      end
+
+      @url = url.match(VALID_URL)[1]
+      @http_options = DEFAULT_OPTIONS.merge(http_options)
+    end
+
+    # path - string, the path of the request
+    # query - string, the query string
+    # headers - Hash, the header of the request
+    # body - String, the body of the request
+    def post(path, query, headers, body)
+      http = EventMachine::HttpRequest.new(url, http_options).post :head => headers, :path => path, :query => query, :body => body
+      http.callback { puts "forward url -> #{url}" }
+      http.errback { puts "ERROR: failed forward to url #{url}" }
+    end
+  end
+end

data/localhook.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'localhook/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "localhook"
+  spec.version       = Localhook::VERSION
+  spec.authors       = ["Francis Chong"]
+  spec.email         = ["francis@ignition.hk"]
+  spec.summary       = %q{Localhook let you receive webhooks on localhost.}
+  spec.description   = %q{Localhook makes it super easy to connect public webhook endpoints with development environments.}
+  spec.homepage      = "https://github.com/siuying/localhook"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "claide"
+  spec.add_dependency "em-http-request"
+  spec.add_dependency "em-eventsource"
+  spec.add_dependency "yajl-ruby"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+end

data/spec/command_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/localhook'
+
+describe Localhook::EventSource do
+  context "-initialize" do
+    it "accept parameters" do
+      argv = CLAide::ARGV.new(['http://mylocalhook.com', 'http://localhost:3000'])
+      command = Localhook::Command.new(argv)
+
+      expect(command.remote_server).to eq("http://mylocalhook.com")
+      expect(command.local_server).to eq("http://localhost:3000")
+    end
+  end
+
+  context "-run" do
+    it "raise error on missing parameters" do
+      argv = CLAide::ARGV.new(['http://mylocalhook.com'])
+      command = Localhook::Command.new(argv)
+      expect {
+        command.run
+      }.to raise_error
+    end
+  end
+end

data/spec/event_source_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../lib/localhook'
+require 'yajl'
+
+describe Localhook::EventSource do  
+  context "-initialize" do
+    it "set url via base_url and token parameter" do
+      forwarder = Localhook::EventSource.new("http://localhost:8080", double(:forwarder), "t")
+      expect(forwarder.url).to eq("http://localhost:8080/_localhook?token=t")
+
+      forwarder = Localhook::EventSource.new("http://localhost:8080/", double(:forwarder), "t")
+      expect(forwarder.url).to eq("http://localhost:8080/_localhook?token=t")
+    end
+  end
+
+  context "-data_parsed" do
+    let(:forwarder) { double(:forwarder) }
+    subject { Localhook::EventSource.new("http://www.google.com", forwarder, "1") }
+
+    it "call forwarder.post() when parsed action 'post'" do
+      message = {:action => "post", 
+        :query_string => "a=1", 
+        :path => "/a/b", 
+        :body => "{}", 
+        :headers => [["User-Agent", "rspec"]]
+      }
+
+      expect(forwarder).to receive(:post).with("/a/b", "a=1", {"User-Agent" => "rspec"}, "{}")
+      subject.data_parsed(message)
+    end
+  end
+end

data/spec/webbook_forwarder_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../lib/localhook'
+require 'yajl'
+
+describe Localhook::WebhookForwarder do
+  context "initialize" do
+    it "accept valid url" do
+      forwarder = Localhook::WebhookForwarder.new("http://localhost:8080")
+      expect(forwarder.url).to eq("http://localhost:8080")
+
+      forwarder = Localhook::WebhookForwarder.new("http://localhost:8080/")
+      expect(forwarder.url).to eq("http://localhost:8080")
+    end
+    
+    it "merge input options with default options" do
+      options = {a: 1}
+      forwarder = Localhook::WebhookForwarder.new("http://localhost:8080", options)
+      expect(forwarder.http_options).to eq(Localhook::WebhookForwarder::DEFAULT_OPTIONS.merge(options))
+    end
+
+    it "raise exception for invalid url" do
+      expect {
+        Localhook::WebhookForwarder.new("http://localhost:8080/a/b")
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "post" do
+    subject { Localhook::WebhookForwarder.new("http://localhost:8080") }
+    it "forward request to remote server via em" do
+      params  = {head: {}, path: "/a/b", query: "", body: ""}
+      request = double(:request)
+      expect(request).to receive(:post).with(params).and_return(request)
+      expect(request).to receive(:callback)
+      expect(request).to receive(:errback)
+      expect(EventMachine::HttpRequest).to receive(:new).with(subject.url, subject.http_options).and_return(request)
+      subject.post("/a/b", "", {}, "")
+    end
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: localhook
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francis Chong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: claide
+  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: em-http-request
+  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: em-eventsource
+  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: yajl-ruby
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+description: Localhook makes it super easy to connect public webhook endpoints with
+  development environments.
+email:
+- francis@ignition.hk
+executables:
+- localhook
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/localhook
+- lib/localhook.rb
+- lib/localhook/command.rb
+- lib/localhook/event_source.rb
+- lib/localhook/version.rb
+- lib/localhook/webhook_forwarder.rb
+- localhook.gemspec
+- spec/command_spec.rb
+- spec/event_source_spec.rb
+- spec/webbook_forwarder_spec.rb
+homepage: https://github.com/siuying/localhook
+licenses:
+- MIT
+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.0
+signing_key: 
+specification_version: 4
+summary: Localhook let you receive webhooks on localhost.
+test_files:
+- spec/command_spec.rb
+- spec/event_source_spec.rb
+- spec/webbook_forwarder_spec.rb