makitzo 0.1.2

data/lib/makitzo/ssh/commands/apple.rb

@@ -0,0 +1,104 @@
+module Makitzo; module SSH; module Commands
+  module Apple
+    def mount_dmg(path)
+      mount_status = exec("hdiutil attach -puppetstrings #{x(path)}")
+      if mount_status.error?
+        logger.warn("unable to mount #{path}")
+        false
+      else
+        mount_status.stdout.split("\n").reverse.each do |line|
+          chunks = line.split(/\t+/)
+          if chunks.length == 3
+            mount_point = chunks[2].strip
+            unless mount_point.empty?
+              logger.success("#{path} mounted at #{mount_point}")
+              return mount_point
+            end
+          end
+        end
+        true
+      end
+    end
+    
+    def unmount_dmg(path)
+      unmount_status = exec("hdiutil detach #{x(path)}")
+      if unmount_status.error?
+        logger.warn("unable to unmount #{path}")
+        false
+      else
+        logger.success("#{path} unmounted")
+        true
+      end
+    end
+    
+    def install_app(app, target = '/Applications', backup_file = nil)
+      target_dir = File.join(target, File.basename(app))
+      exec("test -d #{x(target_dir)} && rm -rf #{x(target_dir)}")
+      if exec("cp -R #{x(app)} #{x(target)}").success?
+        logger.success("app #{app} installed to #{target}")
+        true
+      else
+        logger.warn("failed to install #{app} to #{target}")
+        false
+      end
+    end
+    
+    def install_pkg(pkg)
+      if exec("installer -pkg #{x(pkg)} -target /").success?
+        logger.success("package #{pkg} installed to /")
+        true
+      else
+        logger.warn("failed to install package #{pkg}")
+        false
+      end
+    end
+    
+    def shutdown_at(time)
+      sudo do
+        unless exec("pmset schedule shutdown \"#{time}\"").success?
+          logger.error("couldn't set poweroff time")
+          return false
+        end
+      end
+      true
+    end
+    
+    # format of restart_time is mm/dd/yy HH:MM:ss
+    def shutdown(restart_time = nil)
+      sudo do
+        if restart_time
+          res = exec("pmset schedule poweron \"#{restart_time}\"")
+          unless res.success?
+            logger.error("couldn't set restart time")
+            return false
+          end
+        end
+        res = exec("shutdown -h now")
+        res.success?
+      end
+    end
+    
+    def daily_shutdown
+      tomorrow = Time.now + 86400
+      shutdown(time.strftime("%m/%d/%y 08:45:00"))
+    end
+    
+    def reboot
+      sudo { exec('reboot') }
+    end
+    
+    def serial_number
+      res = exec("system_profiler SPHardwareDataType | grep 'Serial Number' | awk '{ print $4; }'")
+      res.success? ? res.stdout.strip : nil
+    end
+    
+    def use_network_time_server(address)
+      sudo do
+        exec!("systemsetup -setnetworktimeserver \"#{x(address)}\"")
+        exec!("systemsetup -setusingnetworktime on")
+      end
+    end
+    
+    bangify :mount_dmg, :unmount_dmg, :install_app, 'Makitzo::SSH::CommandFailed'
+  end
+end; end; end

data/lib/makitzo/ssh/commands/file_system.rb

@@ -0,0 +1,59 @@
+module Makitzo; module SSH; module Commands
+  module FileSystem
+    
+    #
+    # Predicates... these never log extra info
+    
+    def which?(executable)
+      exec("which #{executable}").success?
+    end
+    
+    def dir_exists?(dir)
+      exec("test -d #{dir}").success?
+    end
+    
+    
+    def cd(dir)
+      exec("cd #{x(dir)}")
+    end
+    
+    def mv(source, destination)
+      exec("mv #{x(source)} #{x(destination)}").success?
+    end
+    
+    # Ensure a directory exists.
+    # Log and raise CommandFailed otherwise
+    def require_dir!(dir, friendly_name = nil)
+      friendly_name ||= dir
+      unless dir_exists?(dir)
+        logger.error "#{friendly_name} (#{dir}) is not a directory"
+        raise CommandFailed
+      end
+    end
+    
+    # Check that a directory exists and attempt to create it if missing
+    # Log and raise CommandFailed if can't create dir
+    def find_or_create_dir!(directory, friendly_name = nil)
+      friendly_name ||= directory
+      if !dir_exists?(directory)
+        mkdir = exec("mkdir -p #{directory}")
+        if mkdir.error?
+          logger.error "Failed to create #{friendly_name} (#{directory})"
+          raise CommandFailed
+        else
+          logger.success "#{friendly_name} directory created"
+        end
+      else
+        logger.success "#{friendly_name} directory located"
+      end
+    end
+    
+    def rm_rf!(directory, friendly_name = nil)
+      friendly_name ||= directory
+      if exec("rm -rf #{directory}").error?
+        logger.error "could not delete #{friendly_name} (#{directory})"
+        raise CommandFailed
+      end
+    end
+  end
+end; end; end

data/lib/makitzo/ssh/commands/file_transfer.rb

@@ -0,0 +1,9 @@
+module Makitzo; module SSH; module Commands
+  module FileTransfer
+    def scp_upload(local_path, remote_path)
+      logger.info "scp: '#{local_path}' -> '#{remote_path}'"
+      scp = Net::SCP.new(connection)
+      scp.upload!(local_path, remote_path)
+    end
+  end
+end; end; end

data/lib/makitzo/ssh/commands/http.rb

@@ -0,0 +1,51 @@
+module Makitzo; module SSH; module Commands
+  module HTTP
+    
+    # downloads a url -> path, using either curl or wget
+    # logs a warning if neither is present
+    # TODO: hosts/roles should be able to specify their preferred d/l mechanism
+    def download(url, path)
+      if which?("curl")
+        download_with_curl(url, path)
+      elsif which?("wget")
+        download_with_wget(url, path)
+      else
+        logger.warn("failed: download #{url} -> #{path} (curl/wget not found)")
+        false
+      end
+    end
+    
+    # downloads url and saves in path, using either curl or wget
+    # raises CommandFailed if download fails
+    def download!(url, path)
+      raise CommandFailed unless download(url, path)
+    end
+    
+    # downloads url and saves to path, using curl
+    # logs success/failure message
+    def download_with_curl(url, path)
+      result = exec("curl -o #{path} -f #{url}")
+      if result.success?
+        logger.success("download #{url} -> #{path} (curl)")
+        true
+      else
+        logger.warn("failed: download #{url} -> #{path} (curl)")
+        false
+      end
+    end
+    
+    def download_with_wget(url, path)
+      result = exec("wget -o #{path} -- #{url}")
+      if result.success?
+        logger.success("download #{url} -> #{path} (wget)")
+        true
+      else
+        logger.warn("failed: download #{url} -> #{path} (wget)")
+        false
+      end
+    end
+    
+    bangify :download_with_curl, :download_with_wget
+    
+  end
+end; end; end

data/lib/makitzo/ssh/commands/makitzo.rb

@@ -0,0 +1,46 @@
+module Makitzo; module SSH; module Commands
+  module Makitzo
+    def makitzo_install
+      root = host.root!
+      if makitzo_install_check
+        logger.success("Makitzo already installed")
+      else
+        find_or_create_dir!(root, 'Makitzo root')
+        find_or_create_dir!(host.migration_history_dir, 'migration history directory')
+        exec!("echo COMPLETE > #{host.install_file}")
+        logger.success("Install successful")
+      end
+      logger.overall_success!
+    rescue CommandFailed => e
+      logger.error "installation aborted"
+    end
+    
+    def makitzo_uninstall
+      root = host.root!
+      if root.length <= 1
+        logger.error "failsafe! I won't remove this directory: #{root}"
+        next
+      end
+      require_dir!(root, 'Makitzo root')
+      rm_rf!(root, 'Makitzo root')
+      logger.success("uninstall successful")
+      logger.overall_success!
+    rescue CommandFailed => e
+      logger.error "uninstallation aborted"
+    end
+    
+    def makitzo_install_check
+      result = exec("cat #{host.install_file}")
+      return result.success? && result.stdout.strip == 'COMPLETE'
+    end
+    
+    def makitzo_install_check!
+      unless makitzo_install_check
+        logger.error "Makitzo is not installed on this system"
+        raise CommandFailed
+      else
+        true
+      end
+    end
+  end
+end; end; end

data/lib/makitzo/ssh/commands/ruby.rb

@@ -0,0 +1,18 @@
+module Makitzo; module SSH; module Commands
+  module Ruby
+    def ruby_version
+      ruby_version_check = exec("#{host.read_merged(:ruby_command) || 'ruby'} -v")
+      if ruby_version_check.error?
+        logger.warn "Ruby executable '#{host.ruby_command}' not found"
+        false
+      else
+        logger.success "Ruby executable located"
+        true
+      end
+    end
+    
+    def require_ruby!
+      raise CommandFailed unless ruby_version
+    end
+  end
+end; end; end

data/lib/makitzo/ssh/commands/unix.rb

@@ -0,0 +1,7 @@
+module Makitzo; module SSH; module Commands
+  module Unix
+    def killall(process_name)
+      exec("killall #{x(process_name)}")
+    end
+  end
+end; end; end

data/lib/makitzo/ssh/context.rb

@@ -0,0 +1,91 @@
+module Makitzo; module SSH
+  class Context
+    def self.protected_context_methods
+      %w(x exec sudo host connection logger) + Migrations::Migration.protected_context_methods
+    end
+    
+    attr_reader :host
+    attr_reader :connection
+    attr_accessor :connection_error
+    
+    def initialize(host, connection)
+      @host, @connection = host, connection
+    end
+    
+    def logger
+      @logger ||= (connection[:logger] || Logging::Blackhole.new)
+    end
+    
+    # escape an argument for use in shell
+    # http://stackoverflow.com/questions/1306680/shellwords-shellescape-implementation-for-ruby-1-8
+    def x(arg)
+      arg = arg.strip
+      return "''" if arg.empty?
+      arg.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+      arg.gsub!(/\n/, "'\n'")
+      arg
+    end
+    
+    def quote(arg)
+      "#{x(arg)}"
+    end
+
+    # wrapper to connection.exec2!
+    # generates necessary sudo command if we're in a sudo block
+    # returns a status object with various useful data about command (output, status code)
+    def exec(command, options = {})
+      log_command = true
+
+      if @sudo
+        password = @sudo[:password] || host.read_merged(:sudo_password)
+        user     = @sudo[:user]
+        group    = @sudo[:group]
+
+        sudo  = "sudo"
+
+        # TODO: if user/group is spec'd as int (ID), prefix it with #
+        sudo << " -u #{x(user)}" if user
+        sudo << " -g #{x(group)}" if group
+
+        log_sudo = sudo
+
+        if password
+          sudo = "echo #{x(password)} | #{sudo} -S --"
+          log_sudo = "echo [PASSWORD REMOVED] | #{log_sudo} -S --"
+        end
+
+        log_command = "#{log_sudo} #{command}"
+        command = "#{sudo} #{command}"
+      end
+
+      connection.exec2!(command, {:log => log_command}.update(options))
+    end
+    
+    def exec!(command, options = {})
+      res = exec(command, options)
+      raise CommandFailed unless res.success?
+    end
+
+    def sudo(options = {})
+      raise "can't nest calls to sudo with different options" if (@sudo && (@sudo != options))
+      begin
+        @sudo = options
+        yield if block_given?
+        # reset sudo timestamp so password will be required next time
+        connection.exec2!("sudo -k")
+      ensure
+        @sudo = nil
+      end
+    end
+
+    include Commands::Apple
+    include Commands::FileSystem
+    include Commands::FileTransfer
+    include Commands::HTTP
+    include Commands::Ruby
+    include Commands::Unix
+    include Commands::Makitzo
+
+    include Migrations::Commands
+  end
+end; end

data/lib/makitzo/ssh/multi.rb

@@ -0,0 +1,79 @@
+module Makitzo
+  module SSH
+    # mixing providing ability to run multiple SSH connections in parallel.
+    # clients mixing in this module should also include ApplicationAware,
+    # or provide +config+ and +logger+ methods.
+    module Multi
+      # connect to an array of hosts, returning an array of arrays.
+      # each array has the form [host, connection, error]
+      # only one of connection and error will be non-nil
+      def multi_connect(hosts, &block)
+        connection_threads = hosts.map { |h|
+          Thread.new do
+            begin
+              ssh_options = {}
+            
+              password = h.read_merged(:ssh_password)
+              ssh_options[:password] = password if password
+
+              timeout = h.read_merged(:ssh_timeout)
+              ssh_options[:timeout] = timeout if timeout
+            
+              [h, Net::SSH.start(h.name, h.read_merged(:ssh_username), ssh_options), nil]
+            rescue => e
+              [h, nil, e]
+            end
+          end
+        }
+        connection_threads.map(&:value)
+      end
+      
+      # execute a block on each host, in parallel
+      # block receives host, connection object and error object
+      # only one of connection, error will be non-nil
+      # returns after block has finished executing on all hosts
+      # returns array of block return values for each host
+      def multi_ssh(hosts, &block)
+        result = []
+        groups = config.concurrency.nil? ? [hosts] : (hosts.in_groups_of(config.concurrency))
+        groups.each do |hosts|
+          group_result = multi_connect(hosts).map { |host, conn, error|
+            conn[:logger] = logger if conn # ick?
+            Thread.new { block.call(host, conn, error) }
+          }.map(&:value)
+          group_result.each { |gr| result << gr }
+        end
+        result
+      end
+      
+      def multi_session(hosts, &block)
+        context_klass = ssh_context_class
+        
+        multi_ssh(hosts) do |host, conn, error|
+          context = context_klass.new(host, conn)
+          logger.with_host(host) do
+            if error
+              logger.error("could not connect to host: #{error.class}")
+              context.connection_error = error
+            else
+              begin
+                block.call(context, host)
+              rescue => e
+                logger.error("unhandled exception: #{e.class} (#{e.message})")
+              ensure
+                conn.close unless conn.closed?
+              end
+            end
+          end
+          context
+        end
+      end
+      
+      def ssh_context_class
+        session_klass = Class.new(Makitzo::SSH::Context)
+        session_klass.send(:include, config.helpers)
+        session_klass
+      end
+    end
+  end
+end

data/lib/makitzo/store/mysql.rb

@@ -0,0 +1,176 @@
+require 'mysql2'
+
+module Makitzo; module Store
+  class MySQL
+    attr_accessor :host, :port, :socket, :username, :password, :database
+    
+    def initialize(config = {})
+      config.each { |k,v| send(:"#{k}=", v) }
+      @mutex = Mutex.new
+    end
+    
+    def open(&block)
+      connect!
+      begin
+        yield if block_given?
+      ensure
+        cleanup!
+      end
+    end
+    
+    def read(host, key)
+      sync do
+        @client.query("SELECT * FROM #{key_value_table} WHERE hostname = #{qs(host)} AND `key` = #{qs(key)}", :cast_booleans => true).each do |r|
+          return row_value(r)
+        end
+        nil
+      end
+    end
+    
+    def write(host, key, value)
+      value_hash = {
+        'value_int'       => 'NULL',
+        'value_float'     => 'NULL',
+        'value_date'      => 'NULL',
+        'value_datetime'  => 'NULL',
+        'value_boolean'   => 'NULL',
+        'value_string'    => 'NULL'
+      }
+      
+      case value
+      when Fixnum                 then  value_hash['value_int'] = value.to_s
+      when Float                  then  value_hash['value_float'] = value.to_s
+      when DateTime, Time         then  value_hash['value_datetime'] = qs(value.strftime("%Y-%m-%dT%H:%M:%S"))
+      when Date                   then  value_hash['value_date'] = qs(value.strftime("%Y-%m-%d"))
+      when TrueClass, FalseClass  then  value_hash['value_boolean'] = value ? '1' : '0'
+      when NilClass               then  ; # do nothing
+      else                              value_hash['value_string'] = qs(value)
+      end
+      
+      sync do
+        @client.query("
+          REPLACE INTO #{key_value_table}
+            (hostname, `key`, value_int, value_float, value_date, value_datetime, value_boolean, value_string)
+          VALUES
+            (#{qs(host)}, #{qs(key)}, #{value_hash['value_int']}, #{value_hash['value_float']},
+             #{value_hash['value_date']}, #{value_hash['value_datetime']}, #{value_hash['value_boolean']},
+             #{value_hash['value_string']})
+        ")
+      end
+    end
+    
+    def read_all(host, *keys)
+      out = [keys].flatten.inject({}) { |hsh,k| hsh[k.to_s] = nil; hsh }
+      sync do
+        @client.query("SELECT * FROM #{key_value_table} WHERE hostname = #{qs(host)} AND `key` IN (#{out.keys.map { |k| qs(k) }.join(', ')})", :cast_booleans => true).each do |r|
+          out[r['key']] = row_value(r)
+        end
+      end
+      out
+    end
+    
+    def write_all(host, hash)
+      sync do
+        hash.each { |k,v| write(host, k, v) }
+      end
+    end
+    
+    def mark_migration_as_applied(host, migration)
+      sync do
+        @client.query("REPLACE INTO #{migrations_table} (hostname, migration_id) VALUES (#{qs(host)}, #{migration.to_i})")
+      end
+    end
+    
+    def unmark_migration_as_applied(host, migration)
+      sync do
+        @client.query("DELETE FROM #{migrations_table} WHERE hostname = #{qs(host)} AND migration_id = #{migration.to_i}")
+      end
+    end
+    
+    def applied_migrations_for_all_hosts
+      sync do
+        @client.query("SELECT * FROM #{migrations_table} ORDER BY migration_id ASC").inject({}) do |m,r|
+          (m[r['hostname']] ||= []) << r['migration_id']
+          m
+        end
+      end
+    end
+    
+    def applied_migrations_for_host(host)
+      sync do
+        @client.query("SELECT migration_id FROM #{migrations_table} WHERE hostname = #{qs(host)} ORDER BY migration_id ASC").inject([]) do |m,r|
+          m << r['migration_id']
+        end
+      end
+    end
+    
+    private
+    
+    def sync(&block)
+      @mutex.synchronize(&block)
+    end
+    
+    def row_value(r)
+      r['value_int'] || r['value_float'] || r['value_string'] || r['value_date'] || r['value_datetime'] || r['value_boolean']
+    end
+    
+    def qs(str)
+      "'#{@client.escape(str.to_s)}'"
+    end
+    
+    def connect!
+      @client = Mysql2::Client.new(connection_hash)
+      create_tables! unless tables_exist?
+    end
+    
+    def cleanup!
+      @client.close if @client
+    end
+    
+    def connection_hash
+      %w(host port socket username password database).inject({}) { |m,k| m[k.to_sym] = send(k); m }
+    end
+    
+    def migrations_table
+      "makitzo_applied_migrations"
+    end
+    
+    def key_value_table
+      "makitzo_key_values"
+    end
+    
+    def tables_exist?
+      (@client.query("SHOW TABLES").map { |r| r.values.first } & [migrations_table, key_value_table]).length == 2
+    end
+    
+    def create_tables!
+      @client.query("DROP TABLE IF EXISTS #{migrations_table}")
+      @client.query("DROP TABLE IF EXISTS #{key_value_table}")
+      
+      sql = <<-SQL
+        CREATE TABLE `#{migrations_table}` (
+          `hostname` varchar(255) NOT NULL,
+          `migration_id` int(11) NOT NULL,
+          `hash` varchar(255) NULL,
+          PRIMARY KEY (`hostname`,`migration_id`)
+        ) ENGINE=InnoDB
+      SQL
+      @client.query(sql)
+      
+      sql = <<-SQL
+        CREATE TABLE `#{key_value_table}` (
+          `hostname` varchar(255) NOT NULL,
+          `key` varchar(255) NOT NULL,
+          `value_int` int(11) DEFAULT NULL,
+          `value_float` float DEFAULT NULL,
+          `value_string` varchar(255) DEFAULT NULL,
+          `value_date` date DEFAULT NULL,
+          `value_datetime` datetime DEFAULT NULL,
+          `value_boolean` tinyint(1) DEFAULT NULL,
+          PRIMARY KEY (`hostname`,`key`)
+        ) ENGINE=InnoDB
+      SQL
+      @client.query(sql)
+    end
+  end
+end; end

data/lib/makitzo/store/skeleton.rb

@@ -0,0 +1,46 @@
+module Makitzo; module Store
+  # Stores record persistent host state data including applied migrations and
+  # arbitrary key-value pairs.
+  #
+  # This is an interface definition for a store backend. It is not necessary to
+  # extend this class, but all methods must be implemented.
+  # 
+  # All operations must raise ::Makitzo::Store::OperationFailedError on failure.
+  class Skeleton
+    def open(&block)
+      raise
+    end
+    
+    def read(host, key)
+      raise
+    end
+    
+    def write(host, key, value)
+      raise
+    end
+    
+    def read_all(host, *keys)
+      raise
+    end
+    
+    def write_all(host, hash)
+      raise
+    end
+    
+    def mark_migration_as_applied(host, migration)
+      raise
+    end
+    
+    def unmark_migration_as_applied(host, migration)
+      raise
+    end
+    
+    def applied_migrations_for_all_hosts
+      raise
+    end
+    
+    def applied_migrations_for_host(host)
+      raise
+    end
+  end
+end; end