freyr 0.4.2 → 0.5.0

data/lib/freyr/process_info.rb

@@ -4,19 +4,28 @@ module Freyr
     def initialize pid
       @pid = pid
     end
+
+    def alive?
+      Process.getpgid(pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
     
     def ps
       return if !pid || pid.to_s.empty?
-      info = `ps p #{pid} -o pid,rss,vsz,pmem,pcpu,ruser,command`
-      match = info.match(/#{pid}\s+(\d+)\s+(\d+)\s+([\d\.]+)\s+([\d\.]+)\s+(\w+)\s+(.+)/)
-      return unless match
-      @rss = match[1].to_i
-      @vsz = match[2].to_i
-      @pmem = match[3].to_f
-      @pcpu = match[4].to_f
-      @ruser = match[5]
-      @command = match[6]
-      info
+      @ps_info ||= begin
+        info = `ps p #{pid} -o pid,rss,vsz,pmem,pcpu,ruser,command`
+        match = info.match(/#{pid}\s+(\d+)\s+(\d+)\s+([\d\.]+)\s+([\d\.]+)\s+(\w+)\s+(.+)/)
+        return unless match
+        @rss = match[1].to_i
+        @vsz = match[2].to_i
+        @pmem = match[3].to_f
+        @pcpu = match[4].to_f
+        @ruser = match[5]
+        @command = match[6]
+        info
+      end
     end
     
     def port

data/lib/freyr/rvm.rb

@@ -0,0 +1,35 @@
+module Freyr
+  module RVM
+    extend self
+
+    def installed? ruby=nil
+      return !`which rvm`.empty? unless ruby
+
+      ruby, gemset = ruby.split('@')
+      if rubies.include? ruby
+        gemset ? gemsets_for(ruby).include?(gemset) : true
+      else
+        false
+      end
+    end
+
+    def rubies
+      @rubies ||= `rvm list`.strip.split("\n").collect do |line|
+        next unless line =~ /^(\s{3}|=)/
+        line.strip.sub(/\=\>\s/,'').sub(/\s\[.+\]$/,'')
+      end.compact
+    end
+
+    def gemsets_for ruby
+      @gemsets_for ||= Hash.new do |h,ruby|
+        output = `rvm #{ruby} exec rvm gemset list`.strip.split("\n")
+        output.shift
+        h[ruby] = output.collect do |line|
+          next unless line =~ /^(\s{3}|=)/
+          line.strip.sub(/\=\>\s/,'')
+        end.compact
+      end
+      @gemsets_for[ruby]
+    end
+  end
+end

data/lib/freyr/service.rb

@@ -3,43 +3,36 @@ module Freyr
     extend Forwardable
     class << self
       def add_service_method *methods
-        def_delegators :@service_info, *methods
+        
       end
     end
     
-    attr_reader :service_info, :command
+    attr_reader :info, :command, :defined_in_paths
+
+    def_delegators :info, :name, :groups
     
     def initialize(s)
-      @service_info = s
+      @info = s
       @command = Command.new(self)
-    end
-    
-    def start_command
-      @service_info.start
-    end
-    
-    def env
-      service_info.env || {}
-    end
-    
-    def log
-      @service_info.read_log || @service_info.log || File.join(command.file_dir,"#{name}.log")
-    end
-    
-    def write_log?
-      @service_info.log && !@service_info.read_log
+      Service.by_selector[name] = ServiceGroup.new(self)
+      Service.s[name] = self
+      Service.by_name[name] = self
+    end
+    class NoProcMatch < StandardError; end
+
+    def pid_file
+      @pid_file ||= begin
+        raise NoProcMatch, "please provide proc_match for service #{@info.name}" unless @info.proc_match
+        PidFile.new(@info.pid_file,@info.proc_match)
+      end
     end
     
     def start!
-      if start_command
-        command.run! unless alive?
-      else
-        error("no start_command")
-      end
+      command.run! unless alive?
     end
     
     def stop!
-      command.kill! if start_command
+      command.kill!
     end
     
     def restart!
@@ -47,110 +40,118 @@ module Freyr
     end
     
     def is_group?(name)
-      groups.find {|g| g.to_s == name.to_s}
+      @info.groups.find {|g| g.to_s == name.to_s}
     end
     
     def alive?
-      command.alive?
+      pid_file.alive?
+    end
+
+    def call_graph
+      graph = Hash.new {|h,k| h[k]=[]}
+      graph[self]
+      @info.dependencies.each do |dep|
+        if d = Service.s[dep]
+          graph[self] << d
+          graph.merge!(d.call_graph)
+        end
+      end
+      graph
+    end
+
+    def dependencies(yell = false)
+      missing = []
+      deps = @info.dependencies.inject([]) do |all,dep|
+        if d = Service.s[dep]
+          all | (d.dependencies(yell) + [d])
+        else
+          missing << dep
+          all
+        end
+      end
+
+      if yell && !missing.empty?
+        raise MissingDependency, "missing #{missing.join(', ')} dependencies"
+      end
+
+      deps.compact
     end
     
     def ping!
-      if ping
+      if @info.ping
         pinger = Pinger.new(self)
         pinger.ping
         pinger
       end
     end
     
-    def read_log
-      @service_info.log || @service_info.read_log
-    end
-    
     def tail!(size = 600, follow = true)
       f = follow ? 'f' : ''
-      if read_log
-        cmd = "tail -#{size}#{f} #{File.join(dir||'/',read_log)}"
+      log_location = @info.log
+      if File.exist?(log_location)
+        cmd = "tail -#{size}#{f} #{log_location}"
         Freyr.logger.debug("tailing cmd") {cmd.inspect}
         exec(cmd)
       else
-        error("no logfile found")
+        error("no logfile found at #{log_location}")
+        abort("no logfile found at #{log_location}")
       end
     end
     
     def error *args, &blk
       Freyr.logger.error(*args,&blk)
-      Freyr.logger.debug("service info for service #{self}") {@service_info.inspect}
+      Freyr.logger.debug("service info for service with error #{self}") {@info.inspect}
     end
     
     def describe
-      %Q{#{name}(#{groups.join(',')}) - #{start_command}}
+      %Q{#{@info.name}(#{@info.groups.join(',')}) - #{@info.start}}
     end
     
     def matches?(n)
       n = n.to_s
-      return true if name.to_s == n
+      return true if @info.name.to_s == n
       
-      also.find {|a| a.to_s == n}
+      @info.also.find {|a| a.to_s == n}
     end
     
     def inspect
-      %Q{#<Freyr::Service #{name} #{start_command.inspect}>}
+      %Q{#<Freyr::Service #{@info.name} #{@info.start.inspect}>}
     end
+
+    class MissingDependency < StandardError; end
     
     class << self
-      
+      # Get by name only
       def s
-        @all_services ||= []
+        @all_services ||= {}
       end
       
-      def names
-        @all_names ||= []
+      def selectors
+        by_selector.keys
       end
-      
-      def groups
-        @all_groups ||= []
+
+      def by_dir
+        @by_dir ||= {}
       end
-      
-      def selectors
-        names+groups
+
+      # Get by name and alias
+      def by_name
+        @by_name ||= {}
       end
-      
-      def add_file f
-        s
-        
-        Freyr.logger.debug('adding file') {f}
-        
-        services = ServiceInfo.from_file(f).collect do |ser|
-          raise 'Cannot have two things of the same name' if selectors.include?(ser.name)
-          names |= [ser.name]
-          @all_groups |= ser.groups
-          Freyr.logger.debug('adding service') {ser.name.inspect}
-          new(ser)
-        end
-        
-        @all_services += services
+
+      # by group/alias/name and always a servicegroup
+      def by_selector
+        @by_selector ||= Hash.new {|h,k| h[k] = ServiceGroup.new}
       end
       
-      def alive?(name)
-        !!self[name].find do |ser|
-          ser.alive?
-        end
+      def add_file f
+        ServiceInfo.from_file(f)
+
+        @all_services
       end
       
       def [](name)
-        group = ServiceGroup.new
-        
-        if ser = s.find {|sr| sr.matches?(name)}
-          group << ser
-        else
-          s.each do |sr|
-            if sr.is_group?(name)
-              group << sr
-            end
-          end
-        end
-        
-        group.empty? ? nil : group
+        by_selector.has_key?(name) ? by_selector[name] : nil
       end
       
     end

data/lib/freyr/service_group.rb

@@ -1,49 +1,45 @@
-require 'delegate'
-
 module Freyr
-  class ServiceGroup < Array
+  class ServiceGroup < DelegateClass(Array)
     extend Forwardable
+    include TSort
     service_methods = Service.instance_methods - Class.instance_methods
     def_delegators :first, *service_methods
     
+    def initialize *services
+      @all_services = []
+      super(services)
+    end
+
     def find_by_name(n)
       find {|s| s.name == n}
     end
+
+    def update_services
+      dependencies = inject([]) do |deps,svc|
+        deps | svc.dependencies(true)
+      end
+      @all_services = dependencies|@_dc_obj
+    end
+
+    def inspect
+      %Q{#<#{self.class.inspect} #{@_dc_obj.collect{|s| s.name}.join(', ')}>}
+    end
+
+    def call_graph
+      @call_graph ||= inject(Hash.new {|h,k| h[k]=[]}) do |graph, svc|
+        graph.merge(svc.call_graph)
+      end
+    end
     
-    # Take care this can make a stack overflow
     def run
       return [] if empty?
-      
-      needs_to_run = ServiceGroup.new
-      
-      kill = false
-      names = []
-      
-      each do |svc|
-        
-        unless svc.dependencies.empty?
-          if n = svc.dependencies.find {|s| !Service.alive?(s)}
-            if find_by_name(n)
-              needs_to_run << svc
-            elsif s = Service[n].first
-              needs_to_run << s
-              needs_to_run << svc
-            else
-              puts "Can't run #{svc.name} because dependency #{n} cannot be found"
-              kill = true
-            end
-            
-            next
-          end
-        end
-        
-        Freyr.logger.debug('starting service') {svc.name}
-        pid = svc.start!
-        names << svc.name if pid
+
+      @call_graph = nil # Make sure it's getting the latest graph
+      services = call_order
+
+      services.collect do |service|
+        service.name if service.start!
       end
-      
-      names += needs_to_run.run unless kill
-      names
     end
     
     def stop
@@ -67,6 +63,15 @@ module Freyr
       
       names
     end
-    
+
+    def tsort_each_node &blk
+      call_graph.keys.each(&blk)
+    end
+
+    def tsort_each_child(node, &blk)
+      call_graph[node].each(&blk)
+    end
+    alias call_order tsort
+
   end
 end

data/lib/freyr/service_info.rb

@@ -1,41 +1,153 @@
 module Freyr
   class ServiceInfo
     attr_reader :groups
-    
-    class << self
-      def add_service_method *methods
-        Service.send :add_service_method, *methods
-        Command.send :add_service_method, *methods
-        methods.each do |method|
-          ATTRS << methods
+    ROOT_PIDS = '/var/run/freyr'.freeze
+    USER_PIDS = File.expand_path('.freyr', '~').freeze
+    ROOT_LOGS = '/var/log/freyr'.freeze
+    USER_LOGS = USER_PIDS
+    failed = []
+    [ROOT_PIDS,USER_PIDS,ROOT_LOGS,USER_LOGS].each do |dir|
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue Errno::EACCES => e
+        failed << dir
+      end
+    end
+
+    module Base
+
+      module ClassMethods
+
+        def add_service_method *methods
+          Service.send :add_service_method, *methods
+          Command.send :add_service_method, *methods
+          methods.each do |method|
+            InstanceMethods.instance_eval do
+              define_method method do |*args|
+                val = args
+                val = val.first if val.size < 2
+                if val
+                  MODIFIERS[method].each do |mod|
+                    val = send(mod,val)
+                  end
+                  instance_variable_set("@#{method}",val)
+                else
+                  instance_variable_get("@#{method}")
+                end
+              end
+              
+            end
+
+          end
         end
+
+      end
+      
+      module InstanceMethods
+        
+      end
+      
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
       end
     end
+    include Base
+    
     
+    MODIFIERS = Hash.new {|h,k| h[k] = []}
+    MODIFIERS[:start] << :_sudo_checker
+    MODIFIERS[:stop] << :_sudo_checker
+    MODIFIERS[:restart] << :_sudo_checker
     ATTRS = []
-    add_service_method :name,:dir,:log_cmd,:log,:err_log_cmd,:err_log,:umask,
+    attr_reader :defined_in
+    add_service_method  :start,:name,:dir,:log_cmd,:log,:err_log_cmd,:err_log,:umask,
                         :uid,:gid,:chroot,:proc_match,:restart,:stop,:stop_sig,
-                        :restart_sig,:sudo,:groups,:ping,:also,:dependencies,:read_log
-    
+                        :restart_sig,:sudo,:groups,:ping,:also,:dependencies,:read_log,
+                        :pid_file, :dont_write_log,:env, :rvm
+    alias log_file log
     def initialize(name=nil, args={}, &block)
       @groups = []
       @also = []
       @dependencies = []
+      @defined_in = []
       if name.is_a?(Hash)
         @name = name.keys.first
         @groups << name[@name]
       else
         @name = name
       end
+
+      @service = Service.new(self)
       
-      instance_eval(&block)
+      instance_eval(&block) if block_given?
     end
     
     def use_sudo
       @sudo = true
     end
+
+    def env val=nil
+      raise TypeError, 'environment must be a hash' unless val.is_a?(Hash) || val.nil?
+      if val = super
+        val
+      else
+        {}
+      end
+    end
     
+    def pid_file val=nil
+      if val = super
+        val
+      else
+        if @sudo
+          File.join(ROOT_PIDS,"#{@name}.pid")
+        else
+          File.join(USER_PIDS,"#{@name}.pid")
+        end
+      end
+    end
+
+    def read_log val=nil
+      @dont_write_log = true
+      super
+    end
+
+    def log val=nil
+      val = if val = super
+        val
+      else
+        if @read_log
+          @read_log
+        else
+          if @sudo
+            File.join(ROOT_LOGS,"#{@name}.log")
+          else
+            File.join(USER_LOGS,"#{@name}.log")
+          end
+        end
+      end
+
+      val =~ /^\// ? val : File.join(dir,val)
+    end
+
+    def dir val=nil
+      if val
+        val.sub! /(.)\/$/, '\1' # remove tailing slash
+        Service.by_dir[val] = @service
+      end
+
+      if val = super
+        val
+      else
+        '/'
+      end
+    end
+
     def group(*val)
+      val.each do |group|
+        Service.by_selector[group] << @service
+      end
       @groups |= val
     end
     
@@ -44,25 +156,11 @@ module Freyr
     end
     
     def also_as(*val)
-      @also |= val
-    end
-    
-    MODIFIERS = Hash.new {|h,k| h[k] = []}
-    MODIFIERS[:start] << :_sudo_checker
-    MODIFIERS[:stop] << :_sudo_checker
-    MODIFIERS[:restart] << :_sudo_checker
-    
-    def method_missing key, val=nil
-      key = key.to_s.gsub(/\=$/,'').to_sym
-      
-      if val
-        MODIFIERS[key].each do |modifier|
-          val = send(modifier,val)
-        end
-        instance_variable_set("@#{key}", val)
-      else
-        instance_variable_get("@#{key}")
+      val.each do |aliaz|
+        Service.by_selector[aliaz] = Service.by_selector[name]
+        Service.by_name[aliaz] = Service.by_name[name]
       end
+      @also |= val
     end
     
     SUDO_MATCHER = /^sudo\s+/
@@ -85,13 +183,15 @@ module Freyr
       def from_file file
         @file_path = file
         file = File.expand_path(file)
+        Freyr.logger.debug("adding file")  {file}
         return [] unless File.exist?(file)
         @added_services = []
-        instance_eval(File.open(file).read)
+        @namespace = nil
+        instance_eval(File.open(file).read,file,0)
         @added_services
       end
       
-      def method_missing name, *args
+      def method_missing name, *args, &blk
         STDERR.puts "Freyr doesn't support #{name} as used in #{@file_path}"
       end
       
@@ -103,24 +203,22 @@ module Freyr
       
       def group name, *services
         services.each do |s|
-          services = Service[s]
-          if services
-            services.each do |service|
-              service.service_info.group(name)
-            end
-          else
-            STDERR.puts "Service #{s} not found, can't add to group #{name} as attempted in #{@file_path}"
+          service s do
+            group name
           end
         end
       end
       
       def service name=nil, &blk
         name = "#{@namespace}:#{name}" if @namespace
-        if service = Service[name]
-          service.service_info.instance_eval(&blk)
+        if service = Service.s[name]
+          service_info = service.info
         else
-          @added_services << new(name,&blk)
+          service_info = new(name)
         end
+        @added_services << service_info
+        service_info.defined_in << @file_path
+        service_info.instance_eval(&blk)
       end
     end
     

data/lib/freyr.rb

@@ -1,16 +1,33 @@
+require 'delegate'
 require 'forwardable'
 require 'logger'
+require 'fileutils'
+require 'tsort'
 
 module Freyr
-  def self.logger
-    @logger ||= Logger.new("/dev/null")
+  extend self
+  OUT = STDOUT.dup
+
+  def logger
+    @logger ||= begin 
+      log = Logger.new(STDOUT)
+      log.level = Logger::FATAL
+      log.formatter = proc do |severity, datetime, progname, msg|
+        %Q{#{severity.chars.first}: #{[progname,msg].compact.join(' - ')}\n}
+      end
+      log
+    end
   end
   
-  def self.logger= logger
+  def logger= logger
     @logger = logger
   end
 end
 
-%w{version service service_group command service_info pinger process_info}.each do |f|
+if ARGV.include?('--trace')
+  Freyr.logger.level = Logger::DEBUG
+end
+
+%w{version helpers service service_group command service_info pid_file pinger process_info rvm}.each do |f|
   require File.expand_path(File.dirname(__FILE__)+"/freyr/#{f}.rb")
 end

data/spec/freyr_spec.rb

@@ -1,7 +1,4 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "Freyr" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
-  end
+describe Freyr do
 end