waxx 0.1.2

data/bin/waxx

@@ -0,0 +1,120 @@
+#! /usr/bin/env ruby
+
+require 'optparse'
+
+command = ARGV[0]    
+commands = %w(on off buff start stop restart console get put post delete patch config migrate migration deploy test init help)
+if not commands.include? command
+  puts "Enter a command: #{commands.join(", ")}"
+  puts "waxx --help for all options"
+  exit 1
+end
+
+def parse_options(commands)
+  options = {
+    sub_command: ARGV[1],
+    port: 7700,
+    base: Dir.pwd,
+    env: "active",
+    pid_path: "tmp/pids/waxx.pid",
+    daemonize: false,
+    log_path: "log/waxx.log",
+    user: ENV['USER'],
+    group: nil,
+    debug: false,
+    to: "stage",
+    app: "all",
+    format: "yaml"
+  }
+  headline = ["Waxx", "The high-performance flexible framework"].compact.join(" - ")
+  OptionParser.new do |opts|
+    opts.summary_width = 25
+    opts.banner = [headline, "\n\n",
+                 "Usage: waxx command [-b base_dir] [-p port] [-P pid_file] [-d] [-e env_name] [-l file] [-u user] [-g group] [-f format]\n",
+                 "Commands: #{commands.join(" ")}\n",
+                 "    waxx 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("-b", "--base DIR", String, "The base/root directory of the app. Should contain: app, bin, opt, log, etc.", "(default: cwd: #{options[:base]})") do |v|
+      options[:base] = v.sub(/\/$/,"")
+    end
+
+    opts.on("-e", "--env ENVIRONMENT", String, "The env to find the config.yaml file.", "(default: #{options[:env]})") do |v|
+      options[:env] = 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", "(default: false)") 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("-n", "--name NAME", String, "The name of the migration", "(default: ask)") do |name|
+      options[:name] = name
+    end
+
+    opts.on("-t", "--to TO", String, "Where to deploy to (defined in opt/deploy.yaml)", "(default: stage)") do |to|
+      options[:to] = to
+    end
+
+    opts.on("-u", "--user USER", String, "User to run as", "(default: current user)") do |user|
+      options[:user] = user
+    end
+
+    opts.on("-g", "--group GROUP", String, "Group to run as", "(default: current user's primary group)") do |group|
+      options[:group] = group
+    end
+
+    opts.on("-D", "--debug", "Output debug messages (console only) 0-9","(default: 0)") do |level|
+      options[:debug] = level
+    end
+
+    opts.on("-a", "--app app_name or all", "The app to test.","(default: all)") do |app|
+      options[:app] = app
+    end
+
+    opts.on("-f", "--format FORMAT", String, "The format output that supports it (tests and config) (yaml or json).","(default: yaml)") do |format|
+      options[:format] = format
+    end
+
+    opts.on_tail("-h", "--help", "Display this usage information.") do
+      puts "#{opts}\n"
+      exit
+    end
+
+  end.parse!
+  options
+end
+
+opts = parse_options(commands)
+require_relative '../lib/waxx'
+$:.unshift "#{opts[:base]}"
+if %w(init help).include? command
+  Waxx::Conf["opts"] = opts
+else
+  Waxx::Conf.load_yaml(opts[:base], opts[:env])
+  Waxx::Conf["opts"] = opts
+  require "#{opts[:base]}/app/app"
+end
+
+if Waxx::Console::Command.respond_to? command
+  if %w(migration).include? command
+    Waxx::Console::Command.send(command, ARGV[1], ARGV[2], opts)
+  elsif %w(get post put delete patch test deploy migration migrate).include? command
+    Waxx::Console::Command.send(command, ARGV[1], opts)
+  else
+    Waxx::Console::Command.send(command, opts)
+  end
+else
+  puts "The #{command} command has not been implemented yet. opts: #{opts.inspect} conf: #{Waxx::Conf.data.inspect}"
+end

data/lib/waxx/app.rb

@@ -0,0 +1,173 @@
+# 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.
+
+##
+# Defines the applications handlers and runs the handlers
+# 
+# `@runs` holds a hash of the entire app (routes) with the methods for each
+# 
+module Waxx::App
+  extend self
+
+  Root = Waxx::Root + '/app'
+   
+  class ParameterParseError < StandardError; end
+
+  # `@runs` holds a hash of the entire app (routes) with the methods for each
+  attr :runs
+
+  def init
+    @runs = {}
+    Waxx::Server.require_apps
+  end
+
+  ##
+  # Return website page or an error message with status 404
+  # `App.not_found(x, title: "Not Found", message: "The record you requested was not found.")`
+  # The layout of the error page (html) is defined in app/app/error/html.rb
+  def not_found(x, title:"Not Found", message:nil)
+    begin
+      if message.nil?
+        return @runs[:website][:page][:get].call(x, *(x.args))
+      end
+    rescue => e
+      message = e.to_s
+    end
+    error(x, status: 404, type: "request", title: title, message: message)
+  end
+
+  ##
+  # Set an app runner
+  # You don't normally call this directly (see Waxx::Object.runs)
+  def []=(name, opts)
+    @runs[name.to_sym] = opts
+  end
+
+  ##
+  # Get an app runner
+  # You don't normally call this directly (see Waxx::Object.runs)
+  def [](name)
+    @runs[name.to_sym]
+  end
+
+  def csrf_failure(x)
+    error(x, status:400, type:"request", title:"Cross Site Request Forgery Error", message:"The request is missing the correct CSRF token.", args: [])
+  end
+
+  ##
+  # Run an app
+  #
+  # Can run the request method (get post put patch delete) or the generic "run".
+  #
+  # 1. x
+  # 2. app: The name of the app (Symbol)
+  # 3. act: The act to run (String or Symbol - type must match definition)
+  # 4, meth: The request method (Symbol)
+  # 5. args: The args to pass to the method (after x) (Array)
+  #
+  # Example: `App.run(x, :person, :record, :get, [1])` will call the get method with the parameter "1" of the record handler defined in App::Person 
+  def run(x, app, act, meth, args)
+    if @runs[app.to_sym][act][meth.to_sym]
+      begin
+        @runs[app.to_sym][act][meth.to_sym][x, *args]
+      rescue ArgumentError => e
+        if Waxx['debug']['on_screen']
+          error(x, status: 405, type: "request", title: "Argument Error", message: "#{e.to_s}\n\n#{e.backtrace.join("\n")}")
+        else
+          Waxx.debug e
+          App.not_found(x)
+        end
+      end
+    elsif @runs[app.to_sym][act][:run]
+      begin
+        @runs[app.to_sym][act][:run][x, *args]
+      rescue ArgumentError => e
+        if Waxx['debug']['on_screen']
+          error(x, status: 405, type: "request", title: "Argument Error", message: "#{e.to_s}\n\n#{e.backtrace.join("\n")}")
+        else
+          Waxx.debug e
+          App.not_found(x)
+        end
+      end
+    else
+      error(x, status: 405, type: "request", title: "Method Not Implemented", message: "The HTTP method requested is not implemented for this interface.")
+    end
+  end
+
+  ##
+  # Return an error to the client
+  # Format is dependant on the request extention x.req.ext.
+  # Layouts in app/app/error/*
+  def error(x, status:200, type:"request", title:"An error occurred", message:"", args: [])
+    x.res.status = status
+    App[:app_error][type.to_sym][:get][x, title, message, *args]
+  end
+
+  ##
+  # Return an alert/error to the client
+  # Format is dependant on the request extention x.req.ext.
+  # Layouts in app/app/error/*
+  def alert(x, status:200, type:"request", title:"Alert", message:"", args: [])
+    x.res.status = status
+    App[:app_error][type.to_sym][:get][x, title, message, *args]
+  end
+
+  ##
+  # Determine if the client or user has access to the handler method.
+  # See Waxx::Object.runs for details
+  def access?(x, acl:nil)
+    return true if acl.nil?
+    return true if %w(* all any public).include? acl.to_s
+    return true if acl.to_s == "user" and x.usr?
+    case acl
+    when String, Symbol
+      return (x.usr["grp"] and x.usr["grp"].include? acl.to_s)
+    when Array
+      return (x.usr["grp"] and (x.usr["grp"] & acl).size > 0)
+    when Hash      
+      g = nil
+      if acl.keys.include? :any or acl.keys.include? :all
+        g = acl[:any] || acl[:all]
+      elsif acl.keys.include? :read and [:get, :head, :options].include? x.meth
+        g = acl[:read]
+      elsif acl.keys.include? :write and [:put, :post, :delete, :patch].include? x.meth
+        g = acl[:write]
+      else
+        g = acl[x.meth]
+      end
+      return false if g.nil?
+      return true if %w(* all any public).include? g.to_s
+      return access?(x, g)
+    when Proc
+      return acl.call(x)
+    else
+      Waxx.debug "No acl type recognized in App.access? for acl: #{acl.inspect}", 1
+      false
+    end
+    false
+  end
+
+  def log(x, cat, name, value=nil, id=nil)
+    AppLog.log(x, cat:cat, name:name, value:value, id:id)
+  end
+
+  # Return a random string with no confusing chars (0Oo1iIl etc)
+  def random_password(size=10)
+    random_string(size, :chars, 'ABCDEFGHJKLMNPQRSTUVWXYabcdefghkmnpqrstuvwxyz23456789#%^&$*i-_+=')
+  end
+
+  def login_needed(x)
+    if x.ext == "json"
+    else
+      App::Html.render(x,
+        title: "Please Login",
+        #message: {type:"info", message: "Please login"},
+        content: App::Usr::Html.login(x, return_to: x.req.uri)
+      )
+    end
+  end
+
+  def debug(str, level=3)
+    Waxx.debug(str, level)
+  end
+end

data/lib/waxx/conf.rb

@@ -0,0 +1,54 @@
+# 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.
+
+##
+# The global Waxx::Conf variable. ex:  `Waxx::Conf['site']['name']` or 
+# shortcut `Waxx['site']['name']`
+# Data is set in opt/env/config.yaml
+module Waxx::Conf
+  extend self
+
+  ##
+  # Internal class var for conf data
+  attr :data
+  @data = {}
+
+  ##
+  # Load the yaml config file into the Waxx module
+  # Access variables with Waxx['var1']['var2'] or Waxx/:var1/:var2
+  def load_yaml(base=ENV['PWD'], env="active")
+    env = "dev" if env == "active" and not File.exist? "#{base}/opt/active"
+    @data = ::YAML.load_file("#{base}/opt/#{env}/config.yaml")
+  end
+
+  ##
+  # Get a Waxx variable
+  def [](n)
+    @data[n]
+  end
+
+  ##
+  # Set a conf variable
+  def []=(n, v)
+    @data[n] = v
+  end
+
+  ##
+  # Get a Waxx variable
+  def /(n)
+    @data[n.to_s] || @data[n.to_sym]
+  end
+
+end
+

data/lib/waxx/console.rb

@@ -0,0 +1,204 @@
+# 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.
+
+require 'stringio'
+
+##
+# The console module that is available with irb
+# When `waxx console` is called, the dbs are connected and a StringIO class acts as the response container
+module Waxx::Console
+  extend self
+  attr_accessor :db
+  attr_accessor :x
+
+  ##
+  # Container for response output when using the console
+  class Stringy < StringIO
+    attr :out
+    # Initialize with StringIO args
+    def initialize(*args)
+      super *args
+      @out = ""
+    end
+    # Write to the output
+    def print(str)
+      @out << str
+    end
+    # Get the output
+    def output
+      @out
+    end
+    # Clear the out to run another request
+    def reset
+      @out = ""
+    end
+  end
+
+  # Initialize the console variables
+  def init
+    @db = Waxx::Database.connections
+    io = Stringy.new "GET /app/ok HTTP1/0\n#{ENV.map{|n,v| "#{n}: #{v}"}.join("\n")}"
+    @x = Waxx::Server.process_request(io, @db)
+  end
+
+  # Run a GET request
+  def get(path, opts={})
+    puts path
+    @db ||= Waxx::Database.connections
+    io = Stringy.new "GET #{path} HTTP1/0\n#{ENV.map{|n,v| "#{n}: #{v}"}.join("\n")}"
+    x = Waxx::Server.process_request(io, @db)
+    #if ARGV[0] == "get"
+      puts x.res.out
+    #else
+    #  x.res.out.join
+    #end
+  end
+
+  # The x variable used on the console. Singleton.
+  def x
+    return @x if @x
+    @x = Waxx::X.new
+    @x.db = Waxx::Database.connections
+    @x.usr = {un:ENV['USER']}
+    @x.ua = {un:ENV['USER']}
+    @x.req = Waxx::Req.new(ENV, nil, :get, "/", {}, {}, {}, Time.new)
+    @x.res = Waxx::Res.new(Stringy.new,200,{},[],[],[])
+    @x
+  end
+
+  ##
+  # Handle console commands. These are called on the command line: waxx on, waxx deploy prod, waxx test app, etc.
+  module Command
+    extend self
+    attr :x
+    def on(opts)
+      Waxx::Process::Runner.new('waxx').execute(daemonize: true, pid_path: opts[:pid_path], log_path: opts[:log_path]){
+        ::App.start(opts)
+      }
+    end
+    alias start on
+
+    def off(opts)
+      Waxx::Process::Runner.new('waxx').execute(kill: true, pid_path: opts[:pid_path])
+    end
+    alias stop off 
+
+    def restart(opts)
+      stop opts
+      sleep 1
+      start opts
+    end
+    alias buff restart
+
+    def get(url=ARGV[1], opts={})
+      Waxx['debug']['level'] = 0
+      Waxx::Console.get(url, opts)
+    end
+
+    def post(opts)
+      App.post(ARGV[1], opts)
+    end
+
+    def put(opts)
+      App.put(ARGV[1], opts)
+    end
+
+    def delete(opts)
+      App.delete(ARGV[1], opts)
+    end
+
+    def console(opts)
+      if File.exist? 'app/app.rb'
+        require 'irb'
+        puts "waxx console"
+        #help = "Use the source, Luke"
+        x = Waxx::Console.x
+        binding.irb
+        #IRB.setup(nil)
+        #workspace = IRB::WorkSpace.new(self)
+        #irb = IRB::Irb.new(workspace)
+        #IRB.conf[:MAIN_CONTEXT] = irb.context
+        #irb.eval_input
+        #require 'lib/waxx/irb.rb'
+        #@x = Waxx::Console.x
+        #IRB.start_session(self) #"#{opts[:base]}/lib/waxx/irb_env.rb")
+      else
+        puts "Error: You need to call 'waxx console' from the root of a waxx installation."
+        exit 1
+      end
+    end
+
+    def config(opts)
+      puts Waxx.data.send("to_#{opts[:format]}")
+    end
+
+    def deploy(target, opts)
+      dep = YAML.load_file("#{opts[:base]}/opt/deploy.yaml")
+      dep[target.to_s].each{|n,v|
+        puts "Deploying #{target} to #{n}"
+        `ssh #{v['user']}@#{v['host']} '#{v['command']}'`
+      }
+    end
+
+    def init(opts)
+      require_relative 'init'
+      Waxx::Init.init(x, opts)
+    end
+
+    def migrate(db='app', opts={})
+      Waxx::Database.migrate db, opts
+    end
+
+    def migration(db='app', name=nil, opts={})
+      dt = Time.new.strftime('%Y%m%d%H%M')
+      if name.nil?
+        puts "Enter the name of the migration: "
+        name = gets.chomp
+      end           
+      m_file = "db/#{db}/#{dt}-#{name.gsub(/\W/,"-")}.sql"
+      File.open(m_file, "w"){|f|
+        f.puts "BEGIN;\n\n\n\nCOMMIT;"
+      }
+      system "/usr/bin/env #{ENV['EDITOR']} #{m_file}"
+    end
+
+    def test(target, opts)
+      require_relative 'test'
+      start_time = Time.new
+      re = {}
+      total_tests = 0
+      total_passed = 0
+      if target == "waxx"
+        tests = []
+        Dir.entries(opts[:base] + '/test').each{|f|
+          next if f =~ /^\./
+          tests << f.sub(/\.rb$/,"")
+          path = opts[:base] + '/test/' + f
+          puts path
+          require path
+        }
+
+        tests.each{|waxx_module_test|
+          re[waxx_module_test] = Waxx.send(waxx_module_test)
+          re[waxx_module_test].each{|file, mod| 
+            mod.map{|meth, test| 
+              total_tests += test['tests']
+              total_passed += test['tests_passed']
+            }
+          }
+        }
+      elsif target == "all" or target.nil?
+        puts "app testing not impletemented yet: all"
+      else
+        puts "app testing not impletemented yet: #{target} #{opts[:format]}"
+      end
+      re["total_tests"] = total_tests
+      re["total_passed"] = total_passed
+      duration = ((Time.new - start_time) * 100000).to_i/100.0
+      re["performance"] = "#{((total_passed.to_f / total_tests.to_f) * 100).to_i}% in #{duration} ms"
+      puts re.send("to_#{opts[:format]}")
+    end
+
+  end
+
+end

data/lib/waxx/csrf.rb

@@ -0,0 +1,14 @@
+# 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.
+
+module Waxx::Csrf
+  extend self
+
+  def ok?(x)
+    x['csrf'] == x.usr['uk']
+  end
+
+  def ht(x)
+    %(<input type="hidden" name="csrf" value="#{x.usr['uk']}">)
+  end
+end

data/lib/waxx/database.rb

@@ -0,0 +1,80 @@
+# 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.
+
+module Waxx::Database
+  extend self
+
+  def parse_uri(uri)
+    _, schema, user, pass, host, port, database, opts = uri.split(/^(\w*):\/\/(\w*):?(.*)@([\w\-]*):?([0-9]*)?\/([\w\-]*)\??(.*)?$/)
+   {
+     type: schema,
+     user: user,
+     pass: pass,
+     host: host,
+     database: database,
+     opts: Waxx::Http.query_string_to_hash(opts) 
+   }
+  end
+
+  def connect(conf=Waxx['database'])
+    # Parse the conf string to load the correct db engine
+    engine = conf.split(":").first
+    case engine.downcase
+    when 'postgresql', 'pg'
+      Waxx::Pg.connect(conf)
+    when 'mysql2', 'mysql'
+      # Parse the string 
+      uri = parse_uri(conf)
+      # Merge the opts into the params
+      config = {
+        username: uri/:user, 
+        password: uri/:pass, 
+        host: uri/:host, 
+        port: uri/:port, 
+        database: uri/:database
+      } 
+      config.merge!(uri/:opts)
+      Waxx::Mysql2.connect(config)
+    when 'sqlite3', 'sqlite'
+      Waxx::Sqlite3.connect(conf.sub('sqlite3://',''))
+    when 'mongodb', 'mongo'
+      Waxx::Mongodb.connect(conf)
+    else
+      raise 'Unknown Database Type'
+    end
+  end
+  
+  # Define database connections in config.yaml or pass in a hash 
+  #   {
+  #     app: connection_string,
+  #     blog: connection_string
+  #   }
+  def connections(dbs=Waxx['databases'])
+    c = {}
+    return c if dbs.nil?
+    dbs.each{|name, conf|
+      c[name.to_sym] = connect(conf)
+      c.define_singleton_method(name){self[name.to_sym]}
+    }
+    c
+  end
+
+  def migrate(db_only=nil, opts={})
+    dbs = connections
+    dbs.each{|name, db|
+      next if db_only and db_only != db
+      puts "Migrating: db.#{name}"
+      # get the latest version
+      latest = db.exec("SELECT value FROM waxx WHERE name = 'db.#{name}.migration.last'").first['value']
+      Dir.entries("#{opts[:base]}/db/#{name}/").sort.each{|f|
+        if f =~ /\.sql$/ and f > latest
+          puts "  #{f}"
+          db.exec(File.read("#{opts[:base]}/db/#{name}/#{f}"))
+          db.exec("UPDATE waxx SET value = $1 WHERE name = 'db.#{name}.migration.last'",[f])
+        end
+      }
+    }
+    puts "Migration complete"
+  end
+
+end

data/lib/waxx/encrypt.rb

@@ -0,0 +1,38 @@
+# 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.
+
+module Waxx::Encrypt
+  extend self
+  def encrypt(str, encode:'b64', cipher: Waxx['encryption']['cipher'], key:Waxx['encryption']['key'], iv:Waxx['encryption']['iv'])
+    aes = OpenSSL::Cipher.new(cipher)
+    aes.encrypt
+    aes.key = key
+    aes.iv = iv if iv
+    case encode.to_sym
+      when :b64
+        Base64.encode64(aes.update(str.to_s) + aes.final).chomp
+      when :url
+        http_escape(Base64.encode64(aes.update(str.to_s) + aes.final).chomp)
+      when :bin
+        aes.update(str.to_s) + aes.final
+      else
+        throw "Encoding not defined"
+    end
+  end
+  def decrypt(str, encode:'b64', cipher: Waxx['encryption']['cipher'], key:Waxx['encryption']['key'], iv:Waxx['encryption']['iv'])
+    aes = OpenSSL::Cipher.new(cipher)
+    aes.decrypt
+    aes.key = key
+    aes.iv = iv if iv
+    case encode.to_sym
+      when :b64
+        aes.update(Base64.decode64(str.to_s + "\n")) + aes.final
+      when :url
+        aes.update(Base64.decode64(http_unescape(str.to_s) + "\n")) + aes.final
+      when :bin
+        aes.update(str.to_s) + aes.final
+      else
+        throw "Encoding not defined"
+    end
+  end
+end