freud 0.0.1

data/lib/freud/launcher.rb

@@ -0,0 +1,121 @@
+require "agrippa/mutable"
+require "freud/logging"
+
+module Freud
+    class Launcher
+        include Logging
+
+        include Agrippa::Mutable
+
+        state_reader %w(name root pidfile logfile background create_pidfile
+            reset_env env commands sudo_user args)
+
+        state_accessor :process
+
+        def default_state
+            { process: Process }
+        end
+
+        def run(command, args = [])
+            @args = args
+            case(command)
+                when "help" then show_help
+                when "start" then daemonize(fetch_executable(command, true))
+                else execute(fetch_executable(command))
+            end
+        end
+
+        private
+
+        def fetch_executable(command, background = false)
+            apply_sudo(background) do
+                commands.fetch(command) do
+                    show_help(false)
+                    logger.fatal("Unknown command: #{command}") 
+                end
+            end
+        end
+
+        def apply_sudo(background)
+            command = yield
+            return(command) unless (sudo_user.to_s != "")
+            bash = sprintf('bash -c "%s"', command.gsub(/"/, '\\"'))
+            sudo_env = env.map { |key, value| sprintf('%s="%s"', key,
+                value.gsub(/"/, '\\"')) }.join(" ")
+            maybe_background = background ? "-b" : ""
+            sudo_options = "-n #{maybe_background} -u #{sudo_user}"
+            "sudo #{sudo_options} #{sudo_env} -- #{bash}"
+        end
+
+        def show_help(terminate = true)
+            logger.info("Valid commands: #{commands.keys.join(", ")}")
+            exit(0) if terminate
+            self
+        end
+
+        def execute(command, options = nil)
+            log_runtime_environment(command)
+            $PROGRAM_NAME = command
+            process.exec(env, command, options || spawn_default_options)
+            self
+        end
+
+        def daemonize(command)
+            return(self) if running?
+            options = spawn_default_options
+            options[:err] = [ logfile, "a" ] if logfile
+            create_logfile
+            if background
+                options.merge!(pgroup: true)
+                log_runtime_environment(command, options)
+                pid = process.spawn(env, command, options)
+                maybe_create_pidfile(pid)
+            else
+                $PROGRAM_NAME = command
+                maybe_create_pidfile(process.pid)
+                execute(command, options)
+            end
+        end
+
+        def log_runtime_environment(command, options = nil)
+            options ||= spawn_default_options
+            logger.debug("running #{command}")
+            logger.debug("env #{ENV.inspect}")
+            logger.debug("env #{env.inspect}")
+            logger.debug("spawn_default_options #{options.inspect}")
+            self
+        end
+
+        def create_logfile
+            return unless logfile
+            begin
+                file = File.open(logfile, "a")
+                file.close
+            rescue
+                logger.fatal("Unable to open logfile: #{logfile}")
+            end
+            self
+        end
+
+        def spawn_default_options
+            output = {}
+            output[:unsetenv_others] = (reset_env == true)
+            output[:chdir] = root
+            output[:close_others] = true
+            output[:in] = "/dev/null"
+            output[:out] = :err
+            output
+        end
+
+        def maybe_create_pidfile(pid)
+            return(self) unless (create_pidfile == true)
+            pidfile.write(pid)
+            self
+        end
+
+        # FIXME  Kill stale pidfile?
+        def running?
+            pidfile.running?
+        end
+    end
+end

data/lib/freud/logging.rb

@@ -0,0 +1,44 @@
+require "logger"
+
+module Freud
+    class RunnerExit < StandardError
+        attr_reader :message, :value
+
+        def initialize(message, value = 1)
+            @message, @value = message, value
+        end
+    end
+
+    class FreudLogger < Logger
+        def initialize(*args)
+            super
+            debug_on = ENV.has_key?("DEBUG")
+            self.level = debug_on ? Logger::DEBUG : Logger::INFO
+            self.formatter = proc { |s, t, p, m| "#{m.strip}\n" }
+        end
+
+        def fatal(message)
+            super
+            raise(RunnerExit.new(message, 1))
+        end
+    end
+
+    module Logging
+        def self.log_to(stream)
+            @logger = FreudLogger.new(stream)
+            self
+        end
+
+        def self.logger
+            @logger ||= FreudLogger.new($stderr)
+        end
+
+        def logger
+            Freud::Logging.logger
+        end
+
+        def exit(value = 0)
+            raise(RunnerExit.new(nil, value))
+        end
+    end
+end

data/lib/freud/pidfile.rb

@@ -0,0 +1,49 @@
+require "freud/logging"
+
+module Freud
+    class Pidfile
+        include Logging
+
+        def initialize(path)
+            @path = path
+        end
+
+        def write(pid)
+            File.open(@path, "w") { |f| f.write(pid.to_s) }
+            self
+        end
+
+        def read
+            return unless @path
+            return unless (File.exists?(@path) and File.readable?(@path))
+            output = File.read(@path)
+            output ? output.to_i : nil
+        end
+
+        def to_s
+            @path
+        end
+
+        def ==(other)
+            File.expand_path(to_s) == File.expand_path(other.to_s)
+        end
+
+        def kill(signal)
+            pid = read
+            return(self) unless pid
+            Process.kill(signal, pid)
+            self
+        end
+
+        def running?
+            begin
+                kill(0)
+                true
+            rescue Errno::ESRCH
+                false
+            rescue Errno::EPERM
+                true
+            end
+        end
+    end
+end

data/lib/freud/runner.rb

@@ -0,0 +1,197 @@
+require "freud/version"
+require "freud/logging"
+require "freud/config"
+require "freud/launcher"
+
+module Freud
+    class Runner
+        include Logging
+
+        def self.run(args = ARGV)
+            begin
+                new.run(args)
+            rescue RunnerExit => exception
+                exit(exception.value)
+            end
+        end
+
+        def run(args)
+            command = extract_command(args)
+            case(command)
+            when "version" then run_version
+            when "generate", "g" then run_generate(args)
+            when "@check" then run_check(args)
+            when "@wait-up" then run_wait_up(args)
+            when "@wait-down" then run_wait_down(args)
+            when "@signal-term" then run_signal(args, "TERM")
+            when "@signal-kill" then run_signal(args, "KILL")
+            when "@signal-hup" then run_signal(args, "HUP")
+            when "@dump" then run_dump(args)
+            else Launcher.new(fetch_config(args).to_hash).run(command, args)
+            end
+        end
+
+        private
+
+        def fetch_config(args)
+            file = extract_file(args)
+            stage = extract_stage(args)
+            Config.new.load(file, stage)
+        end
+
+        def run_version
+            logger.info Freud::VERSION
+            exit(0)
+        end
+
+        def run_generate(args)
+            logger.fatal("Usage: freud new [file]") unless args.first
+            path = args.first.sub(/(\.json)?$/, ".json")
+            name = File.basename(path).sub(/(\.json)?$/, "")
+            logger.fatal("File exists: #{path}") if File.exists?(path)
+            scaffold = <<-END
+                { 
+                    "name": "#{name}",
+                    "root": "#{File.expand_path(Dir.pwd)}",
+                    "background": false,
+                    "create_pidfile": false,
+                    "reset_env": false,
+                    "pidfile": "tmp/#{name}.pid",
+                    "logfile": "log/#{name}.log",
+                    "vars": {},
+                    "env": {},
+                    "stages": {
+                        "development": {},
+                        "production": {}
+                    },
+                    "commands": {
+                        "start": "/bin/false",
+                        "stop": "%freud @signal-term; %freud @wait-down",
+                        "restart": "%freud stop && %freud start",
+                        "reload": "%freud @signal-hup; %freud @wait-up",
+                        "kill": "%freud @signal-kill; %freud @wait-down",
+                        "status": "%freud @check"
+                    }
+                }
+            END
+            lines = scaffold.lines.map { |l| l.rstrip.sub(/^\s{16}/, "") }
+            File.open(path, "w") { |f| f.write(lines.join("\n")) }
+            exit(0)
+        end
+
+        def run_check(args)
+            config = fetch_config(args)
+            print_status(config)
+        end
+
+        def print_status(config)
+            pidfile = config.fetch("pidfile")
+            name = config.fetch("name")
+            if pidfile.running?
+                pid = pidfile.read
+                logger.info("#{name} up with PID #{pid}.")
+            else
+                logger.info("#{name} down.")
+            end
+            exit(0)
+        end
+
+        def run_wait_down(args)
+            timeout = (extract_option(args, "-t", "--timeout") || 30).to_i
+            config = fetch_config(args)
+            pidfile = config.fetch("pidfile")
+            name = config.fetch("name")
+            started_at = Time.now.to_i
+            logger.info("Waiting #{timeout} seconds for #{name} to stop.") \
+                if pidfile.running?
+            while(pidfile.running?)
+                sleep(0.25)
+                next if ((Time.now.to_i - started_at) < timeout)
+                logger.info("#{name} not down within #{timeout} seconds.")
+                exit(1)
+            end
+            print_status(config)
+        end
+
+        def run_wait_up(args)
+            timeout = (extract_option(args, "-t", "--timeout") || 30).to_i
+            config = fetch_config(args)
+            pidfile = config.fetch("pidfile")
+            name = config.fetch("name")
+            started_at = Time.now.to_i
+            while(not pidfile.running?)
+                sleep(0.25)
+                next if ((Time.now.to_i - started_at) < timeout)
+                logger.info("#{name} not up within #{timeout} seconds.")
+                exit(1)
+            end
+            print_status(config)
+        end
+
+        def run_signal(args, signal)
+            config = fetch_config(args)
+            pidfile = config.fetch("pidfile")
+            exit(1) unless pidfile.running?
+            pidfile.kill(signal)
+            exit(0)
+        end
+
+        def run_dump(args)
+            fetch_config(args).dump
+            exit(0)
+        end
+
+        def extract_flag(args, *flags)
+            flags.inject(false) { |out, flag| args.delete(flag) ? true : out }
+        end
+
+        def extract_option(args, *options)
+            output_args, index, value = [], 0, nil
+            while(index < args.length)
+                head = args[index]
+                tail = args[index + 1]
+                if options.include?(head)
+                    index += 2
+                    value = tail
+                else
+                    index += 1
+                    output_args.push(head)
+                end
+            end
+            args.replace(output_args)
+            value
+        end
+
+        def extract_command(args)
+            return(args.shift) unless args.empty?
+            usage
+        end
+
+        def extract_file(args)
+            service_path = ENV["FREUD_SERVICE_PATH"] || "services"
+            path = args.shift
+            filename = first_file_in(path, "#{service_path}/#{path}.json",
+                ENV["FREUD_CONFIG"])
+            usage unless filename
+            logger.fatal("Can't open: #{filename}") \
+                unless (File.file?(filename) and File.readable?(filename))
+            File.open(filename, "r")
+        end
+
+        def extract_stage(args)
+            args.shift || ENV["FREUD_STAGE"] || "development"
+        end
+
+        def first_file_in(*paths)
+            paths.each do |path|
+                next if path.nil?
+                return(path) if File.exists?(path)
+            end
+            nil
+        end
+
+        def usage
+            logger.fatal("Usage: freud [command] [file] <stage>")
+        end
+    end
+end

data/lib/freud/variables.rb

@@ -0,0 +1,64 @@
+require "agrippa/mutable_hash"
+
+module Freud
+    class Variables
+        VARIABLES = /(?<!\\)%((\w+)|{(\w+)}|{(\w+)\|(.*)})/i
+
+        ESCAPED_SIGILS = /\\%/
+
+        UNDEFINED = Object.new
+
+        include Agrippa::MutableHash
+
+        def initialize(*args)
+            super
+            @stack = {}
+        end
+
+        def each_pair(&block)
+            @state.each_pair(&block)
+        end
+
+        def test(input)
+            (input =~ VARIABLES) ? true : false
+        end
+
+        def merge(updates)
+            chain(updates)
+        end
+
+        def fetch(key, default = UNDEFINED)
+            key = key.to_sym
+            return(@state.fetch(key, default)) unless (default == UNDEFINED)
+            @state.fetch(key) { raise(KeyError, "Unknown variable: #{key}") }
+        end
+
+        def apply(input)
+            return(nil) if input.nil?
+            interpolated = input.gsub(VARIABLES) do 
+                key = $~[2] || $~[3] || $~[4] 
+                default = $~[5] || UNDEFINED
+                push_stack(key, input)
+                output = apply(fetch(key, default).to_s)
+                pop_stack(key)
+                output
+            end
+            interpolated.gsub(ESCAPED_SIGILS, "%")
+        end
+
+        def push_stack(key, input)
+            if @stack[key]
+                message = "Infinite loop evaluating '%#{key}' in '#{input}'"
+                raise(RuntimeError, message)
+            else
+                @stack[key] = true
+                self
+            end
+        end
+
+        def pop_stack(key)
+            @stack.delete(key)
+            self
+        end
+    end
+end