inprovise 0.2.2

data/lib/inprovise/helper/linux.rb

@@ -0,0 +1,181 @@
+# Linux Command helper for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+Inprovise::CmdHelper.define('linux') do
+
+  def initialize(channel, sudo=false)
+    super(channel)
+    @exec = sudo ? :sudo_run : :plain_run
+    @cwd = nil
+  end
+
+  # platform properties
+
+  def admin_user
+    'root'
+  end
+
+  def env_reference(varname)
+    "\$#{varname}"
+  end
+
+  def cwd
+    @cwd || plain_run('pwd').chomp
+  end
+
+  def set_cwd(path)
+    old_cwd = @cwd
+    @cwd = path ? File.expand_path(path, self.cwd) : path
+    old_cwd
+  end
+
+  # generic command execution
+
+  def run(cmd, forcelog=false)
+    cmd = "cd #{cwd}; #{cmd}" if @cwd
+    exec(cmd, forcelog)
+  end
+
+  def sudo
+    return self if @exec == :sudo_run
+    @sudo ||= self.class.new(@channel, true)
+  end
+
+  # file management
+
+  def upload(from, to)
+    @channel.upload(real_path(from), real_path(to))
+  end
+
+  def download(from, to)
+    @channel.download(real_path(from), real_path(to))
+  end
+
+  # basic commands
+
+  def echo(arg)
+    exec("echo #{arg}")
+  end
+
+  def cat(path)
+    path = real_path(path)
+    begin
+      @channel.content(path)
+    rescue
+      exec("cat #{path}")
+    end
+  end
+
+  def hash_for(path)
+    path = real_path(path)
+    exec("sha1sum #{path}")[0...40]
+  end
+
+  def mkdir(path)
+    path = real_path(path)
+    exec("mkdir -p #{path}")
+  end
+
+  def exists?(path)
+    path = real_path(path)
+    begin
+      @channel.exists?(path)
+    rescue
+      exec(%{if [ -f #{path} ]; then echo "true"; else echo "false"; fi}).strip == 'true'
+    end
+  end
+
+  def file?(path)
+    path = real_path(path)
+    begin
+      @channel.file?(path)
+    rescue
+      (exec("stat --format=%f #{path}").chomp.hex & 0x8000) == 0x8000
+    end
+  end
+
+  def directory?(path)
+    path = real_path(path)
+    begin
+      @channel.file?(path)
+    rescue
+      (exec("stat --format=%f #{path}").chomp.hex & 0x4000) == 0x4000
+    end
+  end
+
+  def copy(from, to)
+    exec("cp #{real_path(from)} #{real_path(to)}")
+  end
+
+  def delete(path)
+    path = real_path(path)
+    begin
+      @channel.delete(path)
+    rescue
+      exec("rm #{path}")
+    end
+  end
+
+  def permissions(path)
+    path = real_path(path)
+    begin
+      @channel.permissions(path)
+    rescue
+      exec("stat --format=%a #{path}").strip.to_i(8)
+    end
+  end
+
+  def set_permissions(path, perm)
+    path = real_path(path)
+    begin
+      @channel.set_permissions(path, perm)
+    rescue
+      exec("chmod -R #{sprintf("%o",perm)} #{path}")
+    end
+  end
+
+  def owner(path)
+    path = real_path(path)
+    begin
+      @channel.owner(path)
+    rescue
+      user, group = exec("stat --format=%U:%G #{path}").chomp.split(":")
+      {:user => user, :group => group}
+    end
+  end
+
+  def set_owner(path, user, group=nil)
+    path = real_path(path)
+    begin
+      @channel.set_owner(path, user, group)
+    rescue
+      exec(%{chown -R #{user}#{group ? ":#{group}" : ''} #{path}})
+    end
+  end
+
+  def binary_exists?(bin)
+    exec("which #{bin}") =~ /\/#{bin}/ ? true : false
+  end
+
+  private
+
+  def real_path(path)
+    return File.expand_path(path, @cwd) if @cwd
+    path
+  end
+
+  def exec(cmd, forcelog=false)
+    send(@exec, cmd, forcelog)
+  end
+
+  def plain_run(cmd, forcelog=false)
+    @channel.run(cmd, forcelog)
+  end
+
+  def sudo_run(cmd, forcelog=false)
+    @channel.run("sudo #{cmd}", forcelog)
+  end
+
+end

data/lib/inprovise/helper/windows.rb

@@ -0,0 +1,123 @@
+# Windows Command helper for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'digest/sha1'
+
+Inprovise::CmdHelper.define('windows') do
+
+  # platform properties
+
+  def admin_user
+    'administrator'
+  end
+
+  def env_reference(varname)
+    "%#{varname}%"
+  end
+
+  # generic command runution
+
+  def sudo
+    # not implemented yet
+    return self
+  end
+
+  # basic commands
+
+  def echo(arg)
+    run("echo #{arg}")
+  end
+
+  def cat(path)
+    begin
+      @channel.content(path)
+    rescue
+      run("type #{path}")
+    end
+  end
+
+  def hash_for(path)
+    Digest::SHA1.hexdigest(cat(path))
+  end
+
+  def mkdir(path)
+    run("mkdir #{path}")    # assumes CMD extensions are enabled
+  end
+
+  def exists?(path)
+    begin
+      @channel.exists?(path)
+    rescue
+      run(%{if exist #{path} ] (echo true) else (echo false)}).strip == 'true'
+    end
+  end
+
+  def file?(path)
+    begin
+      @channel.file?(path)
+    rescue
+      !run("for %p in (#{path}) do echo %~ap-").chomp.start_with?('d')
+    end
+  end
+
+  def directory?(path)
+    begin
+      @channel.file?(path)
+    rescue
+      run("for %p in (#{path}) do echo %~ap-").chomp.start_with?('d')
+    end
+  end
+
+  def copy(from, to)
+    run("copy #{from} #{to}")
+  end
+
+  def delete(path)
+    begin
+      @channel.delete(path)
+    rescue
+      run("del #{path}")
+    end
+  end
+
+  def permissions(path)
+    begin
+      @channel.permissions(path)
+    rescue
+      # not implemented yet
+      0
+    end
+  end
+
+  def set_permissions(path, perm)
+    begin
+      @channel.set_permissions(path, perm)
+    rescue
+      # not implemented yet
+    end
+  end
+
+  def owner(path)
+    begin
+      @channel.owner(path)
+    rescue
+      # not implemented yet
+      {:user => nil, :group => nil}
+    end
+  end
+
+  def set_owner(path, user, group=nil)
+    begin
+      @channel.set_owner(path, user, group)
+    rescue
+      # not implemented yet
+    end
+  end
+
+  def binary_exists?(bin)
+    run(%{for %p in (#{bin}) do (if exist "%~$PATH:p" echo %~$PATH:p)}).chomp =~ /#{bin}/ ? true : false
+  end
+
+end

data/lib/inprovise/infra.rb

@@ -0,0 +1,122 @@
+# Infrastructure basics for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'json'
+require 'monitor'
+
+module Inprovise::Infrastructure
+
+  # setup JSON parameters
+  JSON.load_default_options[:symbolize_names] = true
+  JSON.create_id = :json_class
+
+  class << self
+    def targets
+      @targets ||= Hash.new.extend(MonitorMixin)
+    end
+    private :targets
+
+    def find(name)
+      return name if name.is_a?(Target)
+      targets.synchronize do
+        return targets[name]
+      end
+    end
+
+    def names
+      targets.synchronize do
+        targets.keys.sort
+      end
+    end
+
+    def list(type=Target)
+      targets.synchronize do
+        targets.values.select {|t| type === t}
+      end
+    end
+
+    def register(tgt)
+      targets.synchronize do
+        raise ArgumentError, "Existing [#{targets[tgt.name].to_s}] found" if targets.has_key?(tgt.name)
+        targets[tgt.name] = tgt
+      end
+    end
+
+    def deregister(tgt)
+      targets.synchronize do
+        raise ArgumentError, "Invalid infrastructure target [#{tgt.to_s}]" unless targets.delete(Target === tgt ? tgt.name : tgt.to_s)
+        targets.each_value {|t| t.remove_target(tgt) }
+      end
+    end
+
+    def save
+      targets.synchronize do
+        data = []
+        targets.each_value {|t| t.is_a?(Node) ? data.insert(0,t) : data.push(t) }
+        File.open(Inprovise.infra, 'w') {|f| f << JSON.pretty_generate(data) }
+      end
+    end
+
+    def init(path)
+      File.open(path, 'w') {|f| f << JSON.pretty_generate([]) }
+    end
+
+    def load
+      targets.synchronize do
+        JSON.load(IO.read(Inprovise.infra)) if File.readable?(Inprovise.infra)
+      end
+    end
+  end
+
+  class Target
+    attr_reader :name, :config
+
+    def initialize(name, config = {})
+      @name = name
+      @config = config
+      Inprovise::Infrastructure.register(self)
+    end
+
+    def get(option)
+      config[option]
+    end
+
+    def set(option, value)
+      config[option.to_sym] = value
+    end
+
+    def add_to(grp)
+      grp.add_target(self)
+    end
+
+    def remove_from(grp)
+      grp.remove_target(self)
+    end
+
+    def add_target(tgt)
+      raise RuntimeError, "Cannot add #{tgt.to_s} to #{self.to_s}"
+    end
+
+    def remove_target(tgt)
+      # ignore
+    end
+
+    def includes?(tgt)
+      false
+    end
+
+    def targets
+      [self]
+    end
+
+    def targets_with_config
+      {self => @config.dup}
+    end
+  end
+
+end
+
+require_relative './node.rb'
+require_relative './group.rb'

data/lib/inprovise/local_file.rb

@@ -0,0 +1,120 @@
+# LocalFile support for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+require 'digest/sha1'
+require 'fileutils'
+require 'etc'
+
+class Inprovise::LocalFile
+  attr_reader :path
+
+  def initialize(path)
+    @path = resolve(path)
+  end
+
+  def resolve(path)
+    if path =~ /^\//
+      path
+    else
+      File.join(Inprovise.root, path)
+    end
+  end
+
+  def hash
+    return nil unless exists?
+    Digest::SHA1.file(path).hexdigest
+  end
+
+  def exists?
+    File.exists?(@path)
+  end
+
+  def directory?
+    File.directory?(path)
+  end
+
+  def file?
+    File.file?(path)
+  end
+
+  def content
+    return File.read(@path) if exists?
+    nil
+  end
+
+  # deosnt check permissions or user. should it?
+  def matches?(other)
+    self.exists? && other.exists? && self.hash == other.hash
+  end
+
+  def copy_to(destination)
+    if destination.is_local?
+      duplicate(destination)
+    else
+      upload(destination)
+    end
+    destination
+  end
+
+  def copy_from(source)
+    source.copy_to(self)
+  end
+
+  def duplicate(destination)
+    FileUtils.cp(path, destination.path)
+    destination
+  end
+
+  def upload(destination)
+    destination = @context.remote(destination) if String === destination
+    if destination.is_local?
+      FileUtils.cp(path, destination.path)
+    else
+      destination.upload(self)
+    end
+    destination
+  end
+
+  def download(source)
+    source = @context.remote(source) if String === source
+    if source.is_local?
+      FileUtils.cp(source.path, path)
+    else
+      source.download(self)
+    end
+    self
+  end
+
+  def delete!
+    FileUtils.rm(path) if exists?
+    self
+  end
+
+  def set_permissions(mask)
+    FileUtils.chmod_R(mask, path)
+    self
+  end
+
+  def permissions
+     File.stat(path).mode & 0777
+  end
+
+  def set_owner(user, group=nil)
+    FileUtils.chown_R(user, group, path)
+    self
+  end
+
+  def user
+    Etc.getpwuid(File.stat(path).uid).name
+  end
+
+  def group
+    Etc.getgrgid(File.stat(path).gid).name
+  end
+
+  def is_local?
+    true
+  end
+end

data/lib/inprovise/logger.rb

@@ -0,0 +1,79 @@
+# Logger for Inprovise
+#
+# Author::    Martin Corino
+# License::   Distributes under the same license as Ruby
+
+class Inprovise::Logger
+  attr_accessor :node
+  attr_reader :task
+
+  def initialize(node, task)
+    @node = node
+    @nl = true
+    set_task(task)
+  end
+
+  def clone_for_node(node)
+    copy = self.dup
+    copy.node = node
+    copy
+  end
+
+  def set_task(task)
+    oldtask = @task
+    @task = task.to_s
+    oldtask
+  end
+
+  def command(msg)
+    say(msg, :yellow)
+  end
+
+  def local(cmd)
+    say(cmd, :bold)
+  end
+
+  def execute(cmd)
+    say(cmd, :cyan)
+  end
+
+  def mock_execute(cmd)
+    execute(cmd)
+  end
+
+  def cached(cmd)
+    execute(cmd)
+  end
+
+  def remote(cmd)
+    say(cmd, :blue)
+  end
+
+  def log(msg)
+    say(msg)
+  end
+
+  def print(msg)
+    Thread.exclusive do
+      $stdout.print "#{@node.to_s} [#{@task.bold}] " if @nl
+      $stdout.print msg.sub("\r", "\r".to_eol << "#{@node.to_s} [#{@task.bold}] ")
+    end
+    @nl = false
+  end
+
+  def stdout(msg, force=false)
+    say(msg, :green) if force || Inprovise.verbosity>0
+  end
+
+  def stderr(msg, force=false)
+    say(msg, :red, $stderr) if force || Inprovise.verbosity>0
+  end
+
+  def say(msg, color=nil, stream=$stdout)
+    msg.to_s.split("\n").each do |line|
+      out = color ? line.send(color) : line
+      Thread.exclusive { stream.puts unless @nl; stream.puts "#{@node.to_s} [#{@task.bold}] #{out}" }
+      @nl = true
+    end
+  end
+end