eksa-server 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20f80700434c2365febde215212050d0d859be1d8b67a2225506545b1ec84ded
-  data.tar.gz: 0fbf23b72be466483c7cb579f11cf1f4c427d09a361df3199acf67567f3d64ae
+  metadata.gz: 72911bfe3a28c5d0e812c9dbbb7f993f4f09e409a4dc872999d059ac089fcba7
+  data.tar.gz: 4964e10492c37334d6729bbd38ce1a91b5c48ab1c2fef75ce5667a14c0a1e58f
 SHA512:
-  metadata.gz: fa73c08ba2d35178db74d35e747906e0a9cabe1f8f0019ba3d516c6f71039798cfdd178a7d540b912f66616564f54e081f4f2ce9873c0cd4fb362f87c8a5ceab
-  data.tar.gz: 6ba5333277149c9cf839368b244632759417315e9a050f5ca60f39567373d179f4c2d0c80b6ee5e083d8121206e7254b917179db19402af2ea16c080912e4e6f
+  metadata.gz: 6b2812653f57e1454481229021fb2ec846d2bc1e1591d60a4442811647a8ad04adb5e9d17ddd59913cedcd1291348e5d77eb9105bfc0083371e6a756b786e0de
+  data.tar.gz: f01bf24108df7967bf8b8fcc28633c2811c705e596674266d6ac956839a3681eae8bfe6df4ee085e958867504fb6f788bc985d1b544432d22457e6cf04634adc

data/README.md

@@ -1,32 +1,27 @@
 # EksaServer
 
-**EksaServer** adalah server web Ruby asinkron berperforma tinggi. Dibangun di atas `nio4r`, server ini dirancang untuk menangani ribuan koneksi secara efisien dengan dukungan multithreading dan multiprocess (cluster mode).
+**EksaServer** adalah server web Ruby asinkron berperforma tinggi yang dirancang untuk keandalan dan kecepatan. Dibangun di atas `nio4r`, server ini mampu menangani ribuan koneksi secara efisien melalui model multithreading dan multiprocess (cluster mode).
 
 ## Fitur Utama
 
-- 🚀 **Performa Tinggi**: Menggunakan `nio4r` untuk event loop non-blocking.
-- 🧵 **Multithreading Dinamis**: Thread pool yang menskalakan secara otomatis sesuai beban.
-- 🏗️ **Cluster Mode**: Memanfaatkan multi-core CPU dengan worker process.
-- 🔄 **Phased Restarts**: Update kode aplikasi tanpa downtime (Zero Downtime).
-- 🛠️ **Konfigurasi DSL**: Pengaturan mudah melalui file `server.rb`.
-- 🔌 **Rack Compliant**: Mendukung semua framework Ruby berbasis Rack (Rails, Sinatra, EksaFramework, dll).
-- 🛡️ **Premium Error Page**: Halaman error *glassmorphism* yang elegan.
+- 🚀 **Performa Tinggi**: Event loop non-blocking berbasis `nio4r`.
+- 🧵 **Auto-Scaling Threads**: Thread pool yang menyesuaikan diri dengan beban request.
+- 🏗️ **Cluster Mode**: Worker process mandiri untuk memanfaatkan multi-core CPU.
+- 🔐 **SSL/HTTPS Native**: Dukungan enkripsi SSL yang mudah via CLI atau config.
+- 🔄 **Auto-Reload**: Pemuatan ulang otomatis saat ada perubahan kode (`--reload`).
+- 📊 **Control Server**: API statistik real-time (memory, workers, threads).
+- 🛠️ **Fleksibilitas Konfigurasi**: Mendukung DSL Ruby, variabel lingkungan (`.env`), dan opsi CLI.
+- 🛡️ **Premium Error Page**: Tampilan error *glassmorphism* yang elegan dan informatif.
 
 ## Instalasi
 
-Tambahkan baris ini ke Gemfile aplikasi Anda:
+Tambahkan ke Gemfile Anda:
 
 ```ruby
 gem 'eksa-server'
 ```
 
-Lalu jalankan:
-
-```bash
-bundle install
-```
-
-Atau instal langsung melalui terminal:
+Atau instal langsung:
 
 ```bash
 gem install eksa-server
@@ -34,37 +29,65 @@ gem install eksa-server
 
 ## Penggunaan Cepat
 
-Cukup jalankan perintah berikut di direktori proyek Anda yang memiliki file `config.ru`:
+Jalankan di direktori aplikasi Rack Anda:
 
 ```bash
 eksa-server
 ```
 
-Anda juga bisa menentukan file rack secara spesifik:
-
+### Opsi CLI yang Berguna
+
+| Opsi | Deskripsi |
+|------|-----------|
+| `-p, --port` | Port server (default: 3000 atau dari `.env`) |
+| `-o, --host` | Host untuk bind (default: 0.0.0.0) |
+| `-b, --bind URL` | Tambahkan bind (tcp://host:port atau unix://path). Bisa dipanggil berkali-kali. |
+| `-R, --reload` | Aktifkan auto-reload saat file `.rb` berubah |
+| `-c, --control` | Port untuk Control Server (statistik) |
+| `-D, --daemonize` | Berjalan di latar belakang (Daemon Mode) |
+| `-L, --log PATH` | Simpan log ke file tertentu |
+| `--ssl-cert PATH` | Path ke sertifikat SSL (.crt) |
+| `--ssl-key PATH` | Path ke private key SSL (.key) |
+
+Contoh penggunaan lengkap:
 ```bash
-eksa-server app/config.ru -p 4000
+eksa-server config.ru -p 443 --ssl-cert server.crt --ssl-key server.key -w 4 -R
 ```
 
 ## Konfigurasi
 
-Buat file `config/eksa_server.rb` untuk pengaturan tingkat lanjut:
+EksaServer otomatis memuat file `.env` jika tersedia. Anda juga bisa menggunakan file `config/eksa_server.rb`:
 
 ```ruby
+# config/eksa_server.rb
 threads 5, 20      # Min, Max threads
-workers 2          # Aktifkan Cluster Mode
-bind "tcp://0.0.0.0:3000"
-# bind "unix:///tmp/eksa.sock"
+workers 2          # Jumlah worker
+control_port 3001  # API Statistik
+
+# SSL (Opsional)
+ssl true
+cert "path/to/cert.crt"
+key "path/to/key.key"
 
 on_worker_boot do |index|
-  puts "Worker #{index} siap melayani!"
+  puts "Worker #{index} siap beraksi!"
 end
 ```
 
-## Dokumentasi Lengkap
+## Statistik (Control Server)
 
-Untuk melihat panduan lengkap dan fitur interaktif, silakan kunjungi repositori resmi di GitHub atau jalankan secara lokal dari source code:
-[https://github.com/IshikawaUta/eksa-server](https://github.com/IshikawaUta/eksa-server)
+Jika Control Server aktif, Anda bisa memantau kesehatan server via JSON:
+`curl http://localhost:3001`
+
+```json
+{
+  "workers": 2,
+  "uptime": 3600,
+  "version": "1.1.0",
+  "memory_kb": 45120,
+  "threads": { "spawned": 10, "waiting": 8 }
+}
+```
 
 ## Lisensi
 

data/bin/eksa-server

@@ -9,7 +9,21 @@ OptionParser.new do |opts|
   opts.banner = "Usage: eksa-server [options] [config.ru]"
 
   opts.on("-p", "--port PORT", "Port to bind to (default: 3000)") { |v| options[:port] = v.to_i }
+  opts.on("-o", "--host HOST", "Host to bind to (default: 0.0.0.0)") { |v| options[:host] = v }
+  opts.on("-b", "--bind URL", "Bind URL (tcp://host:port or unix://path)") do |v| 
+    options[:binds] ||= []
+    options[:binds] << v
+  end
   opts.on("-w", "--workers COUNT", "Number of worker processes") { |v| options[:workers] = v.to_i }
+  opts.on("-t", "--timeout SECONDS", "Worker timeout in seconds") { |v| options[:timeout] = v.to_i }
+  opts.on("-c", "--control PORT", "Control server port (0 for random, false to disable)") do |v| 
+    options[:control_port] = (v == "false" ? false : v.to_i)
+  end
+  opts.on("-L", "--log PATH", "Path to log file") { |v| options[:log_file] = v }
+  opts.on("-D", "--daemonize", "Run in background") { options[:daemonize] = true }
+  opts.on("-R", "--reload", "Auto-reload on file changes") { options[:reload] = true }
+  opts.on("--ssl-cert PATH", "Path to SSL certificate") { |v| options[:cert] = v; options[:ssl] = true }
+  opts.on("--ssl-key PATH", "Path to SSL private key") { |v| options[:key] = v; options[:ssl] = true }
   opts.on("-C", "--config PATH", "Path to config file") { |v| options[:config_file] = v }
 end.parse!
 

data/lib/eksa_server/configuration.rb

@@ -6,21 +6,37 @@ module EksaServer
     attr_reader :options
 
     def initialize(user_options = {})
+      load_env
       @options = default_options.merge(user_options)
     end
 
+    def load_env(path = '.env')
+      return unless File.exist?(path)
+      File.readlines(path).each do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+        key, value = line.split('=', 2)
+        next unless key && value
+        ENV[key] ||= value.gsub(/^["']|["']$/, '') # Bersihkan quote jika ada
+      end
+    end
+
     def load_config(path)
       return unless File.exist?(path)
       dsl = DSL.new(@options)
       dsl.instance_eval(File.read(path), path)
     end
 
+    def merge!(new_options)
+      @options.merge!(new_options)
+    end
+
     private
 
     def default_options
       {
-        host: '0.0.0.0',
-        port: 3000,
+        host: ENV['HOST'] || '0.0.0.0',
+        port: (ENV['PORT'] || 3000).to_i,
         min_threads: 5,
         max_threads: 16,
         workers: 0,

data/lib/eksa_server/events.rb

@@ -29,6 +29,11 @@ module EksaServer
       @stdout.puts msg
     end
 
+    def reopen(io)
+      @stdout = io
+      @logger = setup_logger
+    end
+
     private
 
     def setup_logger

data/lib/eksa_server/http.rb

@@ -0,0 +1,66 @@
+# lib/eksa_server/http.rb
+require 'stringio'
+
+module EksaServer
+  class Request
+    attr_reader :env
+
+    def initialize(client, options = {})
+      @client = client
+      @options = options
+      @env = parse_request
+    end
+
+    private
+
+    def parse_request
+      lines = []
+      while (line = @client.gets) && line != "\r\n"
+        lines << line.chomp
+      end
+      return nil if lines.empty?
+
+      method, path, _version = lines.first.split(" ")
+      headers = lines[1..-1].each_with_object({}) do |line, h|
+        k, v = line.split(": ", 2)
+        h[k] = v
+      end
+
+      env = {
+        'REQUEST_METHOD'    => method,
+        'SCRIPT_NAME'       => '',
+        'PATH_INFO'         => path.split("?", 2)[0],
+        'QUERY_STRING'      => path.split("?", 2)[1] || "",
+        'SERVER_NAME'       => @options[:host],
+        'SERVER_PORT'       => @options[:port].to_s,
+        'rack.version'      => Rack::VERSION,
+        'rack.url_scheme'   => @options[:ssl] ? 'https' : 'http',
+        'rack.input'        => StringIO.new(""),
+        'rack.errors'       => $stderr,
+        'rack.multithread'  => true,
+        'rack.multiprocess' => @options[:workers] > 0,
+        'rack.run_once'     => false
+      }
+
+      headers.each { |k, v| env["HTTP_#{k.upcase.gsub('-', '_')}"] = v }
+      env
+    end
+  end
+
+  class Response
+    def self.send_response(client, status, headers, body)
+      response = "HTTP/1.1 #{status} OK\r\n"
+      headers.each { |k, v| response << "#{k}: #{v}\r\n" }
+      
+      full_body = ""
+      body = [body] unless body.respond_to?(:each)
+      body.each { |chunk| full_body << chunk }
+      body.close if body.respond_to?(:close)
+
+      response << "Content-Length: #{full_body.bytesize}\r\n\r\n"
+      response << full_body
+
+      client.write(response)
+    end
+  end
+end

data/lib/eksa_server/thread_pool.rb

@@ -33,18 +33,20 @@ module EksaServer
     private
 
     def spawn_thread
-      @spawned += 1
-      thread = Thread.new do
-        loop do
-          @mutex.synchronize { @waiting += 1 }
-          work = @todo.pop
-          @mutex.synchronize { @waiting -= 1 }
-          break if work == :exit
-          @block.call(work) rescue nil
+      @mutex.synchronize do
+        @spawned += 1
+        thread = Thread.new do
+          loop do
+            @mutex.synchronize { @waiting += 1 }
+            work = @todo.pop
+            @mutex.synchronize { @waiting -= 1 }
+            break if work == :exit
+            @block.call(work) rescue nil
+          end
+          @mutex.synchronize { @spawned -= 1 }
         end
-        @mutex.synchronize { @spawned -= 1 }
+        @pool << thread
       end
-      @pool << thread
     end
   end
 end

data/lib/eksa_server/version.rb

@@ -1,4 +1,4 @@
 # lib/eksa_server/version.rb
 module EksaServer
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/server.rb

@@ -5,6 +5,7 @@ require 'thread'
 require 'json'
 require 'fileutils'
 require 'openssl'
+require 'stringio'
 require 'rack'
 require 'rackup'
 
@@ -13,17 +14,42 @@ require_relative 'lib/eksa_server/events'
 require_relative 'lib/eksa_server/binder'
 require_relative 'lib/eksa_server/thread_pool'
 require_relative 'lib/eksa_server/configuration'
+require_relative 'lib/eksa_server/http'
+require_relative 'lib/eksa_server/version'
 
 class EksaServerCore
-  def initialize(app, config = {})
-    @app_path_or_obj = app
-    @config = EksaServer::Configuration.new(config)
+  def initialize(app, user_options = {})
+    @app_path_or_obj = app.is_a?(String) ? File.expand_path(app) : app
+    @config = EksaServer::Configuration.new
+    @signal_queue = []
+    @project_root = Dir.pwd
     
-    # Load optional config file
+    # 1. Load optional config file (priority paling rendah)
     if File.exist?('config/eksa_server.rb')
       @config.load_config('config/eksa_server.rb')
     end
 
+    # 2. Muat .env (menimpa config file jika ada variabelnya)
+    @config.load_env
+
+    # 3. Gabungkan user_options dari CLI (priority paling tinggi)
+    # Jika user memberikan port/host secara eksplisit di CLI atau ada di ENV,
+    # kita prioritaskan itu dan kosongkan binds agar tidak tumpang tindih.
+    cli_port = user_options[:port] || user_options[:host]
+    if cli_port || ENV['PORT'] || ENV['HOST']
+      @config.options[:binds] = []
+      @config.options[:port] = (user_options[:port] || ENV['PORT'] || @config.options[:port]).to_i
+      @config.options[:host] = user_options[:host] || ENV['HOST'] || @config.options[:host]
+    end
+    @config.merge!(user_options.compact)
+    
+    # Expand paths to absolute versions before load_app changes Dir.chdir
+    [:cert, :key, :log_file].each do |opt|
+      if @config.options[opt] && @config.options[opt].is_a?(String)
+        @config.options[opt] = File.expand_path(@config.options[opt])
+      end
+    end
+
     @options = @config.options
     @events = EksaServer::Events.new($stdout, $stderr)
     @binder = EksaServer::Binder.new(@events)
@@ -36,6 +62,19 @@ class EksaServerCore
   end
 
   def start
+    if @options[:daemonize]
+      @events.info "Berjalan di latar belakang (Daemon Mode)..."
+      Process.daemon(true, true)
+    end
+
+    if @options[:log_file]
+      log_file = File.open(@options[:log_file], 'a')
+      log_file.sync = true
+      @events.reopen(log_file)
+    end
+
+    start_reloader if @options[:reload]
+
     print_banner
     
     # Bina Sockets (Binder)
@@ -86,13 +125,20 @@ class EksaServerCore
     @options[:workers].times { |i| spawn_worker(i) }
     @events.info "Cluster aktif dengan #{@options[:workers]} worker. 🚀"
 
-    trap('INT') { terminate_all }
-    trap('TERM') { terminate_all }
-    trap('USR2') { phased_restart }
+    trap('INT') { @signal_queue << :TERM }
+    trap('TERM') { @signal_queue << :TERM }
+    trap('USR2') { @signal_queue << :USR2 }
 
     loop do
+      case @signal_queue.shift
+      when :TERM
+        terminate_all
+      when :USR2
+        phased_restart
+      end
+
       check_workers
-      sleep 2
+      sleep 1
     end
   end
 
@@ -120,6 +166,7 @@ class EksaServerCore
 
   def phased_restart
     @events.info "\e[35mMemulai Phased Restart...\e[0m"
+    @app = load_app(@app_path_or_obj)
     @worker_pids.each do |index, pid|
       Process.kill('TERM', pid)
       Process.wait(pid)
@@ -146,19 +193,42 @@ class EksaServerCore
       @selector.register(io, :r).value = :accept
     end
 
+    # Signal handling untuk single-worker mode
+    if @options[:workers] == 0
+      trap('INT') { @signal_queue << :TERM }
+      trap('TERM') { @signal_queue << :TERM }
+    end
+
     Thread.new do
       loop do
-        FileUtils.touch("#{@hb_dir}/#{Process.pid}.hb")
+        begin
+          if File.directory?(@hb_dir)
+            FileUtils.touch("#{@hb_dir}/#{Process.pid}.hb")
+          end
+        rescue
+          # Abaikan error saat shutdown
+        end
         sleep 5
       end
     end
 
     loop do
-      @selector.select(5) do |monitor|
+      if @signal_queue.include?(:TERM)
+        @events.info "Worker #{id} berhenti..."
+        break
+      end
+
+      @selector.select(1) do |monitor|
         if monitor.value == :accept
           begin
-            client = monitor.io.accept_nonblock
+            if monitor.io.respond_to?(:accept_nonblock)
+              client = monitor.io.accept_nonblock
+            else
+              client = monitor.io.accept
+            end
             @selector.register(client, :r).value = :read
+          rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET => e
+            @events.warn "Gagal jabat tangan SSL/Koneksi terputus: #{e.message}"
           rescue IO::WaitReadable
           end
         else
@@ -175,36 +245,9 @@ class EksaServerCore
   end
 
   def process_client(client)
-    # Baca request line & headers
-    lines = []
-    while (line = client.gets) && line != "\r\n"
-      lines << line.chomp
-    end
-    return client.close if lines.empty?
-
-    method, path, _version = lines.first.split(" ")
-    headers = lines[1..-1].each_with_object({}) do |line, h|
-      k, v = line.split(": ", 2)
-      h[k] = v
-    end
-
-    env = {
-      'REQUEST_METHOD'    => method,
-      'SCRIPT_NAME'       => '',
-      'PATH_INFO'         => path.split("?", 2)[0],
-      'QUERY_STRING'      => path.split("?", 2)[1] || "",
-      'SERVER_NAME'       => @options[:host],
-      'SERVER_PORT'       => @options[:port].to_s,
-      'rack.version'      => Rack::VERSION,
-      'rack.url_scheme'   => @options[:ssl] ? 'https' : 'http',
-      'rack.input'        => StringIO.new(""),
-      'rack.errors'       => $stderr,
-      'rack.multithread'  => true,
-      'rack.multiprocess' => @options[:workers] > 0,
-      'rack.run_once'     => false
-    }
-
-    headers.each { |k, v| env["HTTP_#{k.upcase.gsub('-', '_')}"] = v }
+    request = EksaServer::Request.new(client, @options)
+    env = request.env
+    return client.close unless env
 
     # Panggil aplikasi Rack
     begin
@@ -216,20 +259,10 @@ class EksaServerCore
       res_body = [render_error_page(e)]
     end
     
-    # Send Response
-    response = "HTTP/1.1 #{status} OK\r\n"
-    res_headers.each { |k, v| response << "#{k}: #{v}\r\n" }
+    # Kirim Response
+    EksaServer::Response.send_response(client, status, res_headers, res_body)
     
-    full_body = ""
-    res_body = [res_body] unless res_body.respond_to?(:each)
-    res_body.each { |chunk| full_body << chunk }
-    res_body.close if res_body.respond_to?(:close)
-
-    response << "Content-Length: #{full_body.bytesize}\r\n\r\n"
-    response << full_body
-
-    client.write(response)
-    @events.info "Selesai: #{method} #{path} -> #{status} (Threads: #{@thread_pool.spawned})"
+    @events.info "Selesai: #{env['REQUEST_METHOD']} #{env['PATH_INFO']} -> #{status} (Threads: #{@thread_pool.spawned})"
     client.close
   rescue => e
     @events.error "Kesalahan tingkat rendah: #{e.message}"
@@ -248,20 +281,66 @@ class EksaServerCore
     end
   end
 
+  def start_reloader
+    @events.info "Pemuatan otomatis (Auto-Reload) aktif. 👀"
+    Thread.new do
+      # Pantau file di project root agar mencakup lib dan server.rb
+      loop do
+        sleep 2
+        changed = false
+        files = Dir.chdir(@project_root) { Dir["**/*.{rb,ru}"] }
+        
+        @mtimes ||= {}
+        files.each do |f|
+          full_path = File.join(@project_root, f)
+          current_mtime = File.mtime(full_path) rescue next
+          if @mtimes[f] && @mtimes[f] != current_mtime
+            @events.warn "Perubahan terdeteksi di #{f}. Me-restart..."
+            changed = true
+          end
+          @mtimes[f] = current_mtime
+        end
+
+        if changed
+          if @options[:workers] > 0
+            @signal_queue << :USR2
+          else
+            @signal_queue << :TERM
+          end
+        end
+      end
+    end
+  end
+
   def start_control_server
+    return if @options[:control_port] == false || @options[:control_port] == nil
     start_time = Time.now
     Thread.new do
       begin
+        # Jika port 0, OS akan memilih port acak
         server = TCPServer.new('127.0.0.1', @options[:control_port])
+        actual_port = server.addr[1]
+        @events.info "Control Server aktif di http://localhost:#{actual_port}" if @options[:control_port] == 0
+        
         loop do
           client = server.accept
           uptime = (Time.now - start_time).to_i
-          stats = { workers: @worker_pids.size, uptime: uptime }.to_json
+          
+          # Hitung memori (RSS) di Linux
+          mem = `ps -o rss= -p #{Process.pid}`.strip.to_i rescue 0
+          
+          stats = { 
+            workers: @worker_pids.size, 
+            uptime: uptime,
+            version: EksaServer::VERSION,
+            memory_kb: mem,
+            threads: { spawned: @thread_pool&.spawned, waiting: @thread_pool&.waiting }
+          }.to_json
           client.puts "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n#{stats}"
           client.close
         end
       rescue => e
-        @events.error "Control Server Gagal: #{e.message}"
+        @events.error "Control Server Gagal di port #{@options[:control_port]}: #{e.message}"
       end
     end
   end
@@ -273,7 +352,7 @@ class EksaServerCore
 
   def print_banner
     puts "\e[34m"
-    puts "  \e[1mEKSA SERVER v2 \e[0m- \e[90mBy: IshikawaUta\e[0m"
+    puts "  \e[1mEKSA SERVER v#{EksaServer::VERSION} \e[0m- \e[90mBy: IshikawaUta\e[0m"
     puts "\e[34m"
     puts "  ╔═╗╦╔═╔═╗╔═╗  ╔═╗╔═╗╦═╗╦   ╦╔═╗╦═╗"
     puts "  ║╣ ╠╩╗╚═╗╠═╣  ╚═╗║╣ ╠╦╝╚╗ ╔╝║╣ ╠╦╝"
@@ -285,7 +364,9 @@ class EksaServerCore
   def print_server_info
     puts "\n  \e[1mKONFIGURASI SERVER:\e[0m"
     @binder.listeners.each do |io, type|
-       puts "  \e[36m•\e[0m Bind [#{type.upcase}]: \e[33m#{io.local_address.inspect_sockaddr}\e[0m"
+       # SSLServer tidak punya local_address langsung, panggil to_io
+       sock = io.respond_to?(:local_address) ? io : io.to_io
+       puts "  \e[36m•\e[0m Bind [#{type.upcase}]: \e[33m#{sock.local_address.inspect_sockaddr}\e[0m"
     end
     puts "  \e[36m•\e[0m Threads: \e[33m#{@options[:min_threads]}..#{@options[:max_threads]}\e[0m"
     puts "  \e[36m•\e[0m Workers: \e[33m#{@options[:workers]} (#{@options[:workers] > 0 ? 'Cluster' : 'Single'} Mode)\e[0m"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eksa-server
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - IshikawaUta
@@ -51,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 description: A modular, concurrent web server built with nio4r.
 email:
 - komikers09@gmail.com
@@ -69,6 +83,7 @@ files:
 - lib/eksa_server/dsl.rb
 - lib/eksa_server/error.html
 - lib/eksa_server/events.rb
+- lib/eksa_server/http.rb
 - lib/eksa_server/thread_pool.rb
 - lib/eksa_server/version.rb
 - server.rb