launchr 1.1.0

data/lib/launchr/mixin/ordered_hash.rb

@@ -0,0 +1,189 @@
+
+module Launchr
+  module ActiveSupport
+    # <tt></tt>
+    #   ActiveSupport::OrderedHash
+    #   
+    #   Copyright (c) 2005 David Hansson, 
+    #   Copyright (c) 2007 Mauricio Fernandez, Sam Stephenson
+    #   Copyright (c) 2008 Steve Purcell, Josh Peek
+    #   Copyright (c) 2009 Christoffer Sawicki
+    #   
+    #   Permission is hereby granted, free of charge, to any person obtaining
+    #   a copy of this software and associated documentation files (the
+    #   "Software"), to deal in the Software without restriction, including
+    #   without limitation the rights to use, copy, modify, merge, publish,
+    #   distribute, sublicense, and/or sell copies of the Software, and to
+    #   permit persons to whom the Software is furnished to do so, subject to
+    #   the following conditions:
+    #   
+    #   The above copyright notice and this permission notice shall be
+    #   included in all copies or substantial portions of the Software.
+    #   
+    #   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    #   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    #   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    #   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    #   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    #   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    #   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    #
+    class OrderedHash < Hash
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def self.[](*args)
+        ordered_hash = new
+
+        if (args.length == 1 && args.first.is_a?(Array))
+          args.first.each do |key_value_pair|
+            next unless (key_value_pair.is_a?(Array))
+            ordered_hash[key_value_pair[0]] = key_value_pair[1]
+          end
+
+          return ordered_hash
+        end
+
+        unless (args.size % 2 == 0)
+          raise ArgumentError.new("odd number of arguments for Hash")
+        end
+
+        args.each_with_index do |val, ind|
+          next if (ind % 2 != 0)
+          ordered_hash[val] = args[ind + 1]
+        end
+
+        ordered_hash
+      end
+
+      def initialize_copy(other)
+        super
+        # make a deep copy of keys
+        @keys = other.keys
+      end
+
+      def store(key, value)
+        @keys << key if !has_key?(key)
+        super
+      end
+
+      def []=(key, value)
+        @keys << key if !has_key?(key)
+        super
+      end
+
+      def delete(key)
+        if has_key? key
+          index = @keys.index(key)
+          @keys.delete_at index
+        end
+        super
+      end
+
+      def delete_if
+        super
+        sync_keys!
+        self
+      end
+
+      def reject!
+        super
+        sync_keys!
+        self
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def keys
+        (@keys || []).dup
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+
+      def to_hash
+        self
+      end
+
+      def to_a
+        @keys.map { |key| [ key, self[key] ] }
+      end
+
+      def each_key
+        @keys.each { |key| yield key }
+      end
+
+      def each_value
+        @keys.each { |key| yield self[key]}
+      end
+
+      def each
+        @keys.each {|key| yield [key, self[key]]}
+      end
+
+      alias_method :each_pair, :each
+
+      def clear
+        super
+        @keys.clear
+        self
+      end
+
+      def shift
+        k = @keys.first
+        v = delete(k)
+        [k, v]
+      end
+
+      def merge!(other_hash)
+        other_hash.each {|k,v| self[k] = v }
+        self
+      end
+
+      def merge(other_hash)
+        dup.merge!(other_hash)
+      end
+
+      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+      def replace(other)
+        super
+        @keys = other.keys
+        self
+      end
+
+      def inspect
+        "#<OrderedHash #{super}>"
+      end
+
+    private
+
+      def sync_keys!
+        @keys.delete_if {|k| !has_key?(k)}
+      end
+    end
+  end
+end
+
+module Launchr
+  if RUBY_VERSION >= '1.9'
+    # Inheritance
+    #   Ruby 1.9 < Hash
+    #   Ruby 1.8 < ActiveSupport::OrderedHash
+    class OrderedHash < ::Hash
+    end
+  else
+    # Inheritance
+    #   Ruby 1.9 < Hash
+    #   Ruby 1.8 < ActiveSupport::OrderedHash
+    class OrderedHash < Launchr::ActiveSupport::OrderedHash
+    end
+  end
+end
+
+
+

data/lib/launchr/mixin/popen4.rb

@@ -0,0 +1,219 @@
+
+require 'fcntl'
+require 'etc'
+require 'io/wait'
+
+module Launchr
+  module Popen4
+    class << self
+      # This is taken directly from Ara T Howard's Open4 library, and then 
+      # modified to suit the needs of the Chef project.
+      # 
+      # http://github.com/ahoward/open4
+      # 
+      # http://www.ruby-forum.com/topic/54593
+      # 
+      # Don't use the "Block form" calling method. It screws up on the pipes IO.
+      # 
+      # Use "Simple form", always. Simple form = more robust IO handling.
+      #
+      # @example Simple form
+      #  def popen4_exec stdin_str, cmd, *args
+      #    require 'plist4r/mixin/popen4'
+      #  
+      #    pid, stdin, stdout, stderr = ::Plist4r::Popen4::popen4 [cmd, *args]
+      #  
+      #      stdin.puts stdin_str
+      #  
+      #      stdin.close
+      #      ignored, status = Process::waitpid2 pid
+      #  
+      #      stdout_result = stdout.read.strip
+      #      stderr_result = stderr.read.strip
+      #  
+      #    return [cmd, status, stdout_result, stderr_result]    
+      #  end
+      def popen4(cmd, args={}, &b)
+   
+        # Waitlast - this is magic.  
+        # 
+        # Do we wait for the child process to die before we yield
+        # to the block, or after?  That is the magic of waitlast.
+        #
+        # By default, we are waiting before we yield the block.
+        args[:waitlast] ||= false
+    
+        args[:user] ||= nil
+        unless args[:user].kind_of?(Integer)
+          args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
+        end
+        args[:group] ||= nil
+        unless args[:group].kind_of?(Integer)
+          args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
+        end
+        args[:environment] ||= {}
+
+        # Default on C locale so parsing commands output can be done
+        # independently of the node's default locale.
+        # "LC_ALL" could be set to nil, in which case we also must ignore it.
+        unless args[:environment].has_key?("LC_ALL")
+          args[:environment]["LC_ALL"] = "C"
+        end
+    
+        pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+        verbose = $VERBOSE
+        begin
+          $VERBOSE = nil
+          ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+          cid = fork {
+            pw.last.close
+            STDIN.reopen pw.first
+            pw.first.close
+
+            pr.first.close
+            STDOUT.reopen pr.last
+            pr.last.close
+
+            pe.first.close
+            STDERR.reopen pe.last
+            pe.last.close
+
+            STDOUT.sync = STDERR.sync = true
+
+            if args[:group]
+              Process.egid = args[:group]
+              Process.gid = args[:group]
+            end
+
+            if args[:user]
+              Process.euid = args[:user]
+              Process.uid = args[:user]
+            end
+        
+            args[:environment].each do |key,value|
+              ENV[key] = value
+            end
+
+            if args[:umask]
+              umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
+              File.umask(umask)
+            end
+        
+            begin
+              if cmd.kind_of?(Array)
+                exec(*cmd)
+              else
+                exec(cmd)
+              end
+              raise 'forty-two' 
+            rescue Exception => e
+              Marshal.dump(e, ps.last)
+              ps.last.flush
+            end
+            ps.last.close unless (ps.last.closed?)
+            exit!
+          }
+        ensure
+          $VERBOSE = verbose
+        end
+
+        [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+
+        begin
+          e = Marshal.load ps.first
+          raise(Exception === e ? e : "unknown failure!")
+        rescue EOFError # If we get an EOF error, then the exec was successful
+          42
+        ensure
+          ps.first.close
+        end
+
+        pw.last.sync = true
+
+        pi = [pw.last, pr.first, pe.first]
+
+        if b 
+          begin
+            if args[:waitlast]
+              b[cid, *pi]
+              # send EOF so that if the child process is reading from STDIN
+              # it will actually finish up and exit
+              pi[0].close_write
+              Process.waitpid2(cid).last
+            else
+              # This took some doing.
+              # The trick here is to close STDIN
+              # Then set our end of the childs pipes to be O_NONBLOCK
+              # Then wait for the child to die, which means any IO it
+              # wants to do must be done - it's dead.  If it isn't,
+              # it's because something totally skanky is happening,
+              # and we don't care.
+              o = StringIO.new
+              e = StringIO.new
+
+              pi[0].close
+          
+              stdout = pi[1]
+              stderr = pi[2]
+
+              stdout.sync = true
+              stderr.sync = true
+
+              stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+              stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+          
+              stdout_finished = false
+              stderr_finished = false
+         
+              results = nil
+
+              while !stdout_finished || !stderr_finished
+                begin
+                  channels_to_watch = []
+                  channels_to_watch << stdout if !stdout_finished
+                  channels_to_watch << stderr if !stderr_finished
+                  ready = IO.select(channels_to_watch, nil, nil, 1.0)
+                rescue Errno::EAGAIN
+                ensure
+                  results = Process.waitpid2(cid, Process::WNOHANG)
+                  if results
+                    stdout_finished = true
+                    stderr_finished = true 
+                  end
+                end
+
+                if ready && ready.first.include?(stdout)
+                  line = results ? stdout.gets(nil) : stdout.gets
+                  if line
+                    o.write(line)
+                  else
+                    stdout_finished = true
+                  end
+                end
+                if ready && ready.first.include?(stderr)
+                  line = results ? stderr.gets(nil) : stderr.gets
+                  if line
+                    e.write(line)
+                  else
+                    stderr_finished = true
+                  end
+                end
+              end
+              results = Process.waitpid2(cid) unless results
+              o.rewind
+              e.rewind
+              b[cid, pi[0], o, e]
+              results.last
+            end
+          ensure
+            pi.each{|fd| fd.close unless fd.closed?}
+          end
+        else
+          [cid, pw.last, pr.first, pe.first]
+        end
+      end
+    end
+  end
+end

data/lib/launchr/path.rb

@@ -0,0 +1,106 @@
+
+require 'launchr'
+require 'pathname'
+
+module Launchr
+  module Path
+    class << self
+      def user_launchdaemons
+        Pathname.new("~/Library/LaunchAgents").expand_path
+      end
+
+      def boot_launchdaemons
+        Pathname.new("/Library/LaunchDaemons")
+      end
+
+      def brew_launchdaemons
+        if homebrew_prefix
+          homebrew_prefix+"Library/LaunchDaemons"
+        else
+          false
+        end
+      end
+
+      def launchr_default_boot
+        Pathname.new("~/Library/Preferences/#{Launchr.label}.default-boot").expand_path
+      end
+
+      def launchr_bin
+        Pathname.new(LAUNCHR_BIN).expand_path
+      end
+
+      def launchr_root
+        launchr_bin.dirname.parent
+      end
+
+      def launchr_version
+        launchr_root+"VERSION"
+      end
+
+      def cwd_homebrew_prefix
+        case @cwd_homebrew_prefix
+        when nil
+          Pathname.pwd.ascend do |path|
+            if (path+"/Library/Homebrew").exist?
+              @cwd_homebrew_prefix = path
+              break
+            end
+          end
+          @cwd_homebrew_prefix ||= false
+        else
+          @cwd_homebrew_prefix
+        end
+      end
+
+      # Same as Kernel.const_defined?, except it works for global constants
+      def global_const_defined? string
+        begin
+          eval string
+          true
+        rescue NameError
+          false
+        end
+      end
+
+      def bin_homebrew_prefix
+        case @bin_homebrew_prefix
+        when nil
+          if global_const_defined?("HOMEBREW_PREFIX")
+            @bin_homebrew_prefix = HOMEBREW_PREFIX
+          elsif launchr_root.include?("Cellar/launchr")
+            @bin_homebrew_prefix = Pathname.new(launchr_root.to_s.gsub(/\/Cellar\/launchr.*$/,""))
+          end
+
+          @bin_homebrew_prefix ||= false
+        else
+          @bin_homebrew_prefix
+        end
+      end
+
+      def homebrew_prefix
+        # cwd_homebrew_prefix || bin_homebrew_prefix
+        bin_homebrew_prefix
+      end
+
+      def chown_down path
+        if Launchr.superuser?
+          FileUtils.chown_R Launchr.user, Launchr.group, path.to_s
+        end
+      end
+
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+