stubby 0.0.10 → 0.0.11

data/lib/stubby/extensions/dns/osx.rb

@@ -1,58 +1,78 @@
 # This module extracts the OS level DNS configuration dependency for OSX.
-module Extensions
-  module DNS
-    module OSX
-      private
-        def servers_for(interface)
-          servers = `networksetup -getdnsservers '#{interface}'`
+module Stubby
+  module Extensions
+    module DNS
+      module OSX
+        private
+          def servers_for(interface)
+            servers = `networksetup -getdnsservers '#{interface}'`
 
-          if servers =~ /There aren't any DNS Servers/
-            return ["empty"]
-          else
-            return servers.split("\n")
+            if servers =~ /There aren't any DNS Servers/
+              return ["empty"]
+            else
+              return servers.split("\n")
+            end
           end
-        end
 
-        def setup_reference(interface)
-          return if interface.include? "*"
-          @network_interfaces[interface] = servers_for(interface)
-          puts "[INFO] #{interface} configured with Stubby DNS. Will restore to #{@network_interfaces[interface]}"
-          `networksetup -setdnsservers '#{interface}' #{STUBBY_MASTER}`
-        end
+          def setup_reference(interface)
+            return if interface.include? "*"
+            puts "[INFO] #{interface} configured with Stubby DNS. Will restore to #{@network_interfaces[interface]}"
+            `networksetup -setdnsservers '#{interface}' #{STUBBY_MASTER}`
+          end
+
+          def teardown_reference(interface, servers)
+            `networksetup -setdnsservers '#{interface}' #{servers.join(" ")}`
+            puts "[INFO] #{interface} original DNS settings restored #{servers.join(" ")}"
+          rescue => e
+            puts e.inspect
+          end
 
-        def teardown_reference(interface, servers)
-          `networksetup -setdnsservers '#{interface}' #{servers.join(" ")}`
-          puts "[INFO] #{interface} original DNS settings restored #{servers.join(" ")}"
-        rescue => e
-          puts e.inspect
-        end
+          def setup_references
+            # TODO: if we connect to a new network, we'd like that to use us, too
+            return if @network_interfaces
 
-        def setup_references
-          # TODO: if we connect to a new network, we'd like that to use us, too
-          return if @network_interfaces
+            network_interfaces.each do |interface, servers|
+              setup_reference(interface)
+            end
 
-          @network_interfaces = {}
-          `networksetup listallnetworkservices`.split("\n").each do |interface|
-            next if interface.include? '*'
-            setup_reference(interface)
+            flush
           end
 
-          flush
-        end
+          def network_interfaces
+            # TODO: if we connect to a new network, we'd like that to use us, too
+            return @network_interfaces if @network_interfaces
 
-        def teardown_references
-          interfaces, @network_interfaces = @network_interfaces, nil
+            @network_interfaces = {}
+            `networksetup listallnetworkservices`.split("\n").each do |interface|
+              next if interface.include? '*'
+              @network_interfaces[interface] = servers_for(interface)
+            end
+
+            @network_interfaces
+          end
 
-          (interfaces || []).each do |interface, servers| 
-            teardown_reference(interface, servers)
+          # This is less of a complete restoration and actually
+          # a return to no defaults
+          def restore_references
+            network_interfaces.each do |interface, servers|
+              teardown_reference(interface, ["empty"])
+            end
           end
 
-          flush
-        end
+          def teardown_references
+            interfaces, @network_interfaces = @network_interfaces, nil
 
-        def flush
-          `dscacheutil -flushcache`
-        end
+            (interfaces || []).each do |interface, servers| 
+              teardown_reference(interface, servers)
+            end
+
+            flush
+          end
+
+          def flush
+            `dscacheutil -flushcache`
+          end
+      end
     end
   end
 end

data/lib/stubby/extensions/http.rb

@@ -4,237 +4,242 @@ require 'liquid'
 require 'httpi'
 require 'rack/ssl'
 
-module Extensions
-  module HTTP
-    class NotFoundException < Exception
-    end
+module Stubby
+  module Extensions
+    module HTTP
+      class NotFoundException < Exception
+      end
 
-    class HTTPApp < Sinatra::Base
-      class << self
-        def port
-          80
-        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'
+          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
+            super(:server_settings => server_settings)
+          end
 
-        def adapter(*names, &block)
-          names.each do |name|
-            adapters[name] = block
+          def adapter(*names, &block)
+            names.each do |name|
+              adapters[name] = block
+            end
           end
-        end
 
-        def adapters
-          @@adapters ||= {}
+          def adapters
+            @@adapters ||= {}
+          end
         end
-      end
 
-      set :run, false
-      set :static, false
+        set :run, false
+        set :static, false
 
-      adapter "http-redirect" do
-        r = URI.parse(instruction_params["to"])
-        r.path = request.path if r.path.blank?
+        adapter "http-redirect" do
+          r = URI.parse(instruction_params["to"])
+          r.path = request.path if r.path.blank?
 
-        redirect to(r.to_s)
-      end
+          redirect to(r.to_s)
+        end
 
-      adapter "file" do
-        paths = []
+        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
+          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
+          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
+            send_file(p) and break unless p.nil?
+          end
 
-        not_found(paths.join(",\n"))
-      end
+          not_found(paths.join(",\n"))
+        end
 
-      adapter "http-proxy" do
-        run_proxy("http")
-      end
+        adapter "http-proxy" do
+          run_proxy("http")
+        end
 
-      adapter "https-proxy" do
-        run_proxy("https")
-      end
+        adapter "https-proxy" do
+          run_proxy("https")
+        end
 
-      %w(get post put patch delete options link unlink).each do |method|
-        send(method, //) do
-          run_handler
+        %w(get post put patch delete options link unlink).each do |method|
+          send(method, //) do
+            run_handler
+          end
         end
-      end
 
-      private
-      def run_handler
-        if instruction.nil?
-          not_found
-        elsif adapter=self.class.adapters[url.scheme]
-          instance_eval &adapter
-        else
-          instance_eval &self.class.adapters["default"]
+        private
+        def run_handler
+          if instruction.nil?
+            not_found
+          elsif adapter=self.class.adapters[url.scheme]
+            instance_eval &adapter
+          else
+            instance_eval &self.class.adapters["default"]
+          end
         end
-      end
 
-      def run_proxy(scheme)
-        to = url.dup
-        to.scheme = scheme
-        to.path = request.path if to.path.empty?
-        to.query = request.query_string
+        def run_proxy(scheme)
+          to = url.dup
+          to.scheme = scheme
+          to.path = request.path if to.path.empty?
+          to.query = request.query_string
 
-        puts "#{to.to_s} scheme: #{request.scheme}"
+          puts "#{to.to_s} scheme: #{request.scheme}"
 
-        r = HTTPI::Request.new
-        r.url = to.to_s
-      
-        # TODO: this is a hack, should support streaming the bodies
-        # and handling the headers more systematically (allow
-        # keep-alives and transfer encoding)
-        r.headers.merge! Hash[(env.select { |k,v| v.is_a? String }.collect { |k,v| [k.gsub("HTTP_", "").gsub("_", "-"), v] })]
-        r.headers["HOST"] = request.host
-        r.headers["STUBBY-ENV"] = settings.stubby_session.environment
-        r.headers["STUBBY-KEY"] = settings.stubby_session.key(instruction)
-        r.headers["STUBBY-USER"] = settings.stubby_session.user_key
-        r.headers["X-FORWARDED-PROTO"] = request.scheme
-        r.headers["X-FORWARDED-FOR"] = request.ip
-        r.headers["CONNECTION"] = "close"
-        r.headers.delete "ACCEPT-ENCODING"
-
-        request.body.rewind
-        r.body = request.body.read
-
-        response = HTTPI.request(request.request_method.downcase.to_sym, r)
+          r = HTTPI::Request.new
+          r.url = to.to_s
         
-        response.headers.delete "TRANSFER-ENCODING"
+          # TODO: this is a hack, should support streaming the bodies
+          # and handling the headers more systematically (allow
+          # keep-alives and transfer encoding)
+          r.headers.merge! Hash[(env.select { |k,v| v.is_a? String }.collect { |k,v| [k.gsub("HTTP_", "").gsub("_", "-"), v] })]
+          r.headers["HOST"] = request.host
+          r.headers["STUBBY-ENV"] = settings.stubby_session.environment
+          r.headers["STUBBY-KEY"] = settings.stubby_session.key(instruction)
+          r.headers["STUBBY-USER"] = settings.stubby_session.user_key
+          r.headers["X-FORWARDED-PROTO"] = request.scheme
+          r.headers["X-FORWARDED-FOR"] = request.ip
+          r.headers["CONNECTION"] = "close"
+          r.headers.delete "ACCEPT-ENCODING"
+
+          request.body.rewind
+          r.body = request.body.read
+
+          response = HTTPI.request(request.request_method.downcase.to_sym, r)
+          
+          response.headers.delete "TRANSFER-ENCODING"
 
-        status(response.code)
-        puts "response: #{response.headers}"
+          status(response.code)
+          puts "response: #{response.headers}"
 
-        headers(response.headers)
-        body(response.body)
-      end
+          headers(response.headers)
+          body(response.body)
+        end
 
-      def forbidden
-        [403, "Forbidden"]
-      end
+        def forbidden
+          [403, "Forbidden"]
+        end
 
-      def not_found(resource="*unknown*")
-        [404, "Not Found:\n #{resource}"]
-      end
+        def not_found(resource="*unknown*")
+          [404, "Not Found:\n #{resource}"]
+        end
 
-      def instruction
-        @instruction ||= MultiJson.load(HTTPI.post("http://#{STUBBY_MASTER}:9000/rules/search.json", 
-          trigger: "#{request.scheme}://#{request.host}").body)
-      end
+        def instruction
+          @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 instruction_params
+          Rack::Utils.parse_nested_query url.query
+        end
 
-      def url
-        @url ||= URI.parse(instruction)
+        def url
+          @url ||= URI.parse(instruction)
+        end
       end
-    end
 
-    # TODO: get SSL support running. Self signed cert
-    class HTTPSApp < HTTPApp
-      use Rack::SSL
-
-      class << self
-        def port
-          443
-        end
+      # TODO: get SSL support running. Self signed cert
+      class HTTPSApp < HTTPApp
+        use Rack::SSL
 
-        def run!(session)
-          set :bind, STUBBY_MASTER
-          set :port, port
-          set :stubby_session, session
+        class << self
+          def port
+            443
+          end
 
-          Rack::Handler::Thin.run(self, {
-            :Host => STUBBY_MASTER,
-            :Port => 443
-          }) do |server|
-            server.ssl = true
-            server.ssl_options = {
-              :verify_peer => false
-            }
+          def run!(session)
+            set :bind, STUBBY_MASTER
+            set :port, port
+            set :stubby_session, session
+
+            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
-        rescue => e
-          puts "#{e.inspect}" 
         end
       end
-    end
 
-    class Server
-      def initialize
-        @log = Logger.new(STDOUT)
-      end
+      class Server
+        def initialize
+          @log = Logger.new(STDOUT)
+        end
 
-      def run!(session, options)
-        return if options[:http] == false
+        def run!(session, options)
+          return if options[:http] == false
 
-        @session = session
-        HTTPApp.run!(session)
-      end
+          @session = session
+          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
+        # 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
 
-      def stop!
-        HTTPApp.quit!
+        def restore!
+          # nil
+        end
       end
-    end
 
-    class SSLServer < Server
-      def run!(session, options)
-        return if options[:https] == false
+      class SSLServer < Server
+        def run!(session, options)
+          return if options[:https] == false
 
-        @session = session
-        HTTPSApp.run!(session)
-      end
+          @session = session
+          HTTPSApp.run!(session)
+        end
 
-      def stop!
-        HTTPSApp.quit!
-      end
+        def stop!
+          HTTPSApp.quit!
+        end
 
-      def expand_rule(trigger, instruction)
-        super(trigger, instruction, "https")
+        def expand_rule(trigger, instruction)
+          super(trigger, instruction, "https")
+        end
       end
     end
   end
 end
-