bixby-provision 0.1.0

data/lib/bixby/provision/dsl/packager/yum/mongodb.rb

@@ -0,0 +1,43 @@
+
+module Bixby
+  module Provision
+    module Packager
+      class Yum < PackagerBase
+
+        module MongoDB
+
+          private
+
+          def install_mongodb(opts)
+
+            file = File.join(YUM_REPOS_D, "mongodb.repo")
+            if File.exists?(file) then
+              logger.info "[yum] mongodb repo already installed"
+              return
+            end
+
+            logger.info "[yum] installing mongodb repo"
+
+            arch = amd64?() ? "x86_64" : "i686"
+
+            File.open(file, 'w') do |f|
+              f.puts <<-EOF
+[mongodb]
+name=MongoDB Repository
+baseurl=http://downloads-distro.mongodb.org/repo/redhat/os/#{arch}/
+gpgcheck=0
+enabled=1
+EOF
+            end
+
+            true
+          end
+
+        end # MongoDB
+
+        Yum.register_plugin(MongoDB)
+
+      end
+    end
+  end
+end

data/lib/bixby/provision/dsl/ruby.rb

@@ -0,0 +1,21 @@
+
+module Bixby
+  module Provision
+
+    class Ruby < Base
+
+      EXPORTS = [:gem]
+
+      def install(opts={})
+        logger.info "ruby.install"
+      end
+
+      def gem(name, opts={})
+      end
+
+    end
+
+    register_dsl Ruby
+
+  end
+end

data/lib/bixby/provision/dsl/run_control.rb

@@ -0,0 +1,49 @@
+
+module Bixby
+  module Provision
+
+    class RunControl < Base
+
+      EXPORTS = [:first_boot]
+
+      def first_boot(&block)
+        if first_boot_has_run? then
+          logger.info "first_boot already ran"
+          return
+        end
+
+        logger.info "running first_boot block"
+        begin
+          block.call
+        rescue Exception => ex
+          # TODO fail!
+          raise ex
+          return
+        end
+
+        touch_first_boot_state
+      end
+
+
+      private
+
+      def first_boot_has_run?
+        File.exists?(first_boot_state)
+      end
+
+      def first_boot_state
+        Bixby.path("var", "provision", "first_boot")
+      end
+
+      def touch_first_boot_state
+        f = first_boot_state
+        FileUtils.mkdir_p(File.dirname(f))
+        FileUtils.touch(f)
+      end
+
+    end
+
+    register_dsl RunControl, "run_control"
+
+  end
+end

data/lib/bixby/provision/dsl/scm.rb

@@ -0,0 +1,34 @@
+
+require "bixby/provision/dsl/scm/base"
+require "bixby/provision/dsl/scm/git"
+require "bixby/provision/dsl/scm/svn"
+
+module Bixby
+  module Provision
+
+    class SCM < Base
+
+      EXPORTS = [:checkout]
+
+      def checkout(uri, opts={})
+        handler(uri).checkout(uri, opts)
+      end
+
+
+      private
+
+      def handler(uri)
+        @handler ||= if uri =~ %r{\.git$} then
+            SCM::Git.new(self)
+          else
+            # TODO add check
+            SCM::SVN.new(self)
+          end
+      end
+
+    end
+
+    register_dsl SCM
+
+  end
+end

data/lib/bixby/provision/dsl/scm/base.rb

@@ -0,0 +1,11 @@
+
+module Bixby
+  module Provision
+    class SCM < Base
+
+      class SCMBase < Base
+      end
+
+    end
+  end
+end

data/lib/bixby/provision/dsl/scm/git.rb

@@ -0,0 +1,89 @@
+
+require "git"
+
+module Bixby
+  module Provision
+    class SCM < Base
+
+      class Git < SCMBase
+
+        def checkout(uri, opts)
+          path   = opts.delete(:path)
+          branch = opts.delete(:branch) || "master"
+
+          if path.nil? then
+            # TODO raise
+          end
+          path = File.expand_path(path)
+          if File.directory? File.join(path, ".git") then
+            logger.info "repository already checked out at #{path}"
+            return
+          end
+          dir.create(path)
+
+          # https://github.com/user/repo.git
+          # git@github.com:user/repo.git
+          # ssh://hg@bitbucket.org/user/repo
+          if uri !~ %r{https?://} && uri =~ %r{^(ssh://)?(.*?@)(.*?)[:/]} then
+            ensure_ssh_verify($3)
+          end
+
+          sys.package "git"
+
+          logger.info "[scm] cloning #{uri} into #{path}, branch: #{branch}"
+          g = ::Git.clone(uri, File.basename(path), :path => File.dirname(path))
+          g.checkout(branch) if branch != "master"
+        end
+
+
+        private
+
+        # Ensure that StrictHostKeyChecking is disabled for the given host
+        #
+        # @param [String] host
+        def ensure_ssh_verify(host)
+
+          config = File.expand_path("~/.ssh/config")
+          str = ""
+          str = File.read(config) if File.exists? config
+
+          add = str.empty?
+          if !add then
+            # see if it's already disabled for the given host
+            found_host = false
+            found_strict = false
+            str.split(/n/).each do |l|
+
+              if l =~ /^\s*Host (.*?)/ then
+                if found_host then
+                  add = true if !found_strict
+                  found_host = false
+                  next
+                end
+                if $1 == host then
+                  found_host = true
+                end
+
+              elsif found_host && l =~ /StrictHostKeyChecking \s*no/ then
+                found_strict = true
+              end
+            end
+          end
+
+          return if !add
+
+          logger.info "[scm] disabling StrictHostKeyChecking for #{host}"
+          str += "\n"
+          str += "Host #{host}\n"
+          str += "  StrictHostKeyChecking no\n"
+
+          dir.mkdir "~/.ssh", :chmod => "700"
+          File.open(config, 'w'){ |f| f.write(str) }
+          chmod config, "644"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bixby/provision/dsl/scm/svn.rb

@@ -0,0 +1,11 @@
+
+module Bixby
+  module Provision
+    class SCM < Base
+
+      class SVN < SCMBase
+      end
+
+    end
+  end
+end

data/lib/bixby/provision/dsl/service.rb

@@ -0,0 +1,56 @@
+
+require "bixby/provision/dsl/services/base"
+require "bixby/provision/dsl/services/init"
+
+module Bixby
+  module Provision
+
+    class Service < Base
+
+      def initialize(*args)
+        super
+        @services = if ubuntu? then
+            Services::Init.new(self)
+          elsif centos? or amazon? then
+            Services::Init.new(self)
+          end
+      end
+
+      def start(name, opts={})
+        if !running?(name) || opts[:force] == true then
+          @services.start(name, opts)
+        end
+      end
+
+      def stop(name, opts={})
+        if running?(name) || opts[:force] == true then
+          @services.stop(name, opts)
+        end
+      end
+
+      def restart(name, opts={})
+        @services.restart(name, opts)
+      end
+
+      def reload(name, opts={})
+        @services.reload(name, opts)
+      end
+
+      def running?(name)
+        @services.running?(name)
+      end
+
+      def ensure(name)
+        if centos? or amazon? then
+          logged_sudo("chkconfig --add #{name}")
+        elsif ubuntu? then
+          logged_sudo("update-rc.d #{name} defaults")
+        end
+      end
+
+    end
+
+    register_dsl Service
+
+  end
+end

data/lib/bixby/provision/dsl/services/base.rb

@@ -0,0 +1,11 @@
+
+module Bixby
+  module Provision
+    module Services
+
+      class ServiceBase < Base
+      end
+
+    end
+  end
+end

data/lib/bixby/provision/dsl/services/init.rb

@@ -0,0 +1,40 @@
+
+module Bixby
+  module Provision
+    module Services
+
+      class Init < ServiceBase
+
+        def start(name, opts={})
+          init("#{name} start")
+        end
+
+        def stop(name, opts={})
+          init("#{name} stop")
+        end
+
+        def restart(name, opts={})
+          init("#{name} restart")
+        end
+
+        def reload(name, opts={})
+          init("#{name} reload")
+        end
+
+        def running?(name)
+          cmd = init("#{name} status")
+          return cmd.success? # exit 0 means it's running (usually.. hopefully!)
+        end
+
+
+        private
+
+        def init(args)
+          logged_sudo("/etc/init.d/#{args}")
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bixby/provision/dsl/system.rb

@@ -0,0 +1,53 @@
+
+require "bixby/provision/dsl/packager/base"
+require "bixby/provision/dsl/packager/apt"
+require "bixby/provision/dsl/packager/yum"
+require "bixby/provision/dsl/packager/npm"
+
+module Bixby
+  module Provision
+
+    class System < Base
+
+      EXPORTS = [:refresh_packages, :upgrade_system, :package, :repo]
+
+      attr_reader :packager
+
+      def initialize(*args)
+        super
+        @packager = if ubuntu? then
+          Packager::Apt.new(self)
+        elsif centos? or amazon? then
+          Packager::Yum.new(self)
+        end
+      end
+
+      def refresh_packages
+        logger.info "[sys] refresh_packages"
+        packager.refresh
+      end
+
+      def upgrade_system
+        logger.info "[sys] upgrade_system"
+        packager.upgrade_system
+      end
+
+      def package(*packages)
+        packages.flatten!
+        logger.info "[sys] installing packages: " + packages.join(" ")
+        packager.install(*packages)
+      end
+      alias_method :packages, :package
+
+      def repo(name, opts={})
+        if packager.install_repo(name, opts) then
+          refresh_packages
+        end
+      end
+
+    end
+
+    register_dsl System, "sys"
+
+  end
+end

data/lib/bixby/provision/dsl/util/file.rb

@@ -0,0 +1,100 @@
+
+module Bixby
+  module Provision
+    module Util
+      module File
+
+        def chown(path, chown, opts={})
+          if chown.nil? then
+            return
+          end
+          chown.strip!
+          return if chown.empty?
+
+          user, group = chown.split(/:/)
+          user = Process.uid if user == "$USER"
+          group = Process.gid if group == "$GROUP"
+          uid = get_uid(user)
+          gid = get_gid(group)
+
+          logger.info "[chown] #{path} -> '#{get_user(uid)}" + (gid ? ":#{get_group(gid)}'" : "'")
+
+          # always as root
+          if opts[:recurse] or opts[:recursively] then
+            logged_sudo("chown -R #{uid}:#{gid} #{path}")
+          else
+            logged_sudo("chown #{uid}:#{gid} #{path}")
+          end
+        end
+
+        # Change mode of the given path
+        #
+        # @param [String] path
+        # @param [String] mode        File mode given as a string, same as the input to the `chmod` command
+        def chmod(path, mode, opts={})
+          return if mode.nil?
+
+          if mode.kind_of? String then
+            mode.strip!
+            return if mode.empty?
+
+          elsif mode.kind_of? Fixnum then
+            # mode should always be a string
+            # convert fixnum to octal
+            mode = sprintf("%o", mode)
+            if mode.length > 4 then
+              # only want the right-most 4 chars
+              # ex: File.stat = mode=0100440 (file r--r-----) => 33056 => "100440" => "0440"
+              mode = mode[mode.length-4, mode.length]
+            end
+          end
+
+          logger.info "[chmod] #{path} -> '#{mode}'"
+
+          # always as root
+          if opts[:recurse] or opts[:recursively] then
+            logged_sudo("chmod -R #{mode} #{path}")
+          else
+            logged_sudo("chmod #{mode} #{path}")
+          end
+        end
+
+        # Get the SHA-256 hex digest of the given file
+        #
+        # @param [String] filename
+        #
+        # @return [String] sha256 hash in hexadecimal form
+        def sha256sum(filename)
+          if ::File.readable? filename then
+            return Digest::SHA2.new(256).file(filename).hexdigest()
+          end
+
+          # read as root
+          if cmd = which("sha256sum") then
+            return logged_sudo("#{cmd} #{filename}").stdout.split(/\s+/).first
+          end
+
+          # use cat - may not work for binaries
+          str = logged_sudo("cat #{filename}").stdout
+          return Digest::SHA2.new(256).update(str).hexdigest()
+        end
+
+        # Locate the given command, if it exists
+        #
+        # @param [String] cmd     to locate
+        #
+        # @return [String] path to command if it exists, or nil
+        def which(cmd)
+          ret = systemu("which #{cmd}")
+          if ret.success? then
+            return ret.stdout.strip
+          else
+            return nil
+          end
+        end
+        alias_method :command_exists?, :which
+
+      end
+    end
+  end
+end