meepo 1.5.2

data/lib/invoker/power/balancer.rb

@@ -0,0 +1,131 @@
+require 'em-proxy'
+require 'http-parser'
+require "invoker/power/http_parser"
+require "invoker/power/url_rewriter"
+
+module Invoker
+  module Power
+    class InvokerHttpProxy < EventMachine::ProxyServer::Connection
+      attr_accessor :host, :ip, :port
+      def set_host(host, selected_backend)
+        self.host = host
+        self.ip = selected_backend[:host]
+        self.port = selected_backend[:port]
+      end
+    end
+
+    class InvokerHttpsProxy < InvokerHttpProxy
+      def post_init
+        super
+        start_tls
+      end
+    end
+
+    class Balancer
+      attr_accessor :connection, :http_parser, :session, :protocol, :upgraded_to
+
+      def self.run(options = {})
+        start_http_proxy(InvokerHttpProxy, 'http', options)
+        start_http_proxy(InvokerHttpsProxy, 'https', options)
+      end
+
+      def self.start_http_proxy(proxy_class, protocol, options)
+        port = protocol == 'http' ? Invoker.config.http_port : Invoker.config.https_port
+        EventMachine.start_server('0.0.0.0', port,
+                                  proxy_class, options) do |connection|
+          balancer = Balancer.new(connection, protocol)
+          balancer.install_callbacks
+        end
+      end
+
+      def initialize(connection, protocol)
+        @connection = connection
+        @protocol = protocol
+        @http_parser = HttpParser.new(protocol)
+        @session = nil
+        @upgraded_to = nil
+        @buffer = []
+      end
+
+      def install_callbacks
+        http_parser.on_headers_complete { |headers| headers_received(headers) }
+        http_parser.on_message_complete { |full_message| complete_message_received(full_message) }
+        connection.on_data { |data| upstream_data(data) }
+        connection.on_response { |backend, data| backend_data(backend, data) }
+        connection.on_finish { |backend, name| frontend_disconnect(backend, name) }
+      end
+
+      def complete_message_received(full_message)
+        connection.relay_to_servers(full_message)
+        http_parser.reset
+      end
+
+      def headers_received(headers)
+        if @session
+          return
+        end
+        @session = UUID.generate()
+        if !headers['Host'] || headers['Host'].empty?
+          return_error_page(400)
+          return
+        end
+
+        dns_check_response = UrlRewriter.new.select_backend_config(headers['Host'])
+        if dns_check_response && dns_check_response.port
+          connection.server(session, host: dns_check_response.ip, port: dns_check_response.port)
+        else
+          return_error_page(404)
+          http_parser.reset
+          connection.close_connection_after_writing
+        end
+      end
+
+      def upstream_data(data)
+        if upgraded_to == "websocket"
+          data
+        else
+          append_for_http_parsing(data)
+          nil
+        end
+      end
+
+      def append_for_http_parsing(data)
+        http_parser << data
+      rescue HTTP::Parser::Error
+        http_parser.reset
+        connection.close_connection_after_writing
+      end
+
+      def backend_data(backend, data)
+        @backend_data = true
+
+        # check backend data for websockets connection. check for upgrade headers
+        # - Upgarde: websocket\r\n
+        if data =~ /Upgrade: websocket/
+          @upgraded_to = "websocket"
+        end
+
+        data
+      end
+
+      def frontend_disconnect(backend, name)
+        http_parser.reset
+        unless @backend_data
+          return_error_page(503)
+        end
+        @backend_data = false
+        connection.close_connection_after_writing if backend == session
+      end
+
+      private
+
+      def return_error_page(status)
+        http_response = Invoker::Power::HttpResponse.new()
+        http_response.status = status
+        http_response['Content-Type'] = "text/html; charset=utf-8"
+        http_response.use_file_as_body(File.join(File.dirname(__FILE__), "templates/#{status}.html"))
+        connection.send_data(http_response.http_string)
+      end
+    end
+  end
+end

data/lib/invoker/power/config.rb

@@ -0,0 +1,77 @@
+require "yaml"
+
+module Invoker
+  module Power
+    # Save and Load Invoker::Power config
+    class ConfigExists < StandardError; end
+
+    class Config
+      def self.has_config?
+        File.exist?(config_file)
+      end
+
+      def self.create(options = {})
+        if has_config?
+          raise ConfigExists, "Config file already exists at location #{config_file}"
+        end
+        config = new(options)
+        config.save
+      end
+
+      def self.delete
+        if File.exist?(config_file)
+          File.delete(config_file)
+        end
+      end
+
+      def self.config_file
+        File.join(Invoker.home, ".invoker", "config")
+      end
+
+      def self.config_dir
+        File.join(Invoker.home, ".invoker")
+      end
+
+      def initialize(options = {})
+        @config = options
+      end
+
+      def self.load_config
+        config_hash = File.open(config_file, "r") { |fl| YAML.load(fl) }
+        new(config_hash)
+      end
+
+      def dns_port=(dns_port)
+        @config[:dns_port] = dns_port
+      end
+
+      def http_port=(http_port)
+        @config[:http_port] = http_port
+      end
+
+      def https_port=(https_port)
+        @config[:https_port] = https_port
+      end
+
+      def ipfw_rule_number=(ipfw_rule_number)
+        @config[:ipfw_rule_number] = ipfw_rule_number
+      end
+
+      def dns_port; @config[:dns_port]; end
+      def http_port; @config[:http_port]; end
+      def ipfw_rule_number; @config[:ipfw_rule_number]; end
+      def https_port; @config[:https_port]; end
+
+      def tld
+        @config[:tld] || Invoker.default_tld
+      end
+
+      def save
+        File.open(self.class.config_file, "w") do |fl|
+          YAML.dump(@config, fl)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/invoker/power/dns.rb

@@ -0,0 +1,38 @@
+require "logger"
+require 'rubydns'
+
+module Invoker
+  module Power
+    class DNS < RubyDNS::Server
+      def self.server_ports
+        [
+          [:udp, '127.0.0.1', Invoker.config.dns_port],
+          [:tcp, '127.0.0.1', Invoker.config.dns_port]
+        ]
+      end
+
+      def initialize
+        @logger = ::Logger.new($stderr)
+        @logger.level = ::Logger::FATAL
+      end
+
+      def process(name, resource_class, transaction)
+        if name_matches?(name) && resource_class_matches?(resource_class)
+          transaction.respond!("127.0.0.1")
+        else
+          transaction.fail!(:NXDomain)
+        end
+      end
+
+      private
+
+      def resource_class_matches?(resource_class)
+        resource_class == Resolv::DNS::Resource::IN::A
+      end
+
+      def name_matches?(name)
+        name =~ /.*\.#{Invoker.config.tld}/
+      end
+    end
+  end
+end

data/lib/invoker/power/http_parser.rb

@@ -0,0 +1,68 @@
+module Invoker
+  module Power
+    class HttpParser
+      attr_accessor :host, :parser, :protocol
+
+      def initialize(protocol)
+        @protocol = protocol
+        @parser = HTTP::Parser.new
+        @header = {}
+        initialize_message_content
+        parser.on_headers_complete { complete_headers_received }
+        parser.on_header_field { |field_name| @last_key = field_name }
+        parser.on_header_value { |field_value| header_value_received(field_value) }
+
+        parser.on_message_complete { complete_message_received }
+      end
+
+      # define a callback for invoking when complete header is parsed
+      def on_headers_complete(&block)
+        @on_headers_complete_callback = block
+      end
+
+      def header_value_received(value)
+        @header[@last_key] = value
+      end
+
+      # define a callback to invoke when a full http message is received
+      def on_message_complete(&block)
+        @on_message_complete_callback = block
+      end
+
+      def reset
+        @header = {}
+        initialize_message_content
+        parser.reset
+      end
+
+      def << data
+        @full_message.write(data)
+        parser << data
+      end
+
+      private
+
+      def complete_message_received
+        full_message_string = @full_message.string.dup
+        if full_message_string =~ /\r\n\r\n/
+          full_message_string.sub!(/\r\n\r\n/, "\r\nX_FORWARDED_PROTO: #{protocol}\r\n\r\n")
+        end
+        if @on_message_complete_callback
+          @on_message_complete_callback.call(full_message_string)
+        end
+      end
+
+      def initialize_message_content
+        @full_message = StringIO.new
+        @full_message.set_encoding('ASCII-8BIT')
+      end
+
+      # gets invoker when complete header is received
+      def complete_headers_received
+        if @on_headers_complete_callback
+          @on_headers_complete_callback.call(@header)
+        end
+      end
+    end
+  end
+end

data/lib/invoker/power/http_response.rb

@@ -0,0 +1,81 @@
+require 'time'
+
+module Invoker
+  module Power
+    class HttpResponse
+      STATUS_MAPS = {
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        301 => "Moved Permanently",
+        302 => "Found",
+        304 => "Not Modified",
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        411 => "Length Required",
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout"
+      }
+
+      HTTP_HEADER_FIELDS = [
+        'Cache-Control', 'Connection', 'Date',
+        'Pragma', 'Trailer', 'Transfer-Encoding',
+        'Accept-Ranges', 'Age', 'Etag',
+        'Server', 'Location', 'Allow',
+        'Content-Encoding', 'Content-Language', 'Content-Location',
+        'Content-MD5', 'Content-Range',
+        'Content-Type', 'Expires',
+        'Last-Modified', 'extension-header'
+      ]
+
+      attr_accessor :header, :body, :status
+
+      def initialize
+        @header = {}
+        header['Server'] = "Invoker #{Invoker::VERSION}"
+        header['Date'] = Time.now.httpdate
+        @status = 200
+        @body = ""
+      end
+
+      def []=(key, value)
+        header[key] = value
+      end
+
+      def use_file_as_body(file_name)
+        if file_name && File.exists?(file_name)
+          file_content = File.read(file_name)
+          self.body = file_content
+        else
+          raise Invoker::Errors::InvalidFile, "Invalid file as body"
+        end
+      end
+
+      def http_string
+        final_string = []
+        final_string << "HTTP/1.1 #{status} #{STATUS_MAPS[status]}"
+
+        if header['Transfer-Encoding'].nil? && body.empty?
+          header['Content-Length'] = body.length
+        end
+
+        HTTP_HEADER_FIELDS.each do |key|
+          if value = header[key]
+            final_string << "#{key}: #{value}"
+          end
+        end
+
+        final_string.join("\r\n") + "\r\n\r\n" + body
+      end
+    end
+  end
+end

data/lib/invoker/power/pf_migrate.rb

@@ -0,0 +1,64 @@
+module Invoker
+  module Power
+    # for migrating existins users to pf
+    class PfMigrate
+      def firewall_config_requires_migration?
+        return false if !Invoker.darwin?
+        # lets not migrate on osx < 10.10
+        return false if osx_version < Invoker::Version.new("14.0.0")
+        # also verify if firewall config is old
+        check_firewall_file?
+      end
+
+      def migrate
+        if firewall_config_requires_migration? && ask_user_for_migration
+          sudome
+          osx_setup = Invoker::Power::OsxSetup.new(Invoker.config.tld)
+          osx_setup.install_firewall(Invoker.config.http_port, Invoker.config.https_port)
+          drop_to_normal_user
+          Invoker::Logger.puts "Invoker has updated its configuration for yosemite."\
+            " Please restart OSX to complete the configuration process.".color(:red)
+          exit(-1)
+        end
+      end
+
+      def ask_user_for_migration
+        if not_already_root?
+          Invoker::Logger.puts "Invoker has detected you are running OSX 10.10 "\
+            " but your invoker configuration does not support it."
+          Invoker::Logger.puts "Invoker can update its configuration automaticaly"\
+            " but it will require a system reboot.".color(:red)
+          Invoker::CLI::Question.agree("Update Invoker configuration (y/n) :")
+        else
+          true
+        end
+      end
+
+      # http://jimeh.me/blog/2010/02/22/built-in-sudo-for-ruby-command-line-tools/
+      def sudome
+        if not_already_root?
+          exec("sudo #{$0} #{ARGV.join(' ')}")
+        end
+      end
+
+      def not_already_root?
+        ENV["USER"] != "root"
+      end
+
+      def drop_to_normal_user
+        EventMachine.set_effective_user(ENV["SUDO_USER"])
+      end
+
+      def osx_version
+        osx_kernel_version = `uname -r`.strip
+        Invoker::Version.new(osx_kernel_version)
+      end
+
+      def check_firewall_file?
+        return false unless File.exist?(Invoker::Power::OsxSetup::FIREWALL_PLIST_FILE)
+        firewall_contents = File.read(Invoker::Power::OsxSetup::FIREWALL_PLIST_FILE)
+        !!firewall_contents.match(/ipfw/)
+      end
+    end
+  end
+end