itrg-invoker 1.6.0

data/lib/invoker/parsers/config.rb

@@ -0,0 +1,184 @@
+require 'iniparse'
+
+module Invoker
+  module Parsers
+    class Config
+      PORT_REGEX = /\$PORT/
+
+      attr_accessor :processes, :power_config
+      attr_reader :filename
+
+      # initialize takes a port form cli and decrements it by 1 and sets the
+      # instance variable @port. This port value is used as the environment
+      # variable $PORT mentioned inside invoker.ini. When method pick_port gets
+      # fired it increments the value of port by 1, subsequently when pick_port
+      # again gets fired, for another command, it will again increment port
+      # value by 1, that way generating different ports for different commands.
+      def initialize(filename, port)
+        @filename = filename || autodetect_config_file
+        print_message_and_abort if invalid_config_file?
+
+        @port = port - 1
+        @processes = load_config
+        if Invoker.can_run_balancer?
+          @power_config = Invoker::Power::Config.load_config()
+        end
+      end
+
+      def http_port
+        power_config && power_config.http_port
+      end
+
+      def dns_port
+        power_config && power_config.dns_port
+      end
+
+      def https_port
+        power_config && power_config.https_port
+      end
+
+      def tld
+        power_config && power_config.tld
+      end
+
+      def autorunnable_processes
+        process_to_run = processes.reject(&:disable_autorun)
+        process_to_run.sort_by { |process| process.index }
+      end
+
+      def process(label)
+        processes.detect { |pconfig| pconfig.label == label }
+      end
+
+      private
+
+      def autodetect_config_file
+        Dir.glob("{invoker.ini,Procfile.dev,Procfile}").first
+      end
+
+      def invalid_config_file?
+        @filename.nil?
+      end
+
+      def load_config
+        @filename = to_global_file if is_global?
+
+        if is_ini?
+          process_ini
+        elsif is_procfile?
+          process_procfile
+        else
+          print_message_and_abort
+        end
+      end
+
+      def process_ini
+        ini_content = File.read(@filename)
+        document = IniParse.parse(ini_content)
+        document.map do |section|
+          check_directory(section["directory"])
+          process_command_from_section(section)
+        end
+      end
+
+      def process_procfile
+        procfile = Invoker::Parsers::Procfile.new(@filename)
+        procfile.entries.map do |name, command|
+          section = { "label" => name, "command" => command }
+          process_command_from_section(section)
+        end
+      end
+
+      def print_message_and_abort
+        Invoker::Logger.puts("\n Invalid config file. Invoker requires an ini or a Procfile.".colorize(:red))
+        abort
+      end
+
+      def process_command_from_section(section)
+        if supports_subdomain?(section)
+          port = pick_port(section)
+          if port
+            command = replace_port_in_command(section['command'], port)
+            section['port'], section['command'] = port, command
+          end
+        end
+
+        make_pconfig(section)
+      end
+
+      def pick_port(section)
+        if section['command'] =~ PORT_REGEX
+          @port += 1
+        elsif section['port']
+          section['port']
+        else
+          nil
+        end
+      end
+
+      def make_pconfig(section)
+        pconfig = {
+          label: section["label"] || section.key,
+          dir: expand_directory(section["directory"]),
+          cmd: section["command"]
+        }
+        pconfig['port'] = section['port'] if section['port']
+        pconfig['disable_autorun'] = section['disable_autorun'] if section['disable_autorun']
+        pconfig['index'] = section['index'].to_i if section['index']
+        section_index = pconfig['index'].to_i
+        if section_index
+          pconfig['index'] = section_index
+        else
+          pconfig['index'] = 0
+        end
+
+        sleep_duration = section['sleep'].to_i
+        if sleep_duration >= 0
+          pconfig['sleep_duration'] = sleep_duration
+        else
+          pconfig['sleep_duration'] = 0
+        end
+
+        OpenStruct.new(pconfig)
+      end
+
+      def supports_subdomain?(section)
+        (section['command'] =~ PORT_REGEX) || section['port']
+      end
+
+      def check_directory(app_dir)
+        if app_dir && !app_dir.empty? && !File.directory?(expand_directory(app_dir))
+          raise Invoker::Errors::InvalidConfig.new("Invalid directory #{app_dir}")
+        end
+      end
+
+      def expand_directory(app_dir)
+        File.expand_path(app_dir) if app_dir
+      end
+
+      def replace_port_in_command(command, port)
+        if command =~ PORT_REGEX
+          command.gsub(PORT_REGEX, port.to_s)
+        else
+          command
+        end
+      end
+
+      def is_ini?
+        File.extname(@filename) == '.ini'
+      end
+
+      def is_procfile?
+        @filename =~ /Procfile/
+      end
+
+      def to_global_file
+        File.join(Invoker::Power::Config.config_dir, "#{@filename}.ini")
+      end
+
+      def is_global?
+        @filename =~ /^\w+$/ && File.exist?(to_global_file)
+      end
+    end
+  end
+end

data/lib/invoker/parsers/procfile.rb

@@ -0,0 +1,86 @@
+module Invoker
+  module Parsers
+    # rip off from foreman
+    class Procfile
+      # Initialize a Procfile
+      #
+      # @param [String] filename (nil)  An optional filename to read from
+      #
+      def initialize(filename=nil)
+        @entries = []
+        load(filename) if filename
+      end
+
+      # Yield each +Procfile+ entry in order
+      #
+      def entries
+        return @entries unless block_given?
+        @entries.each do |(name, command)|
+          yield name, command
+        end
+      end
+
+      # Retrieve a +Procfile+ command by name
+      #
+      # @param [String] name  The name of the Procfile entry to retrieve
+      #
+      def [](name)
+        @entries.detect { |n,c| name == n }.last
+      end
+
+      # Create a +Procfile+ entry
+      #
+      # @param [String] name     The name of the +Procfile+ entry to create
+      # @param [String] command  The command of the +Procfile+ entry to create
+      #
+      def []=(name, command)
+        delete name
+        @entries << [name, command]
+      end
+
+      # Remove a +Procfile+ entry
+      #
+      # @param [String] name  The name of the +Procfile+ entry to remove
+      #
+      def delete(name)
+        @entries.reject! { |n,c| name == n }
+      end
+
+      # Load a Procfile from a file
+      #
+      # @param [String] filename  The filename of the +Procfile+ to load
+      #
+      def load(filename)
+        @entries.replace parse(filename)
+      end
+
+      # Save a Procfile to a file
+      #
+      # @param [String] filename  Save the +Procfile+ to this file
+      #
+      def save(filename)
+        File.open(filename, 'w') do |file|
+          file.puts self.to_s
+        end
+      end
+
+      # Get the +Procfile+ as a +String+
+      #
+      def to_s
+        @entries.map do |name, command|
+          [ name, command ].join(": ")
+        end.join("\n")
+      end
+
+      private
+
+      def parse(filename)
+        File.read(filename).gsub("\r\n","\n").split("\n").map do |line|
+          if line =~ /^([A-Za-z0-9_-]+):\s*(.+)$/
+            [$1, $2]
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/invoker/power/balancer.rb

@@ -0,0 +1,133 @@
+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(private_key_file: Invoker.private_key, cert_chain_file: Invoker.certificate)
+      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()
+        headers = headers.transform_keys(&:downcase)
+
+        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
+        # - Upgrade: 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.exist?(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