tipi 0.42 → 0.47

data/examples/https_server.rb

@@ -10,27 +10,50 @@ authority = Localhost::Authority.fetch
 opts = {
   reuse_addr:     true,
   dont_linger:    true,
-  secure_context: authority.server_context
 }
 
 puts "pid: #{Process.pid}"
 puts 'Listening on port 1234...'
-Tipi.serve('0.0.0.0', 1234, opts) do |req|
-  p path: req.path
-  if req.path == '/stream'
-    req.send_headers('Foo' => 'Bar')
-    sleep 0.5
-    req.send_chunk("foo\n")
-    sleep 0.5
-    req.send_chunk("bar\n", done: true)
-  elsif req.path == '/upload'
-    body = req.read
-    req.respond("Body: #{body.inspect} (#{body.bytesize} bytes)")
-  else
-    req.respond("Hello world!\n")
+
+ctx = authority.server_context
+server = Polyphony::Net.tcp_listen('0.0.0.0', 1234, opts)
+loop do
+  socket = server.accept
+  client = OpenSSL::SSL::SSLSocket.new(socket, ctx)
+  client.sync_close = true
+  spin do
+    state = {}
+    accept_thread = Thread.new do
+      puts "call client accept"
+      client.accept
+      state[:result] = :ok
+    rescue Exception => e
+      puts error: e
+      state[:result] = e
+    end
+    "wait for accept thread"
+    accept_thread.join
+    "accept thread done"
+    if state[:result].is_a?(Exception)
+      puts "Exception in SSL handshake: #{state[:result].inspect}"
+      next
+    end
+    Tipi.client_loop(client, opts) do |req|
+      p path: req.path
+      if req.path == '/stream'
+        req.send_headers('Foo' => 'Bar')
+        sleep 0.5
+        req.send_chunk("foo\n")
+        sleep 0.5
+        req.send_chunk("bar\n", done: true)
+      elsif req.path == '/upload'
+        body = req.read
+        req.respond("Body: #{body.inspect} (#{body.bytesize} bytes)")
+      else
+        req.respond("Hello world!\n")
+      end
+    end
+  ensure
+    client ? client.close : socket.close
   end
-  # req.send_headers
-  # req.send_chunk("Method: #{req.method}\n")
-  # req.send_chunk("Path: #{req.path}\n")
-  # req.send_chunk("Query: #{req.query.inspect}\n", done: true)
 end

data/examples/rack_server_forked.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'tipi'
+
+app_path = ARGV.first || File.expand_path('./config.ru', __dir__)
+unless File.file?(app_path)
+  STDERR.puts "Please provide rack config file (there are some in the examples directory.)"
+  exit!
+end
+
+app = Tipi::RackAdapter.load(app_path)
+opts = { reuse_addr: true, dont_linger: true }
+
+server = Tipi.listen('0.0.0.0', 1234, opts)
+puts 'listening on port 1234'
+
+child_pids = []
+4.times do
+  child_pids << Polyphony.fork do
+    puts "forked pid: #{Process.pid}"
+    server.each(&app)
+  end
+end
+
+child_pids.each { |pid| Thread.current.backend.waitpid(pid) }

data/examples/rack_server_https_forked.rb

@@ -25,4 +25,4 @@ child_pids = []
   end
 end
 
-child_pids.each { |pid| Thread.current.backend.waitpid(pid) }
+child_pids.each { |pid| Thread.current.backend.waitpid(pid) }

data/examples/websocket_demo.rb

@@ -26,7 +26,7 @@ class WebsocketClient
   def receive
     parsed = @reader.next
     return parsed if parsed
-    
+
     @socket.read_loop do |data|
       @reader << data
       parsed = @reader.next

data/lib/tipi/acme.rb

@@ -10,10 +10,11 @@ module Tipi
     end
 
     class CertificateManager
-      def initialize(master_ctx:, store:, challenge_handler:)
+      def initialize(master_ctx:, store:, challenge_handler:, valid_hosts:)
         @master_ctx = master_ctx
         @store = store
         @challenge_handler = challenge_handler
+        @valid_hosts = valid_hosts
         @contexts = {}
         @requests = Polyphony::Queue.new
         @worker = spin { run }
@@ -35,32 +36,45 @@ module Tipi
       IP_REGEXP = /^\d+\.\d+\.\d+\.\d+$/
 
       def setup_sni_callback
-        @master_ctx.servername_cb = proc do |_socket, name|
-          p servername_cb: name
-          state = { ctx: nil }
-
-          if name =~ IP_REGEXP
-            @master_ctx
-          else
-            @requests << [name, state]
-            wait_for_ctx(state)
-            p name: name, error: state if state[:error]
-            # Eventually we might want to return an error returned in
-            # state[:error]. For the time being we handle errors by returning the
-            # master context
-            state[:ctx] || @master_ctx
-          end
+        @master_ctx.servername_cb = proc { |_socket, name| get_ctx(name) }
+      end
+
+      def get_ctx(name)
+        state = { ctx: nil }
+
+        if @valid_hosts
+          return nil unless @valid_hosts.include?(name)
         end
+
+        ready_ctx = @contexts[name]
+        return ready_ctx if ready_ctx
+        return @master_ctx if name =~ IP_REGEXP
+
+        @requests << [name, state]
+        wait_for_ctx(state)
+        # Eventually we might want to return an error returned in
+        # state[:error]. For the time being we handle errors by returning the
+        # master context
+        state[:ctx] || @master_ctx
+      rescue => e
+        @master_ctx
       end
-    
+
+      MAX_WAIT_FOR_CTX_DURATION = 30
+
       def wait_for_ctx(state)
+        t0 = Time.now
         period = 0.00001
         while !state[:ctx] && !state[:error]
           orig_sleep period
-          period *= 2 if period < 0.1
+          if period < 0.1
+            period *= 2
+          elsif Time.now - t0 > MAX_WAIT_FOR_CTX_DURATION
+            raise "Timeout waiting for certificate provisioning"
+          end
         end
       end
-      
+
       def run
         loop do
           name, state = @requests.shift
@@ -69,13 +83,13 @@ module Tipi
           state[:error] = e if state
         end
       end
-    
+
       LOCALHOST_REGEXP = /\.?localhost$/.freeze
 
       def get_context(name)
         @contexts[name] = setup_context(name)
       end
-    
+
       def setup_context(name)
         ctx = provision_context(name)
         transfer_ctx_settings(ctx)
@@ -100,7 +114,7 @@ module Tipi
       end
 
       CERTIFICATE_REGEXP = /(-----BEGIN CERTIFICATE-----\n[^-]+-----END CERTIFICATE-----\n)/.freeze
-    
+
       def parse_certificate(certificate)
         certificate
           .scan(CERTIFICATE_REGEXP)
@@ -126,17 +140,17 @@ module Tipi
         @localhost_authority ||= Localhost::Authority.fetch
         @localhost_authority.server_context
       end
-    
+
       def private_key
         @private_key ||= OpenSSL::PKey::RSA.new(4096)
       end
-    
+
       ACME_DIRECTORY = 'https://acme-v02.api.letsencrypt.org/directory'
-    
+
       def acme_client
         @acme_client ||= setup_acme_client
       end
-    
+
       def setup_acme_client
         client = Acme::Client.new(
           private_key: private_key,
@@ -148,13 +162,12 @@ module Tipi
         )
         client
       end
-    
+
       def provision_certificate(name)
-        p provision_certificate: name
         order = acme_client.new_order(identifiers: [name])
         authorization = order.authorizations.first
         challenge = authorization.http
-      
+
         @challenge_handler.add(challenge)
         challenge.request_validation
         while challenge.status == 'pending'
@@ -162,8 +175,7 @@ module Tipi
           challenge.reload
         end
         raise ACME::Error, "Invalid CSR" if challenge.status == 'invalid'
-      
-        p challenge_status: challenge.status
+
         private_key = OpenSSL::PKey::RSA.new(4096)
         csr = Acme::Client::CertificateRequest.new(
           private_key: private_key,
@@ -189,33 +201,33 @@ module Tipi
         }
       end
     end
-  
+
     class HTTPChallengeHandler
       def initialize
         @challenges = {}
       end
-    
+
       def add(challenge)
         path = "/.well-known/acme-challenge/#{challenge.token}"
         @challenges[path] = challenge
       end
-    
+
       def remove(challenge)
         path = "/.well-known/acme-challenge/#{challenge.token}"
         @challenges.delete(path)
       end
-    
+
       def call(req)
         challenge = @challenges[req.path]
-    
+
         # handle incoming request
         challenge = @challenges[req.path]
         return req.respond(nil, ':status' => 400) unless challenge
-    
+
         req.respond(challenge.file_content, 'content-type' => challenge.content_type)
       end
-    end    
-  
+    end
+
     class CertificateStore
       def set(name, private_key:, certificate:, expired_stamp:)
         raise NotImplementedError

data/lib/tipi/cli.rb

@@ -2,29 +2,92 @@
 
 require 'tipi'
 require 'fileutils'
+require 'tipi/supervisor'
+require 'optparse'
 
 module Tipi
+  DEFAULT_OPTS = {
+    app_type: :web,
+    mode: :polyphony,
+    workers: 1,
+    threads: 1,
+    listen: ['http', 'localhost', 1234],
+    path: '.',
+  }
+
+  def self.opts_from_argv(argv)
+    opts = DEFAULT_OPTS.dup
+    parser = OptionParser.new do |o|
+      o.banner = "Usage: tipi [options] path"
+      o.on('-h', '--help', 'Show this help') { puts o; exit }
+      o.on('-wNUM', '--workers NUM', 'Number of worker processes (default: 1)') do |v|
+        opts[:workers] = v
+      end
+      o.on('-tNUM', '--threads NUM', 'Number of worker threads (default: 1)') do |v|
+        opts[:threads] = v
+        opts[:mode] = :stock
+      end
+      o.on('-c', '--compatibility', 'Use compatibility mode') do
+        opts[:mode] = :stock
+      end
+      o.on('-lSPEC', '--listen SPEC', 'Setup HTTP listener') do |v|
+        opts[:listen] = parse_listen_spec('http', v)
+      end
+      o.on('-sSPEC', '--secure SPEC', 'Setup HTTPS listener (for localhost)') do |v|
+        opts[:listen] = parse_listen_spec('https', v)
+      end
+      o.on('-fSPEC', '--full-service SPEC', 'Setup HTTP/HTTPS listeners (with automatic certificates)') do |v|
+        opts[:listen] = parse_listen_spec('full', v)
+      end
+      o.on('-v', '--verbose', 'Verbose output') do
+        opts[:verbose] = true
+      end
+    end.parse!(argv)
+    opts[:path] = argv.shift unless argv.empty?
+    verify_path(opts[:path])
+    opts
+  end
+
+  def self.parse_listen_spec(type, spec)
+    [type, *spec.split(':').map { |s| str_to_native_type(s) }]
+  end
+
+  def self.str_to_native_type(str)
+    case str
+    when /^\d+$/
+      str.to_i
+    else
+      str
+    end
+  end
+
+  def self.verify_path(path)
+    return if File.file?(path) || File.directory?(path)
+
+    puts "Invalid path specified #{opts[:path]}"
+    exit!
+  end
+
   module CLI
-    BANNER = "
-         ooo
-       oo
-     o
-   \\|/    Tipi - a better web server for a better world
-   / \\       
-  /   \\      https://github.com/digital-fabric/tipi
-⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺
-"
-
-    def self.start
-      display_banner
-      require File.expand_path(ARGV[0] || 'app.rb', FileUtils.pwd)
+    BANNER =
+      "\n" +
+      "         ooo\n" +
+      "       oo\n" +
+      "     o\n" +
+      "   \\|/    Tipi - a better web server for a better world\n" +
+      "   / \\       \n" +
+      "  /   \\      https://github.com/digital-fabric/tipi\n" +
+      "⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺\n"
+
+    def self.start(argv = ARGV.dup)
+      opts = Tipi.opts_from_argv(argv)
+      display_banner if STDOUT.tty? && !opts[:silent]
+
+      Tipi::Supervisor.run(opts)
     end
 
     def self.display_banner
       puts BANNER
-      puts
     end
   end
 end
-
-__END__

data/lib/tipi/config_dsl.rb

@@ -4,28 +4,28 @@ module Tipi
   module Configuration
     class Interpreter
       # make_blank_slate
-      
+
       def initialize(assembler)
         @assembler = assembler
       end
-      
+
       def gzip_response
         @assembler.emit 'req = Tipi::GZip.wrap(req)'
       end
-      
+
       def log(out)
         @assembler.wrap_current_frame 'logger.log_request(req) do |req|'
       end
-        
+
       def error(&block)
         assembler.emit_exception_handler &block
       end
-        
+
       def match(pattern, &block)
         @assembler.emit_conditional "if req.path =~ #{pattern.inspect}", &block
       end
     end
-      
+
     class Assembler
       def self.from_source(code)
         new.from_source code
@@ -36,7 +36,7 @@ module Tipi
         @app_procs = {}
         @interpreter = Interpreter.new self
         @interpreter.instance_eval code
-        
+
         loop do
           frame = @stack.pop
           return assemble_app_proc(frame).join("\n") if @stack.empty?
@@ -51,7 +51,7 @@ module Tipi
           body: []
         }
       end
-        
+
       def add_frame(&block)
         @stack.push new_frame
         yield
@@ -67,20 +67,20 @@ module Tipi
         @stack.push wrapper
         @stack.push frame
       end
-        
+
       def emit(code)
         @stack.last[:body] << code
       end
-      
+
       def emit_prelude(code)
         @stack.last[:prelude] << code
       end
-      
+
       def emit_exception_handler(&block)
         proc_id = add_app_proc block
         @stack.last[:rescue_proc_id] = proc_id
       end
-      
+
       def emit_block(conditional, &block)
         proc_id = add_app_proc block
         @stack.last[:branched] = true
@@ -93,7 +93,7 @@ module Tipi
         @app_procs[id] = proc
         id
       end
-      
+
       def assemble_frame(frame)
         indent = 0
         lines = []

data/lib/tipi/configuration.rb

@@ -12,7 +12,7 @@ module Tipi
           old_runner&.stop
         end
       end
-      
+
       def run(config)
         start_listeners(config)
         config[:forked] ? forked_supervise(config) : simple_supervise(config)
@@ -29,7 +29,7 @@ module Tipi
         suspend
         # supervise(restart: true)
       end
-      
+
       def forked_supervise(config)
         config[:forked].times do
           spin { Polyphony.watch_process { simple_supervise(config) } }

data/lib/tipi/controller/bare_stock.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Tipi
+  module Apps
+    module Bare
+      def start(opts)
+      end
+    end
+  end
+end

data/lib/tipi/controller/extensions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'tipi'
+
+module Kernel
+  def run(app = nil, &block)
+    Tipi.app = app || block
+  end
+end
+
+module Tipi
+  class << self
+    attr_writer :app
+
+    def app
+      return @app if @app
+      
+      raise 'No app define. The app to run should be set using `Tipi.app = ...`'
+    end
+
+    def run_sites(site_map)
+      sites = site_map.each_with_object({}) { |(k, v), h| h[k] = v.to_proc }
+      valid_hosts = sites.keys
+
+      @app = ->(req) {
+        handler = sites[req.host]
+        if handler
+          handler.call(req)
+        else
+          req.respond(nil, ':status' => Qeweney::Status::NOT_FOUND)
+        end
+      }
+
+      @app.define_singleton_method(:valid_hosts) { valid_hosts }
+    end
+  end
+end

data/lib/tipi/controller/stock_http1_adapter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'tipi/http1_adapter'
+
+module Tipi
+  class StockHTTP1Adapter < HTTP1Adapter
+    def initialize(conn, opts)
+      super(conn, opts)
+
+    end
+
+    def each(&block)
+    end
+  end
+end