dust-deploy 0.16.4 → 0.16.5

data/lib/dust/server/facter.rb

@@ -0,0 +1,33 @@
+require 'dust/server/ssh'
+require 'dust/server/osdetect'
+require 'dust/server/package'
+
+module Dust
+  class Server
+    # collect additional system facts using puppets facter
+    def collect_facts(options={})
+      options = default_options.merge(options)
+
+      # if facts already have been collected, just return
+      return true if @node['operatingsystem']
+
+      # check if lsb-release (on apt systems) and facter are installed
+      # and install them if not
+      if uses_apt? and not package_installed?('lsb-release', :quiet => true)
+        install_package('lsb-release', :quiet => false)
+      end
+
+      unless package_installed?('facter', :quiet => true)
+        return false unless install_package('facter', :quiet => false)
+      end
+
+      msg = messages.add("collecting additional system facts (using facter)", options)
+
+      # run facter with -y for yaml output, and merge results into @node
+      ret = exec('facter -y')
+      @node = YAML.load(ret[:stdout]).merge(@node)
+
+      msg.parse_result(ret[:exit_code])
+    end
+  end
+end

data/lib/dust/server/file.rb

@@ -0,0 +1,152 @@
+require 'erb'
+require 'tempfile'
+require 'dust/server/ssh'
+require 'dust/server/selinux'
+
+module Dust
+  class Server
+    def write(destination, content, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("deploying #{File.basename destination}", options)
+
+      f = Tempfile.new('dust-write')
+      f.print(content)
+      f.close
+
+      ret = msg.parse_result(scp(f.path, destination, :quiet => true))
+      f.unlink
+
+      ret
+    end
+
+    def append(destination, newcontent, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("appending to #{File.basename destination}", options)
+
+      content = exec("cat #{destination}")[:stdout]
+      content.concat(newcontent)
+
+      msg.parse_result(write(destination, content, :quiet => true))
+    end
+
+    # if file is a regular file, copy it using scp
+    # if it's an file.erb exists, render template and push to server
+    def deploy_file(file, destination, options={})
+      options = default_options(:binding => binding).merge(options)
+
+      if File.exists?(file)
+        scp(file, destination, options)
+
+      elsif File.exists?("#{file}.erb")
+        template = ERB.new( File.read("#{file}.erb"), nil, '%<>')
+        write(destination, template.result(options[:binding]), options)
+
+      else
+        messages.add("'#{file}' was not found.", options).failed
+      end
+    end
+
+    # create a temporary file
+    def mktemp(options={:type => 'file'})
+      if options[:type] == 'file'
+        ret = exec('mktemp --tmpdir dust.XXXXXXXXXX')
+      elsif options[:type] == 'directory'
+        ret = exec('mktemp -d --tmpdir dust.XXXXXXXXXX')
+      else
+        return messages.add("mktemp: unknown type '#{options[:type]}'").failed
+      end
+
+      return false if ret[:exit_code] != 0
+      ret[:stdout].chomp
+    end
+
+    def symlink(source, destination, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("symlinking #{File.basename source} to '#{destination}'", options)
+      ret = msg.parse_result(exec("ln -s #{source} #{destination}")[:exit_code])
+      restorecon(destination, options) # restore SELinux labels
+      ret
+    end
+
+    def chmod(mode, file, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("setting mode of #{File.basename file} to #{mode}", options)
+      msg.parse_result(exec("chmod -R #{mode} #{file}")[:exit_code])
+    end
+
+    def chown(user, file, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("setting owner of #{File.basename file} to #{user}", options)
+      msg.parse_result(exec("chown -R #{user} #{file}")[:exit_code])
+    end
+
+
+    def rm(file, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("deleting #{file}", options)
+      msg.parse_result(exec("rm -rf #{file}")[:exit_code])
+    end
+
+    def cp(source, destination, options={})
+      options = default_options.merge(options)
+
+      # get rid of overly careful aliases
+      exec 'unalias -a'
+
+      msg = messages.add("copying #{source} to #{destination}", options)
+      msg.parse_result(exec("cp -a #{source} #{destination}")[:exit_code])
+    end
+
+    def mv(source, destination, options={})
+      options = default_options.merge(options)
+
+      # get rid of overly careful aliases
+      exec 'unalias -a'
+
+      msg = messages.add("moving #{source} to #{destination}", options)
+      msg.parse_result(exec("mv #{source} #{destination}")[:exit_code])
+    end
+
+    def mkdir(dir, options={})
+      options = default_options.merge(options)
+
+      return true if dir_exists?(dir, :quiet => true)
+
+      msg = messages.add("creating directory #{dir}", options)
+      ret = msg.parse_result(exec("mkdir -p #{dir}")[:exit_code])
+      restorecon(dir, options) # restore SELinux labels
+      ret
+    end
+
+    def is_executable?(file, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("checking if file #{file} exists and is executeable", options)
+      msg.parse_result(exec("test -x $(which #{file})")[:exit_code])
+    end
+
+    def file_exists?(file, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("checking if file #{file} exists", options)
+
+      # don't treat directories as files
+      return msg.failed if dir_exists?(file, :quiet => true)
+
+      msg.parse_result(exec("test -e #{file}")[:exit_code])
+    end
+
+    def dir_exists?(dir, options={})
+      options = default_options.merge(options)
+
+      msg = messages.add("checking if directory #{dir} exists", options)
+      msg.parse_result(exec("test -d #{dir}")[:exit_code])
+    end
+  end
+end

data/lib/dust/server/osdetect.rb

@@ -0,0 +1,112 @@
+require 'dust/server/ssh'
+
+module Dust
+  class Server
+    # determining the system packet manager has to be done without facter
+    # because it's used to find out whether facter is installed / install facter
+    def uses_apt?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return @uses_apt if defined?(@uses_apt)
+      msg = messages.add('determining whether node uses apt', options)
+      @uses_apt = msg.parse_result(exec('test -e /etc/debian_version')[:exit_code])
+    end
+
+    def uses_rpm?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return @uses_rpm if defined?(@uses_rpm)
+      msg = messages.add('determining whether node uses rpm', options)
+      @uses_rpm = msg.parse_result(exec('test -e /etc/redhat-release')[:exit_code])
+    end
+
+    def uses_emerge?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return @uses_emerge if defined?(@uses_emerge)
+      msg = messages.add('determining whether node uses emerge', options)
+      @uses_emerge = msg.parse_result(exec('test -e /etc/gentoo-release')[:exit_code])
+    end
+
+    def uses_pacman?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return @uses_pacman if defined?(@uses_pacman)
+      msg = messages.add('determining whether node uses pacman', options)
+      @uses_pacman = msg.parse_result(exec('test -e /etc/arch-release')[:exit_code])
+    end
+
+    def uses_opkg?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return @uses_opkg if defined?(@uses_opkg)
+      msg = messages.add('determining whether node uses opkg', options)
+      @uses_opkg = msg.parse_result(exec('test -e /etc/opkg.conf')[:exit_code])
+    end
+
+    def is_os?(os_list, options={})
+      options = default_options(:quiet => true).merge(options)
+
+      msg = messages.add("checking if this machine runs #{os_list.join(' or ')}", options)
+      return msg.failed unless collect_facts options
+
+      os_list.each do |os|
+        if @node['operatingsystem'].downcase == os.downcase
+          return msg.ok
+        end
+      end
+
+      msg.failed
+      false
+    end
+
+    def is_debian?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_apt?
+      is_os?(['debian'], options)
+    end
+
+    def is_ubuntu?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_apt?
+      is_os?(['ubuntu'], options)
+    end
+
+    def is_gentoo?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_emerge?
+      is_os?(['gentoo'], options)
+    end
+
+    def is_centos?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_rpm?
+      is_os?(['centos'], options)
+    end
+
+    def is_scientific?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_rpm?
+      is_os?(['scientific'], options)
+    end
+
+    def is_fedora?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_rpm?
+      is_os?(['fedora'], options)
+    end
+
+    def is_arch?(options={})
+      options = default_options(:quiet => true).merge(options)
+
+      return false unless uses_pacman?
+      is_os?(['archlinux'], options)
+    end
+  end
+end

data/lib/dust/server/package.rb

@@ -0,0 +1,215 @@
+require 'dust/server/ssh'
+require 'dust/server/osdetect'
+
+module Dust
+  class Server
+    # checks if one of the packages is installed
+    def package_installed?(packages, options={})
+      options = default_options.merge(options)
+
+      packages = [ packages ] if packages.is_a?(String)
+
+      msg = messages.add("checking if #{packages.join(' or ')} is installed", options)
+
+      packages.each do |package|
+        if uses_apt?
+          return msg.ok if exec("dpkg -l #{package} |grep '^ii'")[:exit_code] == 0
+        elsif uses_emerge?
+          return msg.ok unless exec("qlist -I #{package}")[:stdout].empty?
+        elsif uses_rpm?
+          return msg.ok if exec("rpm -q #{package}")[:exit_code] == 0
+        elsif uses_pacman?
+          return msg.ok if exec("pacman -Q #{package}")[:exit_code] == 0
+        elsif uses_opkg?
+          return msg.ok unless exec("opkg status #{package}")[:stdout].empty?
+        end
+      end
+
+      msg.failed
+    end
+
+    def install_package(package, options={})
+      options = default_options.merge(options)
+      options[:env] ||= ''
+
+      if package_installed?(package, :quiet => true)
+        return messages.add("package #{package} already installed", options).ok
+      end
+
+      # if package is an url, download and install the package file
+      if package =~ /^(http:\/\/|https:\/\/|ftp:\/\/)/
+        if uses_apt?
+          messages.add("installing #{package}\n", options)
+          return false unless install_package('wget')
+
+          msg = messages.add('downloading package', options.merge(:indent => options[:indent] + 1))
+
+          # creating temporary file
+          tmpfile = mktemp
+          return msg.failed('could not create temporary file') unless tmpfile
+
+          msg.parse_result(exec("wget #{package} -O #{tmpfile}")[:exit_code])
+
+          msg = messages.add('installing package', options.merge(:indent => options[:indent] + 1))
+          ret = msg.parse_result(exec("dpkg -i #{tmpfile}")[:exit_code])
+
+          msg = messages.add('deleting downloaded file', options.merge(:indent => options[:indent] + 1))
+          msg.parse_result(rm(tmpfile, :quiet => true))
+
+          return ret
+
+        elsif uses_rpm?
+          msg = messages.add("installing #{package}", options)
+          return msg.parse_result(exec("rpm -U #{package}")[:exit_code])
+
+        else
+          return msg.failed("\ninstalling packages from url not yet supported " +
+                            "for your distribution. feel free to contribute!").failed
+        end
+
+      # package is not an url, use package manager
+      else
+        msg = messages.add("installing #{package}", options)
+
+        if uses_apt?
+          exec "DEBIAN_FRONTEND=noninteractive apt-get install -y #{package}"
+        elsif uses_emerge?
+          exec "#{options[:env]} emerge #{package}"
+        elsif uses_rpm?
+          exec "yum install -y #{package}"
+        elsif uses_pacman?
+          exec "echo y |pacman -S #{package}"
+        elsif uses_opkg?
+          exec "opkg install #{package}"
+        else
+          return msg.failed("\ninstall_package only supports apt, emerge and yum systems at the moment")
+        end
+
+        # check if package actually was installed
+        return msg.parse_result(package_installed?(package, :quiet => true))
+      end
+    end
+
+    # check if installed package is at least version min_version
+    def package_min_version?(package, min_version, options={})
+      msg = messages.add("checking if #{package} is at least version #{min_version}", options)
+      return msg.failed unless package_installed?(package, :quiet => true)
+
+      if uses_apt?
+        v = exec("dpkg --list |grep #{package}")[:stdout].chomp
+      elsif uses_rpm?
+        v = exec("rpm -q #{package}")[:stdout].chomp
+      elsif uses_pacman?
+        v = exec("pacman -Q #{package}")[:stdout].chomp
+      else
+        return msg.failed('os not supported')
+      end
+
+      # convert version numbers to arrays
+      current_version = v.to_s.split(/[-. ]/ ).select {|j| j =~ /^[0-9]+$/ }
+      min_version = min_version.to_s.split(/[-. ]/ ).select {|j| j =~ /^[0-9]+$/ }
+
+      # compare
+      min_version.each_with_index do |i, pos|
+        break unless current_version[pos]
+        return msg.failed if i.to_i < current_version[pos].to_i
+      end
+
+      msg.ok
+    end
+
+    def remove_package(package, options={})
+      options = default_options.merge(options)
+
+      unless package_installed?(package, :quiet => true)
+        return messages.add("package #{package} not installed", options).ok
+      end
+
+      msg = messages.add("removing #{package}", options)
+      if uses_apt?
+        msg.parse_result(exec("DEBIAN_FRONTEND=noninteractive apt-get purge -y #{package}")[:exit_code])
+      elsif uses_emerge?
+        msg.parse_result(exec("emerge --unmerge #{package}")[:exit_code])
+      elsif uses_rpm?
+        msg.parse_result(exec("yum erase -y #{package}")[:exit_code])
+      elsif uses_pacman?
+        msg.parse_result(exec("echo y |pacman -R #{package}")[:exit_code])
+      elsif uses_opkg?
+        msg.parse_result(exec("opkg remove #{package}")[:exit_code])
+      else
+        msg.failed
+      end
+    end
+
+    def update_repos(options={})
+      options = default_options.merge(options)
+
+      msg = messages.add('updating system repositories', options)
+
+      if uses_apt?
+        ret = exec('apt-get update', options)
+      elsif uses_emerge?
+        ret = exec('emerge --sync', options)
+      elsif uses_rpm?
+        ret = exec('yum check-update', options)
+
+        # yum returns != 0 if packages that need to be updated are found
+        # we don't want that this is producing an error
+        ret[:exit_code] = 0 if ret[:exit_code] == 100
+      elsif uses_pacman?
+        ret = exec('pacman -Sy', options)
+      elsif uses_opkg?
+        ret =  exec('opkg update', options)
+      else
+        return msg.failed
+      end
+
+      unless options[:live]
+        msg.parse_result(ret[:exit_code])
+      end
+
+      ret[:exit_code]
+    end
+
+    def system_update(options={})
+      options = default_options.merge(:live => true).merge(options)
+
+      update_repos
+
+      msg = messages.add('installing system updates', options)
+
+      if uses_apt?
+        ret = exec 'DEBIAN_FRONTEND=noninteractive apt-get full-upgrade -y', options
+        if is_ubuntu?
+          if install_package('update-manager-core')
+            ret = exec 'do-release-upgrade -d -f DistUpgradeViewNonInteractive', options
+          else
+            msg.failed('could not install the update-manager package')
+            return false
+          end
+        else
+          ret = exec 'DEBIAN_FRONTEND=noninteractive apt-get full-upgrade -y', options
+        end
+      elsif uses_emerge?
+        ret = exec('emerge -uND @world', options)
+      elsif uses_rpm?
+        ret = exec('yum upgrade -y', options)
+      elsif uses_pacman?
+        # pacman has no --yes option that i know of, so echoing y
+        ret = exec('echo y |pacman -Su', options)
+      elsif uses_opkg?
+        # upgrading openwrt is very experimental, and should not used normally
+        ret = exec('opkg upgrade $(echo $(opkg list-upgradable |cut -d' ' -f1 |grep -v Multiple))', options)
+      else
+        msg.failed('system not (yet) supported')
+        return false
+      end
+
+      unless options[:live]
+        msg.parse_result(ret[:exit_code])
+      end
+
+      ret[:exit_code]
+    end
+  end
+end