stubby 0.0.1

data/lib/stubby/extensions/http.rb

@@ -0,0 +1,203 @@
+require 'logger'
+require 'sinatra/base'
+require 'liquid'
+require 'httpi'
+require 'rack/ssl'
+
+module Extensions
+  module HTTP
+    class NotFoundException < Exception
+    end
+
+    class HTTPApp < Sinatra::Base
+      class << self
+        def port
+          80
+        end
+
+        def run!(session, server_settings={})
+          puts self.inspect + ": " + port.to_s
+          
+          set :bind, STUBBY_MASTER
+          set :port, port
+          set :stubby_session, session
+          set :server, 'thin'
+
+          super(:server_settings => server_settings)
+        end
+
+        def adapter(name, &block)
+          adapters[name] = block
+        end
+
+        def adapters
+          @@adapters ||= {}
+        end
+      end
+
+      set :run, false
+      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)
+      end
+
+      adapter "file" do
+        paths = []
+
+        if url.host == "-"
+          paths << File.expand_path(File.join("~/.stubby/#{request.host}", request.path))
+          paths << File.expand_path(File.join("/usr/local/stubby/#{request.host}", request.path))
+        else
+          paths << File.expand_path(File.join(url.path, request.path))
+        end
+
+        paths.each do |path|
+          next if path.index(url.path) != 0
+          
+          p = [path, File.join(path, "index.html")].select { |path|
+            File.exists?(path) and !File.directory?(path)
+          }.first
+
+          send_file(p) and break unless p.nil?
+        end
+
+        not_found(paths.join(",\n"))
+      end
+
+      adapter "default" do
+        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
+
+          response = HTTPI.get(request)
+
+          response.headers.delete "transfer-encoding"
+          response.headers.delete "connection"
+
+          status(response.code)
+          headers(response.headers)
+          body(response.body)
+
+        else
+          # Proxy to the given path
+          request = HTTPI::Request.new
+          request.url = url.to_s
+
+          response = HTTPI.get(request)
+
+          response.headers.delete "transfer-encoding"
+          response.headers.delete "connection"
+
+          status(response.code)
+          headers(response.headers)
+          body(response.body)
+        end
+      end
+
+      get(//) do
+        if instruction.nil?
+          not_found
+        elsif adapter=self.class.adapters[url.scheme]
+          instance_eval &adapter
+        else
+          instance_eval &self.class.adapters["default"]
+        end
+      end	
+
+      private
+      def forbidden
+        [403, "Forbidden"]
+      end
+
+      def not_found(resource="*unknown*")
+        [404, "Not Found:\n #{resource}"]
+      end
+
+      def instruction
+        MultiJson.load(HTTPI.post("http://#{STUBBY_MASTER}:9000/rules/search.json", 
+          trigger: "#{request.scheme}://#{request.host}").body)
+      end
+
+      def url
+        @url ||= URI.parse(instruction)
+      end
+    end
+
+    # TODO: get SSL support running. Self signed cert
+    class HTTPSApp < HTTPApp
+      use Rack::SSL
+
+      class << self
+        def port
+          443
+        end
+
+        def run!(session)
+          set :bind, STUBBY_MASTER
+          set :port, port
+          set :stubby_session, session
+
+          #super(session, {
+          #  :SSLEnable => true,
+          #  :SSLCertName => %w[CN localhost]
+          #})
+
+          Rack::Handler::Thin.run(self, {
+            :Host => STUBBY_MASTER,
+            :Port => 443
+          }) do |server|
+            server.ssl = true
+            server.ssl_options = {
+              :verify_peer => false
+            }
+          end
+        rescue => e
+          puts "#{e.inspect}" 
+        end
+      end
+    end
+
+    class Server
+      def initialize
+        @log = Logger.new(STDOUT)
+      end
+
+      def run!(session, options)
+        return if options[:http] == false
+
+        @session = session
+        HTTPApp.run!(session)
+      end
+
+      def stop!
+        HTTPApp.quit!
+      end
+    end
+
+    class SSLServer < Server
+      def run!(session, options)
+        return if options[:https] == false
+
+        @session = session
+        HTTPSApp.run!(session)
+      end
+
+      def stop!
+        HTTPSApp.quit!
+      end
+    end
+  end
+end
+

data/lib/stubby/extensions/reload.rb

@@ -0,0 +1,46 @@
+require 'listen'
+
+module Extensions
+  class Reload
+    def run!(session, options)
+      @options = options
+      @session = session
+      return if @options[:reload] == false
+
+      listener.start
+      sleep 1 while @listener
+      puts 'run! done'
+    end
+
+    def stop!
+      return if @options[:reload] == false
+      @listener.stop and @listener = nil if @listener
+      puts 'stop! done'
+    end
+
+    private
+    def root_path
+      @session.system.root_path
+    end
+
+    def session_config_path
+      @session.system.session_config_path
+    end
+
+    def listener
+      return @listener if @listener
+
+      puts "NEW LISTENER"
+
+      @listener ||= Listen.to(root_path, debug: true) do |modified, added, removed|
+        (modified + added).each do |mpath|
+          puts "[INFO] Detected change, test identical #{mpath}"
+          if File.identical?(session_config_path, mpath)
+            puts "[INFO] Detected config change, reloading #{mpath}..."
+            @session.system.reload
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stubby/master.rb

@@ -0,0 +1,182 @@
+require 'sinatra/json'
+
+module Stubby
+  class Api < Sinatra::Base
+    class << self
+      attr_accessor :enabled_stubs
+      attr_accessor :registry
+      attr_accessor :environments, :environment
+
+      def enabled_stubs
+        @enabled_stubs ||= {} 
+      end
+
+      def registry
+        @registry ||= Stubby::Registry.new
+      end
+
+      def reset
+        @enabled_stubs = nil
+        @environment = nil
+        @registry = nil
+      end
+
+      def env_settings
+        (@environments[environment] || {}).dup
+      end
+
+      def environment=(name)
+        reset
+        @environment = name
+
+        (env_settings["dependencies"] || []).each do |depname, mode|
+          activate(depname, mode)
+        end
+
+        env_settings.delete("dependencies")
+
+        activate_transient(env_settings)
+      end
+
+      def activate(name, mode)
+        registry_item = registry.latest(name)
+        registry_item.install
+        self.enabled_stubs[name] = registry_item.stub(mode)
+      end
+
+      def activate_transient(options)
+        self.enabled_stubs["_"] = TransientStub.new(options)
+      end
+    end
+
+    set :bind, STUBBY_MASTER
+    set :port, 9000
+    set :run, false
+    set :static, false
+
+    get "/status" do
+      json status: "ok"
+    end
+
+    get "/stubs/available.json" do
+      json Api.registry.index
+    end
+
+    get "/stubs/activated.json" do
+      json Hash[Api.enabled_stubs.collect { |name, stub|
+        [name, stub.options]
+      }]
+    end
+
+    post "/reset.json" do
+      Api.reset
+      json status: "ok"
+    end
+
+    get "/environment.json" do
+      json environment: (Api.environment || "undefined")
+    end
+
+    post "/environment.json" do
+      Api.environment = params[:environment]
+      json status: "ok"
+    end
+
+    get "/environments.json" do
+      json environments: Api.environments
+    end
+
+    post "/stubs/transient/activate.json" do
+      Api.activate_transient(params[:options])
+      json status: "ok"
+    end
+
+    post "/stubs/activate.json" do
+      Api.activate(params[:name], params[:mode])
+      json status: "ok"
+    end
+
+    post "/rules/search.json" do
+      json Api.enabled_stubs.collect { |_, stub|
+        stub.search(params[:trigger])
+      }.compact.first
+    end
+  end
+
+  class Master
+    attr_accessor :extensions, :config
+
+    def initialize(environments)
+      @extensions = [
+        Extensions::DNS::Server.new,
+        Extensions::HTTP::Server.new,
+        Extensions::HTTP::SSLServer.new
+      ]
+
+      @config = Api
+      @config.environments = environments
+    end
+
+    def environment=(environment)
+      @config.environment = environment
+    end
+
+    def run!(options={})
+      begin
+        assume_network_interface
+
+        running.each do |process|
+          puts "wait for #{process}"
+          Process.waitpid(process)
+        end
+      ensure
+        unassume_network_interface
+      end
+    end
+
+    private
+    def stop_extensions
+      puts "Shutting down..."
+
+      running.each do |process|
+        Process.kill("INT", 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!
+      }
+    end
+
+    def run_extensions
+      @running_extensions ||= @extensions.collect { |plugin|
+        Process.fork {
+          $0 = "stubby: [extension worker] #{plugin.class.name}"
+          plugin.run!(self, {})
+        }
+      }
+
+      trap("INT") { 
+        stop_extensions
+      }
+
+      return @running_extensions
+    end
+
+    def assume_network_interface
+      `ifconfig lo0 alias #{STUBBY_MASTER}`
+    end
+
+    def unassume_network_interface
+      `ifconfig lo0 -alias #{STUBBY_MASTER}`
+    end
+  end
+end

data/lib/stubby/registry.rb

@@ -0,0 +1,148 @@
+require 'pry'
+require 'httpi'
+
+module Stubby
+  class RegistryItem
+    attr_accessor :name, :version, :source, :location
+
+    def initialize(name, version, source)
+      @name = name
+      @version = version
+      @source = source
+      @location = "~/.stubby/#{name}"
+    end
+
+    def version
+      @version.slice(1, @version.length)
+    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
+    end
+
+    def uninstall
+      `rm -rf ~/.stubby/#{name}`
+    end
+
+    def installed?
+      File.exists? @location
+    end
+
+    def download(source, destination)
+      `curl #{source} #{destination}` 
+    end
+
+    def config
+      File.join("~", ".stubby", name, "stubby.json")
+    end
+
+    def stub(target=nil)
+      install unless installed?
+      Stub.new(config, target)
+    end
+  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
+    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
+    end
+  end
+end

data/lib/stubby/stub.rb

@@ -0,0 +1,56 @@
+require 'pry'
+
+module Stubby
+  class Stub
+    attr_accessor :target, :path, :modes
+
+    # TODO: target is mode, rename
+    def initialize(path, target=nil)
+      self.path = path
+      self.target = target
+    end
+
+    def modes
+      @modes ||= MultiJson.load(File.read(path))
+    rescue
+      {}
+    end
+
+    def path=(v)
+      unless v and File.exists?(File.expand_path(v))
+        puts "'#{v}' not found. Use --config to specify a different config file"
+        exit
+      end
+
+      @path = File.expand_path(v)
+    end
+
+    def options
+      modes[target] || {}
+    end
+
+    def search(trigger)
+      options.each do |rule, instruction|
+        if Regexp.new(rule, Regexp::EXTENDED | Regexp::IGNORECASE).match(trigger)
+          return instruction
+        end
+      end
+
+      return nil
+    end
+  end
+
+  class TransientStub < Stub
+    def initialize(options)
+      @options = options
+    end
+
+    def modes 
+      {}
+    end
+
+    def options
+      @options
+    end 
+  end
+end

data/lib/stubby.rb

@@ -0,0 +1,10 @@
+STUBBY_MASTER="172.16.123.1"
+
+require 'multi_json'
+require 'stubby/extensions/dns/osx'
+require 'stubby/extensions/dns'
+require 'stubby/extensions/http'
+require 'stubby/extensions/reload'
+require 'stubby/registry'
+require 'stubby/stub'
+require 'stubby/master'