pakyow-core 0.11.3 → 1.0.0.rc1

data/lib/pakyow/environment/actions/logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Actions
+    # Sets up a connection logger and logs the prologue/epilogue.
+    #
+    class Logger
+      def call(connection, &block)
+        if silence?(connection)
+          connection.logger.silence do
+            call_with_logging(connection, &block)
+          end
+        else
+          call_with_logging(connection, &block)
+        end
+      end
+
+      private
+
+      def call_with_logging(connection)
+        connection.logger.prologue(connection)
+        yield
+        connection.logger.epilogue(connection)
+      end
+
+      def silence?(connection)
+        Pakyow.silencers.any? { |silencer|
+          silencer.call(connection)
+        }
+      end
+    end
+  end
+end

data/lib/pakyow/environment/actions/normalizer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "pakyow/support/core_refinements/string/normalization"
+
+module Pakyow
+  module Actions
+    # Normalizes request uris, issuing a 301 redirect to the normalized uri.
+    #
+    class Normalizer
+      using Support::Refinements::String::Normalization
+
+      def call(connection)
+        if strict_www? && require_www? && !www?(connection) && !subdomain?(connection)
+          redirect!(connection, File.join(add_www(connection), connection.path))
+        elsif strict_www? && !require_www? && www?(connection)
+          redirect!(connection, File.join(remove_www(connection), connection.path))
+        elsif strict_path? && slash?(connection)
+          redirect!(connection, String.normalize_path(connection.path))
+        end
+      end
+
+      private
+
+      def redirect!(connection, location)
+        connection.status = 301
+        connection.set_header("Location", location)
+        connection.halt
+      end
+
+      def add_www(connection)
+        "www.#{connection.authority}"
+      end
+
+      def remove_www(connection)
+        connection.authority.split(".", 2)[1]
+      end
+
+      def slash?(connection)
+        double_slash?(connection) || tail_slash?(connection)
+      end
+
+      def double_slash?(connection)
+        connection.path.include?("//")
+      end
+
+      TAIL_SLASH_REGEX = /(.)+(\/)+$/
+
+      def tail_slash?(connection)
+        !(TAIL_SLASH_REGEX =~ connection.path).nil?
+      end
+
+      def subdomain?(connection)
+        connection.host.count(".") > 1
+      end
+
+      def www?(connection)
+        connection.subdomain == "www"
+      end
+
+      def strict_path?
+        Pakyow.config.normalizer.strict_path == true
+      end
+
+      def strict_www?
+        Pakyow.config.normalizer.strict_www == true
+      end
+
+      def require_www?
+        Pakyow.config.normalizer.require_www == true
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/config.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+require "pakyow/logger/formatters/human"
+require "pakyow/logger/formatters/logfmt"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Config
+        extend Support::Extension
+
+        apply_extension do
+          setting :default_env, :development
+          setting :freeze_on_boot, true
+          setting :exit_on_boot_failure, true
+          setting :timezone, :utc
+          setting :connection_class do
+            require "pakyow/connection"
+            Connection
+          end
+
+          setting :root do
+            File.expand_path(".")
+          end
+
+          setting :lib do
+            File.join(config.root, "lib")
+          end
+
+          setting :environment_path do
+            File.join(config.root, "config/environment")
+          end
+
+          setting :loader_path do
+            File.join(config.root, "config/loader")
+          end
+
+          defaults :test do
+            setting :exit_on_boot_failure, false
+          end
+
+          configurable :server do
+            setting :host, "localhost"
+            setting :port, 3000
+            setting :count, 1
+            setting :proxy, true
+
+            defaults :production do
+              setting :proxy, false
+
+              setting :host do
+                ENV["HOST"] || "0.0.0.0"
+              end
+
+              setting :port do
+                ENV["PORT"] || 3000
+              end
+
+              setting :count do
+                ENV["WORKERS"] || 5
+              end
+            end
+          end
+
+          configurable :cli do
+            setting :repl do
+              require "irb"; IRB
+            end
+          end
+
+          configurable :logger do
+            setting :enabled, true
+            setting :sync, true
+
+            setting :level do
+              if config.logger.enabled
+                :debug
+              else
+                :off
+              end
+            end
+
+            setting :formatter do
+              Logger::Formatters::Human
+            end
+
+            setting :destinations do
+              if config.logger.enabled
+                { stdout: $stdout }
+              else
+                {}
+              end
+            end
+
+            defaults :test do
+              setting :enabled, false
+            end
+
+            defaults :production do
+              setting :level do
+                if config.logger.enabled
+                  :info
+                else
+                  :off
+                end
+              end
+
+              setting :formatter do
+                Logger::Formatters::Logfmt
+              end
+            end
+
+            defaults :ludicrous do
+              setting :enabled, false
+            end
+          end
+
+          configurable :normalizer do
+            setting :strict_path, true
+            setting :strict_www, false
+            setting :require_www, true
+          end
+
+          configurable :tasks do
+            setting :paths, ["./tasks", File.expand_path("../../../tasks", __FILE__)]
+            setting :prelaunch, []
+          end
+
+          configurable :redis do
+            configurable :connection do
+              setting :url do
+                ENV["REDIS_URL"] || "redis://127.0.0.1:6379"
+              end
+
+              setting :timeout, 5
+              setting :driver, nil
+              setting :id, nil
+              setting :tcp_keepalive, 5
+              setting :reconnect_attempts, 1
+              setting :inherit_socket, false
+            end
+
+            configurable :pool do
+              setting :size, 3
+              setting :timeout, 1
+            end
+
+            setting :key_prefix, "pw"
+          end
+
+          configurable :cookies do
+            setting :domain
+            setting :path, "/"
+            setting :max_age
+            setting :expires
+            setting :secure
+            setting :http_only
+            setting :same_site
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/initializers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Initializers
+        extend Support::Extension
+
+        apply_extension do
+          on "configure" do
+            Dir.glob(File.join(Pakyow.config.root, "config/initializers/environment/**/*.rb")).each do |initializer|
+              require initializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/input_parsing.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+require "pakyow/support/extension"
+require "pakyow/support/indifferentize"
+
+require "pakyow/connection/query_parser"
+require "pakyow/connection/multipart_parser"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module InputParsing
+        extend Support::Extension
+        using Support::Indifferentize
+
+        apply_extension do
+          class_state :input_parsers, default: {}
+
+          on "configure" do
+            Pakyow.parse_input "application/x-www-form-urlencoded" do |input, connection|
+              connection.params.parse(input.read)
+            end
+
+            Pakyow.parse_input "multipart/form-data" do |input, connection|
+              Connection::MultipartParser.new(
+                connection.params, boundary: connection.type_params[:boundary]
+              ).parse(input)
+            end
+
+            Pakyow.parse_input "application/json" do |input, connection|
+              values = JSON.parse(input.read)
+
+              if values.is_a?(Hash)
+                values.deep_indifferentize.each do |key, value|
+                  connection.params.add(key, value)
+                end
+              end
+
+              values
+            end
+          end
+        end
+
+        class_methods do
+          def parse_input(type, &block)
+            @input_parsers[type] = block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/plugins.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Plugins
+        extend Support::Extension
+
+        apply_extension do
+          class_state :plugins, default: {}
+        end
+
+        class_methods do
+          def register_plugin(plugin_name, plugin_module)
+            @plugins[plugin_name] = plugin_module
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/restarting.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Restarting
+        extend Support::Extension
+
+        apply_extension do
+          on "run" do
+            @respawn = false
+
+            # Other processes (e.g. apps) can touch this file to restart the server.
+            #
+            watch "./tmp/restart.txt" do
+              restart
+            end
+
+            # Automatically bundle.
+            #
+            watch "./Gemfile" do
+              Bundler.with_clean_env do
+                Support::CLI::Runner.new(message: "Bundling").run("bundle install")
+              end
+            end
+
+            # Respawn when the bundle changes.
+            #
+            watch "./Gemfile.lock" do
+              respawn
+            end
+
+            # Respawn when something about the environment changes.
+            #
+            watch "#{Pakyow.config.environment_path}.rb" do
+              respawn
+            end
+          end
+        end
+
+        class_methods do
+          def respawn
+            # Set the respawn flag and stop the process manager.
+            # Pakyow will check the flag and respawn from the main thread.
+            #
+            @respawn = true; @process_manager.stop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/running.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "async/reactor"
+require "async/io/shared_endpoint"
+require "async/http/endpoint"
+
+require "pakyow/support/extension"
+
+require "pakyow/process_manager"
+require "pakyow/processes/proxy"
+require "pakyow/processes/server"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Running
+        extend Support::Extension
+
+        apply_extension do
+          unfreezable :process_manager
+
+          class_state :processes, default: []
+
+          on "run" do
+            if config.server.proxy
+              # Find a port to run the environment on, start the proxy on the configured port.
+              #
+              port = Processes::Proxy.find_local_port
+              process :proxy, restartable: false do
+                Processes::Proxy.new(
+                  host: config.server.host,
+                  port: config.server.port,
+                  proxy_port: port
+                ).run
+              end
+            else
+              # Run the environment on the configured port.
+              #
+              port = config.server.port
+            end
+
+            endpoint = Async::HTTP::Endpoint.parse(
+              "http://#{config.server.host}:#{port}"
+            )
+
+            bound_endpoint = Async::Reactor.run {
+              Async::IO::SharedEndpoint.bound(endpoint)
+            }.wait
+
+            process :server, count: config.server.count do
+              Pakyow.config.server.port = port
+
+              Processes::Server.new(
+                protocol: endpoint.protocol,
+                scheme: endpoint.scheme,
+                endpoint: bound_endpoint
+              ).run
+            end
+
+            unless config.server.proxy || ENV.key?("PW_RESPAWN")
+              Pakyow.logger << Processes::Server.running_text(
+                scheme: endpoint.scheme, host: config.server.host, port: port
+              )
+            end
+          end
+        end
+
+        class_methods do
+          def process(name, count: 1, restartable: true, &block)
+            @processes << {
+              name: name,
+              block: block,
+              count: count,
+              restartable: restartable
+            }
+          end
+
+          def run
+            performing :run do
+              @process_manager = @processes.each_with_object(ProcessManager.new) { |process, manager|
+                manager.add(process)
+              }
+
+              root_pid = Process.pid
+
+              at_exit do
+                if Process.pid == root_pid
+                  shutdown
+                else
+                  @apps.select { |app|
+                    app.respond_to?(:shutdown)
+                  }.each(&:shutdown)
+                end
+              end
+            end
+
+            @process_manager.wait
+
+            if @respawn
+              # Replace the master process with a copy of itself.
+              #
+              exec "PW_RESPAWN=true #{$0} #{ARGV.join(" ")}"
+            end
+          rescue SignalException
+            exit
+          end
+
+          def shutdown
+            if $stdout.isatty
+              # Don't let ^C mess up our output.
+              #
+              puts
+            end
+
+            Pakyow.logger << "Goodbye"
+
+            performing :shutdown do
+              @process_manager.stop
+            end
+          end
+
+          def restart
+            @process_manager.restart
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/silencing.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Silencing
+        extend Support::Extension
+
+        apply_extension do
+          class_state :silencers, default: []
+        end
+
+        class_methods do
+          def silence(&block)
+            @silencers << block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/timezone.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Environment
+    module Behavior
+      # Sets up the timezone for the environment.
+      #
+      module Timezone
+        extend Support::Extension
+
+        apply_extension do
+          after "configure" do
+            ENV["TZ"] = config.timezone.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/environment/behavior/watching.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "filewatcher"
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Environment
+    module Behavior
+      module Watching
+        extend Support::Extension
+
+        apply_extension do
+          class_state :on_change_matchers, default: {}
+          class_state :watched_paths, default: []
+
+          unfreezable :filewatcher, :filewatcher_thread
+
+          after "run" do
+            @filewatcher = Filewatcher.new(
+              @watched_paths.map { |path|
+                File.expand_path(path)
+              }
+            )
+
+            @filewatcher_thread = Thread.new do
+              @filewatcher.watch(&method(:watch_callback))
+            end
+          end
+
+          on "shutdown" do
+            @filewatcher.stop
+            @filewatcher_thread.join
+          end
+        end
+
+        class_methods do
+          # Register a callback to be called when a file changes.
+          #
+          def on_change(matcher, &block)
+            (@on_change_matchers[matcher] ||= []) << block
+          end
+
+          # Register one or more path for changes.
+          #
+          def watch(*paths, &block)
+            @watched_paths.concat(paths).uniq!
+
+            if block
+              paths.each do |path|
+                on_change(File.expand_path(path), &block)
+              end
+            end
+          end
+
+          # @api private
+          def change_callbacks(path)
+            @on_change_matchers.each_with_object([]) { |(matcher, blocks), matched_blocks|
+              if matcher.match?(path)
+                matched_blocks.concat(blocks)
+              end
+            }
+          end
+
+          # @api private
+          def watch_callback(path, _event)
+            change_callbacks(path).each do |callback|
+              instance_exec(&callback)
+            end
+          end
+        end
+      end
+    end
+  end
+end