waxx 0.1.2

data/lib/waxx/process.rb

@@ -0,0 +1,270 @@
+# Waxx Copyright (c) 2016 ePark labs Inc. & Daniel J. Fitzpatrick <dan@eparklabs.com> All rights reserved.
+# Released under the Apache Version 2 License. See LICENSE.txt.
+
+# Derived from dante
+
+module Waxx::Process
+
+  class Runner
+    MAX_START_TRIES = 5
+
+    attr_accessor :options, :name, :description, :verify_options_hook
+
+    class << self
+      def run(*args, &block)
+        self.new(*args, &block)
+      end
+    end
+
+    def initialize(name, defaults={}, &block)
+      @name = name
+      @startup_command = block
+      @options = {
+        :host => '0.0.0.0',
+        :pid_path => "/var/run/#{@name}.pid",
+        :log_path => false,
+        :debug => true
+      }.merge(defaults)
+    end
+
+    # Accepts options for the process
+    # `@runner.with_options { |opts| opts.on(...) }`
+    def with_options(&block)
+      @with_options = block
+    end
+
+    # Executes the runner based on options
+    # `@runner.execute`
+    # `@runner.execute { ... }`
+    def execute(opts={}, &block)
+      parse_options
+      self.options.merge!(opts)
+
+      @verify_options_hook.call(self.options) if @verify_options_hook
+
+      if options.include?(:kill)
+        self.stop
+      else # create process
+        self.stop if options.include?(:restart)
+
+        # If a username, uid, groupname, or gid is passed,
+        # drop privileges accordingly.
+
+        if options[:group]
+          gid = options[:group].is_a?(Integer) ? options[:group] : Etc.getgrnam(options[:group]).gid
+          Process::GID.change_privilege(gid)
+        end
+
+        if options[:user]
+          uid = options[:user].is_a?(Integer) ? options[:user] : Etc.getpwnam(options[:user]).uid
+          Process::UID.change_privilege(uid)
+        end
+
+        @startup_command = block if block_given?
+        options[:daemonize] ? daemonize : start
+      end
+    end
+
+    def daemonize
+      return log("Process is already started") if self.daemon_running? # daemon already started
+
+      if !options[:log_path]
+         options[:log_path] = "/var/log/#{@name}.log"
+      end
+
+      # Start process
+      pid = fork do
+        exit if fork
+        Process.setsid
+        exit if fork
+        store_pid(Process.pid)
+        File.umask 0000
+        redirect_output!
+        start
+      end
+      Process.waitpid pid
+      # Ensure process is running
+      if until_true(MAX_START_TRIES) { self.daemon_running? }
+        log "Daemon has started successfully"
+        true
+      else # Failed to start
+        log "Daemonized process couldn't be started"
+        false
+      end
+    end
+
+    def start
+      log "Starting #{@name} service..."
+
+      if log_path = options[:log_path] && options[:daemonize].nil?
+         redirect_output!
+      end
+
+      trap("INT") {
+        interrupt
+        exit
+      }
+
+      trap("TERM"){
+        log "Trying to stop #{@name}..."
+        exit
+      }
+
+      @startup_command.call(self.options) if @startup_command
+    end
+
+    # Stops a daemonized process
+    def stop(kill_arg=nil)
+      if self.daemon_running?
+        kill_pid(kill_arg || options[:kill])
+        until_true(MAX_START_TRIES) { self.daemon_stopped? }
+      else # not running
+        log "No #{@name} processes are running"
+        false
+      end
+    end
+
+    def restart
+      self.stop
+      self.start
+    end
+
+    def interrupt
+      if options[:debug]
+        raise Interrupt
+        sleep 1
+      else
+        log "Interrupt received; stopping #{@name}"
+      end
+    end
+
+    # Returns true if process is not running
+    def daemon_stopped?
+      ! self.daemon_running?
+    end
+
+    # Returns running for the daemonized process
+    # self.daemon_running?
+    def daemon_running?
+      return false unless File.exist?(options[:pid_path])
+      Process.kill 0, File.read(options[:pid_path]).to_i
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    protected
+
+    def parse_options
+      headline = [@name, @description].compact.join(" - ")
+      OptionParser.new do |opts|
+        opts.summary_width = 25
+        opts.banner = [headline, "\n\n",
+                     "Usage: #{@name} [-p port] [-P file] [-d] [-k]\n",
+                     "       #{@name} --help\n"].compact.join("")
+        opts.separator ""
+
+        opts.on("-p", "--port PORT", Integer, "Specify port", "(default: #{options[:port]})") do |v|
+          options[:port] = v
+        end
+
+        opts.on("-P", "--pid FILE", String, "save PID in FILE when using -d option.", "(default: #{options[:pid_path]})") do |v|
+          options[:pid_path] = File.expand_path(v)
+        end
+
+        opts.on("-d", "--daemon", "Daemonize mode") do |v|
+          options[:daemonize] = v
+        end
+
+        opts.on("-l", "--log FILE", String, "Logfile for output", "(default: /var/log/#{@name}.log)") do |v|
+          options[:log_path] = v
+        end
+
+        opts.on("-k", "--kill [PORT]", String, "Kill specified running daemons - leave blank to kill all.") do |v|
+          options[:kill] = v
+        end
+
+        opts.on("-u", "--user USER", String, "User to run as") do |user|
+          options[:user] = user
+        end
+
+        opts.on("-G", "--group GROUP", String, "Group to run as") do |group|
+          options[:group] = group
+        end
+
+        opts.on_tail("-?", "--help", "Display this usage information.") do
+          puts "#{opts}\n"
+          exit
+        end
+
+        # Load options specified through 'with_options'
+        instance_exec(opts, &@with_options) if @with_options
+      end.parse!
+      options
+    end
+
+    def store_pid(pid)
+      FileUtils.mkdir_p(File.dirname(options[:pid_path]))
+      File.open(options[:pid_path], 'w'){|f| f.write("#{pid}\n")}
+    end
+
+    def kill_pid(k='*')
+      Dir[options[:pid_path]].each do |f|
+        begin
+          pid = IO.read(f).chomp.to_i
+          FileUtils.rm f
+          Process.kill('TERM', pid)
+          log "Stopped PID: #{pid} at #{f}"
+        rescue => e
+          log "Failed to stop! #{k}: #{e}"
+        end
+      end
+    end
+
+    # Redirect output based on log settings (reopens stdout/stderr to specified logfile)
+    # If log_path is nil, redirect to /dev/null to quiet output
+    def redirect_output!
+      if log_path = options[:log_path]
+        # if the log directory doesn't exist, create it
+        FileUtils.mkdir_p File.dirname(options[:log_path]), :mode => 0755
+        # touch the log file to create it
+        FileUtils.touch log_path
+        # Set permissions on the log file
+        File.chmod(0644, log_path)
+        # Reopen $stdout (NOT +STDOUT+) to start writing to the log file
+        $stdout.reopen(log_path, 'a')
+        # Redirect $stderr to $stdout
+        $stderr.reopen $stdout
+        $stdout.sync = true
+      else # redirect to /dev/null
+        # We're not bothering to sync if we're dumping to /dev/null
+        # because /dev/null doesn't care about buffered output
+        $stdin.reopen '/dev/null'
+        $stdout.reopen '/dev/null', 'a'
+        $stderr.reopen $stdout
+      end
+      log_path = options[:log_path] ? options[:log_path] : '/dev/null'
+    end
+
+    # Runs until the block condition is met or the timeout_seconds is exceeded
+    # until_true(10) { ...return_condition... }
+    def until_true(timeout_seconds, interval=1, &block)
+      elapsed_seconds = 0
+      while elapsed_seconds < timeout_seconds && block.call != true
+        elapsed_seconds += interval
+        sleep(interval)
+      end
+      elapsed_seconds < timeout_seconds
+    end
+
+    def log(message)
+      puts message
+    end
+
+  end
+
+  def self.run(name, options={}, &blk)
+    Waxx::Process::Runner.new(name, options, &blk).execute
+  end
+
+end

data/lib/waxx/req.rb

@@ -0,0 +1,116 @@
+# Waxx Copyright (c) 2016-2017 ePark labs Inc. & Daniel J. Fitzpatrick <dan@eparklabs.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Waxx
+
+  ##
+  # The Request Struct gets instanciated with each request (x.req)
+  # ```
+  # x.req.env   # A hash of the request environment
+  # x.req.data  # The raw body of put, post, patch requests
+  # x.req.meth  # Request method as a string: GET, PUT, POST, PATCH, DELETE
+  # x.req.uri   # The URI 
+  # x.req.get   # The GET/URL parameters (has with string keys and values) shortcut: x['name'] => 'value'
+  # x.req.post  # The POST/BODY params with string keys and values) shortcut: x['name'] => 'value'
+  # ```
+  #
+  # GET params can be delimited with & or ;. The following are equivilant:
+  #
+  # ```
+  # http://localhost:7777/waxx/env?x=1&y=2&z=3
+  # http://localhost:7777/waxx/env?x=1;y=2;z=3
+  # ```
+  #
+  # Note that single params are single values and will be set to the last value received. 
+  # Params names with "[]" appended are array values.
+  #
+  # ```
+  # http://localhost:7777/waxx/env?foo=1;foo=2;foo=3
+  # x['foo'] => "3"
+  #
+  # http://localhost:7777/waxx/env?foo[]=1;foo[]=2;foo[]=3
+  # x['foo'] => ["1", "2", "3"]
+  #
+  # ```
+  # If you are uploading JSON directly in the body (with the content type application/json or text/json), then the types are matched.
+  #
+  # Given the a request like:
+  #
+  # ```
+  # Content-Type: application/json
+  #
+  # {foo:123,bar:['a','1',2]}
+  # ```
+  #
+  # The following vars are of the type submitted
+  #
+  # ```
+  # x['foo'] => 123 (as an int)
+  # x['bar'] => ['a','1',2] (1 is a string and 2 is an int)
+  # ```
+  #
+  # ### File Uploads
+  # Given the form:
+  #
+  # ```
+  # <form action="/file/upload" method="post" enctype="multipart/form-data">
+  #   <input type="file" name="file">
+  #   <button type="submit">Upload File</button>
+  # </form>
+  # ```
+  #
+  # The following hash is available (symbol keys):
+  #
+  # ```
+  # x['file'][:filename] => 'file_name.ext'
+  # x['file'][:data] => The content of the file
+  # x['file'][:content_type] => The Content-Type as sent by the browser
+  # x['file'][:headers] => An hash of other headers send by the browser regarding this file
+  # ```
+  #
+  # How to save a file to the tmp folder:
+  #
+  # **app/file/file.rb**
+  #
+  # ```
+  # module App::File
+  #   extend Waxx::Object
+  #   runs(
+  #     upload: {
+  #       desc: 'Upload a file to the tmp folder',
+  #       post: -> (x) {
+  #         # Strip any non-word chars and save the file to the tmp folder
+  #         File.open("#{Waxx::Root}/tmp/(x/:file/:filename).gsub(/[\W\.]/,'-'),'wb'){|f| 
+  #           f << x/:file/:data
+  #         }
+  #         x << "Your file has been uploaded."
+  #       }
+  #     }
+  #   )
+  # end
+  # ```
+  #
+  Req = Struct.new(
+    :env,
+    :data,
+    :meth,
+    :uri,
+    :get,
+    :post,
+    :cookies,
+    :start_time
+  )  
+
+end
+

data/lib/waxx/res.rb

@@ -0,0 +1,98 @@
+# Waxx Copyright (c) 2016-2017 ePark labs Inc. & Daniel J. Fitzpatrick <dan@eparklabs.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Waxx
+
+  ##
+  # The Response Struct gets instanciated with each request (x.res)
+  #
+  # ```
+  # x.res[name] = value    # Set a response header
+  # x.res.as(extention)    # Set the Content-Type header based on extension
+  # x.res.redirect '/path' # Redirect the client with 302 / Location header
+  # x.res.location '/path' # Redirect the client with 302 / Location header
+  # x.res.cookie(          # Set a cookie
+  #   name: "", 
+  #   value: nil, 
+  #   domain: nil, 
+  #   expires: nil, 
+  #   path: "/", 
+  #   secure: true, 
+  #   http_only: false, 
+  #   same_site: "Lax"
+  # )
+  # x << "ouput"           # Append output to the response body 
+  # x.res << "output"      # Append output to the response body
+  # ```
+  Res = Struct.new(
+    :server,
+    :status,
+    :headers,
+    :out,
+    :error,
+    :cookies,
+    :no_cookies
+  ) do
+
+    # Send output to the client (may be buffered)
+    def << str
+      out << str
+    end
+
+    def [](n,v)
+      headers[n]
+    end
+
+    def []=(n,v)
+      headers[n] = v
+    end
+
+    def as(ext)
+      headers['Content-Type'] = Waxx::Http.ctype(ext)
+    end
+    
+    def location(uri)
+      self.status = 302
+      headers['Location'] = uri
+    end
+    alias redirect location
+
+    # Return the response headers
+    def head
+      [
+        "HTTP/1.1 #{status} #{Waxx::Http::Status[status.to_s]}",
+        headers.map{|n,v| "#{n}: #{v}"},
+        (cookies.map{|c| 
+          "Set-Cookie: #{c}"
+        } unless no_cookies),
+        "\r\n"
+      ].flatten.join("\r\n")
+    end
+    
+    # Output the headers and the body
+    def complete
+      re = out.join
+      headers["Content-Length"] = re.bytesize
+      server.print head
+      server.print re
+    end
+
+    def cookie(name:"", value:nil, domain:nil, expires:nil, path:"/", secure:true, http_only: false, same_site: "Lax")
+      expires = expires.nil? ? "" : "expires=#{Time === expires ? expires.rfc2822 : expires}; "
+      cookies << "#{name}=#{Waxx::Http.escape(value.to_s)}; #{expires}#{";domain=#{domain}" if domain}; path=#{path}#{"; secure" if secure}#{"; HttpOnly" if http_only}; SameSite=#{same_site}"
+    end
+  end
+
+end
+