stubby 0.0.1 → 0.0.2

data/lib/stubby/extensions/http.rb

@@ -26,8 +26,10 @@ module Extensions
           super(:server_settings => server_settings)
         end
 
-        def adapter(name, &block)
-          adapters[name] = block
+        def adapter(*names, &block)
+          names.each do |name|
+            adapters[name] = block
+          end
         end
 
         def adapters
@@ -39,15 +41,7 @@ module Extensions
       set :static, false
 
       adapter "http-redirect" do
-        url.scheme = "http"
-        url.path = request.path if url.path.to_s.empty?
-        redirect to(url.to_s)
-      end
-
-      adapter "https-redirect" do
-        url.scheme = "https"
-        url.path = request.path if url.path.to_s.empty?
-        redirect to(url.to_s)
+        redirect to(instruction_params["to"])
       end
 
       adapter "file" do
@@ -73,37 +67,54 @@ module Extensions
         not_found(paths.join(",\n"))
       end
 
-      adapter "default" do
+      adapter "http-proxy" do
+        url.scheme = "http"
+
         if url.path.empty?
           # Proxy all requests, preserve incoming path
           out = url.dup
           out.path = request.path
           request = HTTPI::Request.new
           request.url = out.to_s
+        else
+          # Proxy to the given path
+          request = HTTPI::Request.new
+          request.url = url.to_s
+        end
 
-          response = HTTPI.get(request)
+        response = HTTPI.get(request)
+        response.headers.delete "transfer-encoding"
+        response.headers.delete "connection"
 
-          response.headers.delete "transfer-encoding"
-          response.headers.delete "connection"
+        status(response.code)
+        headers(response.headers)
+        body(response.body)
 
-          status(response.code)
-          headers(response.headers)
-          body(response.body)
+      end
+
+      adapter "https-proxy" do
+        url.scheme = "https"
 
+        if url.path.empty?
+          # Proxy all requests, preserve incoming path
+          out = url.dup
+          out.path = request.path
+          request = HTTPI::Request.new
+          request.url = out.to_s
         else
           # Proxy to the given path
           request = HTTPI::Request.new
           request.url = url.to_s
+        end
 
-          response = HTTPI.get(request)
+        response = HTTPI.get(request)
+        response.headers.delete "transfer-encoding"
+        response.headers.delete "connection"
 
-          response.headers.delete "transfer-encoding"
-          response.headers.delete "connection"
+        status(response.code)
+        headers(response.headers)
+        body(response.body)
 
-          status(response.code)
-          headers(response.headers)
-          body(response.body)
-        end
       end
 
       get(//) do
@@ -126,10 +137,14 @@ module Extensions
       end
 
       def instruction
-        MultiJson.load(HTTPI.post("http://#{STUBBY_MASTER}:9000/rules/search.json", 
+        @instruction ||= MultiJson.load(HTTPI.post("http://#{STUBBY_MASTER}:9000/rules/search.json", 
           trigger: "#{request.scheme}://#{request.host}").body)
       end
 
+      def instruction_params
+        Rack::Utils.parse_nested_query url.query
+      end
+
       def url
         @url ||= URI.parse(instruction)
       end
@@ -181,6 +196,24 @@ module Extensions
         HTTPApp.run!(session)
       end
 
+      # http://blah.com => localhost:3000
+      # =>
+      # http://blah.com => http-proxy://localhost:3000
+      def expand_rule(trigger, instruction, proto='http')
+        u = URI.parse(instruction)
+    
+        (if u.scheme.nil?
+          { trigger => "http-proxy://#{instruction}" }
+        elsif u.scheme == "http"
+          u.scheme = "http-proxy"
+          { trigger => u.to_s }
+        else
+          { trigger => instruction }
+        end).merge({
+          "#{trigger.gsub(proto + "://", "dns://")}/a" => "dns-a://#{STUBBY_MASTER}"
+        })
+      end
+
       def stop!
         HTTPApp.quit!
       end
@@ -197,6 +230,10 @@ module Extensions
       def stop!
         HTTPSApp.quit!
       end
+
+      def expand_rule(trigger, instruction)
+        super(trigger, instruction, "https")
+      end
     end
   end
 end

data/lib/stubby/extensions/smtp.rb

@@ -0,0 +1,47 @@
+require 'mail_catcher'
+
+module Extensions
+  module SMTP
+    class Server
+      def run!(session, options)
+        @process = Process.fork {
+          $0 = "stubby: [extension worker sub] Extensions::SMTP::Server"
+
+          sleep 2
+
+          HTTPI.post("http://#{STUBBY_MASTER}:9000/stubs/transient/activate.json",
+            options: MultiJson.dump(smtp_stub), key: "_smtp")
+          
+          MailCatcher.run! smtp_ip: STUBBY_MASTER,
+            smtp_port: 25,
+            http_ip: STUBBY_MASTER,
+            http_port: 9001,
+            daemon: false
+        }
+
+        trap("INT", important: true){
+          stop!
+        }
+
+        sleep
+      end
+
+      def smtp_stub
+        {
+          "dns://outbox.stubby.dev/a" => "dns-a://#{STUBBY_MASTER}",
+          "http://outbox.stubby.dev" => "http://#{STUBBY_MASTER}:9001"
+        }
+      end
+
+      def expand_rule(trigger, instruction)
+        {
+          "#{trigger.gsub("smtp://", "dns://")}/mx" => "dns-mx://#{STUBBY_MASTER}/?priority=10"
+        }
+      end
+
+      def stop!
+        Process.shutdown(@process)
+      end
+    end
+  end
+end

data/lib/stubby/kernel.rb

@@ -0,0 +1,36 @@
+$tracked = {}
+
+module Kernel
+  alias _trap trap
+
+  def trap(*args, &block)
+    #puts "kernel::trap: #{args.inspect}\n---------------\n #{caller.join("\n")}\n\n"
+
+    if args.last.is_a? Hash
+      options = args.pop
+    else
+      options = {}
+    end
+
+    if options[:important]
+      track(args.first, _trap(*args, &block))
+    else
+      if tracked?(args.first)
+        puts "kernel::trap: #{args.inspect} ignoring"
+      else
+        _trap(*args, &block) 
+      end
+    end
+  end
+
+  private
+  def track(signal, child_pid)
+    (($tracked ||= {})[Process.pid] ||= {})[signal] = child_pid
+  end
+
+  def tracked?(signal)
+    !!($tracked[Process.pid][signal])
+  rescue
+    false
+  end
+end

data/lib/stubby/master.rb

@@ -5,8 +5,9 @@ module Stubby
     class << self
       attr_accessor :enabled_stubs
       attr_accessor :registry
+      attr_accessor :master
       attr_accessor :environments, :environment
-
+      
       def enabled_stubs
         @enabled_stubs ||= {} 
       end
@@ -19,6 +20,8 @@ module Stubby
         @enabled_stubs = nil
         @environment = nil
         @registry = nil
+
+        yield if block_given?
       end
 
       def env_settings
@@ -26,26 +29,50 @@ module Stubby
       end
 
       def environment=(name)
-        reset
-        @environment = name
+        reset do
+          @environment = name
 
-        (env_settings["dependencies"] || []).each do |depname, mode|
-          activate(depname, mode)
-        end
+          (env_settings["dependencies"] || []).each do |depname, mode|
+            activate(depname, mode)
+          end
 
-        env_settings.delete("dependencies")
+          env_settings.delete("dependencies")
+          activate_transient(env_settings)
+        end
+      end
 
-        activate_transient(env_settings)
+      def activate(source, mode)
+        registry_item = RegistryItem.new(source)
+        self.enabled_stubs[source] = registry_item.stub(mode)
       end
 
-      def activate(name, mode)
-        registry_item = registry.latest(name)
-        registry_item.install
-        self.enabled_stubs[name] = registry_item.stub(mode)
+      def activate_transient(options, key="_")
+        puts "Transient activation #{options.inspect}, #{key}"
+        self.enabled_stubs[key] = TransientStub.new(options)
       end
 
-      def activate_transient(options)
-        self.enabled_stubs["_"] = TransientStub.new(options)
+      def expand_rules(options)
+        options.inject({}) do |new_opts, (trigger, instruction)|
+          if instruction.is_a? Hash # dependency modes
+            new_opts[trigger] = instruction
+          else 
+            instruction = instruction.gsub("@", STUBBY_MASTER)
+
+            protocol, url = trigger.split("://")
+            url, protocol = protocol, :default if url.nil?
+
+            extension = master.extensions[protocol.to_sym]
+
+            if extension
+              new_opts.delete(trigger)
+              new_opts.merge!(extension.expand_rule(trigger, instruction))
+            else
+              raise "No `#{extension}` extension found for trigger: #{trigger}"
+            end
+          end
+
+          new_opts
+        end
       end
     end
 
@@ -87,7 +114,7 @@ module Stubby
     end
 
     post "/stubs/transient/activate.json" do
-      Api.activate_transient(params[:options])
+      Api.activate_transient(MultiJson.load(params[:options]), params[:key])
       json status: "ok"
     end
 
@@ -107,14 +134,17 @@ module Stubby
     attr_accessor :extensions, :config
 
     def initialize(environments)
-      @extensions = [
-        Extensions::DNS::Server.new,
-        Extensions::HTTP::Server.new,
-        Extensions::HTTP::SSLServer.new
-      ]
+      @extensions = {
+        default:    Extensions::Default.new,
+        dns:        Extensions::DNS::Server.new,
+        http:       Extensions::HTTP::Server.new,
+        https:      Extensions::HTTP::SSLServer.new,
+        smtp:       Extensions::SMTP::Server.new
+      }
 
       @config = Api
       @config.environments = environments
+      @config.master = self
     end
 
     def environment=(environment)
@@ -122,50 +152,61 @@ module Stubby
     end
 
     def run!(options={})
-      begin
-        assume_network_interface
-
-        running.each do |process|
-          puts "wait for #{process}"
-          Process.waitpid(process)
-        end
-      ensure
-        unassume_network_interface
+      run_network do
+        run_master do
+          run_extensions
+        end 
       end
     end
 
     private
-    def stop_extensions
+    def run_network
+      assume_network_interface
+      yield
+    ensure
+      unassume_network_interface
+    end
+
+    def run_master
+      $0 = "stubby: master"
+
+      Api.run! do |server|
+        yield
+      end
+    end
+
+    def run_extensions
+      running.each do |process|
+        Process.waitpid(process)
+      end
+    end
+
+    def stop!
       puts "Shutting down..."
 
+      Api.stop!
+
       running.each do |process|
-        Process.kill("INT", process)
+        Process.shutdown(process)
       end
 
       puts "Bye."
     end
 
     def running
-      @running ||= [run_master_api, run_extensions].flatten
-    end
-
-    def run_master_api
-      Process.fork {
-        $0 = "stubby: [config api]"
-        Api.run!
-      }
+      @running ||= run_extensions
     end
 
     def run_extensions
-      @running_extensions ||= @extensions.collect { |plugin|
+      @running_extensions ||= @extensions.collect { |name, plugin|
         Process.fork {
           $0 = "stubby: [extension worker] #{plugin.class.name}"
           plugin.run!(self, {})
         }
       }
 
-      trap("INT") { 
-        stop_extensions
+      trap("INT", important: true) { 
+        stop!
       }
 
       return @running_extensions

data/lib/stubby/process.rb

@@ -0,0 +1,22 @@
+require 'timeout'
+
+module Process extend self
+  def running?(pid)
+    !!(kill(0, pid))
+  rescue
+    false
+  end
+
+  def shutdown(pid, timeout=10, sig1="TERM", sig2="KILL")
+    puts "Shutting down: #{pid}"
+
+    kill(sig1, pid)
+
+    Timeout::timeout(timeout) do
+      sleep 1 and puts "." while running?(pid)
+    end 
+  rescue Timeout::Error
+    kill(sig2, pid)
+  end
+
+end

data/lib/stubby/registry.rb

@@ -3,46 +3,32 @@ require 'httpi'
 
 module Stubby
   class RegistryItem
-    attr_accessor :name, :version, :source, :location
+    attr_accessor :name, :source
 
-    def initialize(name, version, source)
-      @name = name
-      @version = version
-      @source = source
-      @location = "~/.stubby/#{name}"
+    def initialize(source)
+      @source = URI.parse(source)
+      @name = @source.path
     end
 
-    def version
-      @version.slice(1, @version.length)
+    def install
+      `mkdir -p #{path}`
+      `cd #{path} && git clone #{@source} .`
     end
 
-    def install
-      if File.exists? source
-        uninstall
-        `ln -s #{source} ~/.stubby/#{name}`
-      else
-        `mkdir -p ~/.stubby`
-        download source, "~/.stubby/#{name}.zip"
-        `curl #{source} > ~/.stubby/#{name}.zip`
-        `unzip -d ~/.stubby/ #{source}`
-        `rm ~/.stubby/#{name}.zip`
-      end
+    def path
+      "~/.stubby/#{@source.path}"
     end
 
     def uninstall
-      `rm -rf ~/.stubby/#{name}`
+      `rm -rf ~/.stubby/#{@source.path}`
     end
 
     def installed?
-      File.exists? @location
-    end
-
-    def download(source, destination)
-      `curl #{source} #{destination}` 
+      File.exists? path
     end
 
     def config
-      File.join("~", ".stubby", name, "stubby.json")
+      "~/.stubby/#{@source.path}/stubby.json"
     end
 
     def stub(target=nil)
@@ -52,97 +38,12 @@ module Stubby
   end
 
   class Registry
-    def index
-      Hash[(remote_index || local_index).collect { |name, versions|
-        [name, versions.collect { |version, source|
-          RegistryItem.new name, version, source
-        }]
-      }]
-    end
-
-    def versions(name)
-      if index[name]
-        index[name].sort { |x, y|
-          Gem::Version.new(y.version) <=> Gem::Version.new(x.version)
-        }
-      else
-        []
-      end
-    end
-
-    def version(name, version)
-      version = version.gsub("v", "")
-
-      index[name].detect { |stub|
-        stub.version == version
-      }
-    end
-
-    def latest(name)
-      versions(name).first
-    end
-
-    def install(name, opts={})
-      source = opts[:source]
-      v = opts[:version]
-
-      if name =~ /https?:\/\//
-        source = name
-        name = File.basename(name).split(".").first
-        RegistryItem.new(name, "v1.0.0", source).install
-      else
-        stub = v.nil? ? latest(name) : version(name, v) 
-
-        if stub
-          stub.install
-        elsif source
-          add_new_source(name, source, v)
-        else
-          puts "[ERROR] Cannot find #{name} at #{v}"
-        end
-      end
+    def install(source)
+      RegistryItem.new(source).install
     end
 
-    def uninstall(name)
-      # TODO: we're not doing a search of the installed stubs'
-      # version, but we have a convention of using a ~/.stubby/NAME
-      # location, so this shouldn't be a problem for the POC
-      if name =~ /https?:\/\//
-        name = File.basename(name).split(".").first
-      end
-
-      latest(name).uninstall
-    end
-
-
-    private
-
-    def remote_index
-      response = HTTPI.get("http://github.com/jkassemi/stubby/index.json")
-      MultiJson.load(response.body) if response.code == 200
-    end
-
-    def local_index
-      MultiJson.load(File.read(File.expand_path(File.join('~', '.stubby', "index.json"))))
-    rescue 
-      {}
-    end
-
-    def write_local_index(&block)
-      File.open File.expand_path(File.join('~', '.stubby', "index.json")), "w", &block
-    end
-
-    def add_new_source(name, source, v=nil)
-      version = v.nil? ? 'v0.0.1' : v
-
-      item = RegistryItem.new name, version, source
-      item.install
-
-      current_index = local_index
-
-      write_local_index do |index|
-        index.puts MultiJson.dump(local_index.merge({item.name => {item.version => item.location}}))
-      end
+    def uninstall(source)
+      RegistryItem.new(source).uninstall
     end
   end
 end

data/lib/stubby/stub.rb

@@ -1,5 +1,3 @@
-require 'pry'
-
 module Stubby
   class Stub
     attr_accessor :target, :path, :modes
@@ -12,8 +10,11 @@ module Stubby
 
     def modes
       @modes ||= MultiJson.load(File.read(path))
-    rescue
-      {}
+    rescue => e
+      if File.exists?(path)
+        puts "[INFO] Problem parsing #{path}"
+        raise e
+      end
     end
 
     def path=(v)
@@ -25,8 +26,14 @@ module Stubby
       @path = File.expand_path(v)
     end
 
+    def target=(environment)
+      @environment = environment 
+      @options = nil
+      options
+    end
+
     def options
-      modes[target] || {}
+      @options ||= expand(modes[@environment] || {})
     end
 
     def search(trigger)
@@ -38,11 +45,16 @@ module Stubby
 
       return nil
     end
+
+    private
+    def expand(options)
+      Stubby::Api.expand_rules(options) 
+    end
   end
 
   class TransientStub < Stub
     def initialize(options)
-      @options = options
+      @options = expand(options)
     end
 
     def modes 

data/lib/stubby.rb

@@ -1,10 +1,17 @@
 STUBBY_MASTER="172.16.123.1"
 
+require 'oj'
 require 'multi_json'
+require 'rubygems'
+require 'bundler/setup'
 require 'stubby/extensions/dns/osx'
 require 'stubby/extensions/dns'
 require 'stubby/extensions/http'
+require 'stubby/extensions/smtp'
 require 'stubby/extensions/reload'
+require 'stubby/extensions/default'
 require 'stubby/registry'
 require 'stubby/stub'
 require 'stubby/master'
+require 'stubby/process'
+require 'stubby/kernel'