orca 0.1.0

data/lib/orca/extensions/file_sync.rb

@@ -0,0 +1,100 @@
+Orca.extension :file_sync do
+  class Orca::Package
+    def file(config)
+      Orca::FileSync.new(self, config).configure
+    end
+  end
+end
+
+class Orca::FileSync
+  def initialize(parent, config)
+    @parent = parent
+    @config = config
+    raise ArgumentError.new('A file :source must be provided') unless local_path
+    raise ArgumentError.new('A file :destination must be provided') unless remote_path
+  end
+
+  def local_path
+    @config[:source]
+  end
+
+  def remote_path
+    @config[:destination]
+  end
+
+  def permissions
+    @config[:permissions]
+  end
+
+  def user
+    @config[:user]
+  end
+
+  def group
+    @config[:group]
+  end
+
+  def create_dir
+    @config[:create_dir] || @config[:create_dirs]
+  end
+
+  def package_name(suffix)
+    "file-#{suffix}[#{remote_path}]"
+  end
+
+  def configure
+    fs = self
+    add_content_package
+    add_permissions_package unless permissions.nil? and user.nil? and group.nil?
+  end
+
+  def add_content_package
+    fs = self
+    add_package('content') do |package|
+      package.command :apply do
+        if fs.create_dir
+          mk_dir = fs.create_dir == true ? File.dirname(fs.remote_path) : fs.create_dir
+          sudo("mkdir -p #{mk_dir}")
+          sudo("chown #{fs.user}:#{fs.group || fs.user} #{mk_dir}") if fs.user
+        end
+        local_file = local(fs.local_path)
+        tmp_path = "orca-upload-#{local_file.hash}"
+        local_file.copy_to(remote(tmp_path))
+        sudo("mv #{tmp_path} #{fs.remote_path}")
+      end
+
+      package.command :remove do
+        remote(fs.remote_path).delete!
+      end
+
+      package.command :validate do
+        local(fs.local_path).matches?(remote(fs.remote_path))
+      end
+    end
+  end
+
+  def add_permissions_package
+    fs = self
+    add_package('permissions') do |package|
+      package.command :apply do
+        remote(fs.remote_path).set_owner(fs.user, fs.group) unless fs.user.nil? and fs.group.nil?
+        remote(fs.remote_path).set_permissions(fs.permissions) unless fs.permissions.nil?
+      end
+
+      package.command :validate do
+        r_file = remote(fs.remote_path)
+        valid = r_file.permissions == fs.permissions
+        valid = valid && r_file.user == fs.user if fs.user
+        valid = valid && r_file.group == fs.group if fs.group
+        valid
+      end
+    end
+  end
+
+  def add_package(suffix)
+    package = Orca.add_package(package_name(suffix))
+    yield(package)
+    @parent.triggers(package.name)
+    package
+  end
+end

data/lib/orca/local_file.rb

@@ -0,0 +1,77 @@
+require 'digest/sha1'
+require 'fileutils'
+
+class Orca::LocalFile
+  attr_reader :path
+
+  def initialize(path)
+    @path = resolve(path)
+  end
+
+  def resolve(path)
+    if path =~ /^\//
+      path
+    else
+      File.join(Orca.root, path)
+    end
+  end
+
+  def hash
+    return nil unless exists?
+    Digest::SHA1.file(path).hexdigest
+  end
+
+  def exists?
+    File.exists?(@path)
+  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(destination)
+    destination.copy_to(self)
+  end
+
+  def duplicate(destination)
+    FileUtils.cp(path, destination.path)
+    destination
+  end
+
+  def upload(destination)
+    destination.upload(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 is_local?
+    true
+  end
+end

data/lib/orca/node.rb

@@ -0,0 +1,83 @@
+require 'net/ssh'
+require 'net/sftp'
+
+class Orca::Node
+  attr_reader :name, :host
+
+  def self.find(name)
+    return name if name.is_a?(Orca::Node)
+    @nodes[name]
+  end
+
+  def self.register(node)
+    @nodes ||= {}
+    @nodes[node.name] = node
+  end
+
+  def initialize(name, host, options={})
+    @name = name
+    @host = host
+    @options = options
+    @connection = nil
+    Orca::Node.register(self)
+  end
+
+  def upload(from, to)
+    log('sftp', "UPLOAD: #{from} => #{to}")
+    sftp.upload!(from, to)
+  end
+
+  def download(from, to)
+    log('sftp', "DOWLOAD: #{from} => #{to}")
+    sftp.download!(from, to)
+  end
+
+  def remove(path)
+    log('sftp', "REMOVE: #{path}")
+    sftp.remove!(path)
+  end
+
+  def stat(path)
+    log('sftp', "STAT: #{path}")
+    sftp.stat!(path)
+  end
+
+  def setstat(path, opts)
+    log('sftp', "SET: #{path} - #{opts.inspect}")
+    sftp.setstat!(path, opts)
+  end
+
+  def sftp
+    @sftp ||= connection.sftp.connect
+  end
+
+  def execute(cmd)
+    log('execute', cmd.cyan)
+    output = ""
+    connection.exec! cmd do |channel, stream, data|
+      output += data if stream == :stdout
+      data.split("\n").each do |line|
+        msg = stream == :stdout ? line.green : line.red
+        log(stream, msg)
+      end
+    end
+    output
+  end
+
+  def sudo(cmd)
+    execute("sudo #{cmd}")
+  end
+
+  def log(context, msg)
+    puts "#{self.to_s} [#{context.to_s.bold}] #{msg}"
+  end
+
+  def connection
+    return @connection if @connection
+    @connetion = Net::SSH.start(@host, (@options[:user] || 'root'), @options)
+  end
+
+  def to_s
+    "#{name}(#{host})"
+  end
+end

data/lib/orca/package.rb

@@ -0,0 +1,52 @@
+class Orca::Package
+  attr_reader :name, :dependancies, :actions, :children
+
+  def initialize(name)
+    @name = name
+    @dependancies = []
+    @children = []
+    @actions = {}
+    @commands = {}
+    @remove = nil
+  end
+
+  def depends_on(*pkg_names)
+    pkg_names.each do |pkg_name|
+      @dependancies << pkg_name
+    end
+  end
+
+  def triggers(*pkg_names)
+    pkg_names.each do |pkg_name|
+      @children << pkg_name
+    end
+  end
+
+  def validate(&definition)
+    command(:validate, &definition)
+  end
+
+  def apply(&definition)
+    command(:apply, &definition)
+  end
+
+  def remove(&definition)
+    command(:remove, &definition)
+  end
+
+  def action(name, &definition)
+    @actions[name] = definition
+  end
+
+  def command(name, &definition)
+    if block_given?
+      (@commands[name.to_sym] ||= []) << definition
+    else
+      @commands[name.to_sym]
+    end
+  end
+
+  def provides_command?(name)
+    @commands.has_key?(name.to_sym)
+  end
+end

data/lib/orca/package_index.rb

@@ -0,0 +1,37 @@
+class Orca::PackageIndex
+  attr_reader :index_name
+
+  def initialize(index_name)
+    @index_name = index_name
+    @packages = {}
+  end
+
+  def self.default
+    @default ||= new('default')
+  end
+
+  def add(pkg)
+    @packages[pkg.name] = pkg
+  end
+
+  def get(pkg_name)
+    pkg = @packages[pkg_name]
+    raise MissingPackageError.new(index_name, pkg_name) if pkg.nil?
+    pkg
+  end
+
+  def clear!
+    @packages = {}
+  end
+
+  class MissingPackageError < StandardError
+    def initialize(index_name, package_name)
+      @index_name = index_name
+      @package_name = package_name
+    end
+
+    def message
+      "package #{@package_name} could not be found in the index #{@index_name}"
+    end
+  end
+end

data/lib/orca/remote_file.rb

@@ -0,0 +1,104 @@
+require 'digest/sha1'
+require 'fileutils'
+
+class Orca::RemoteFile
+  attr_reader :path
+
+  def initialize(context, path)
+    @context = context
+    @path = path
+    @exists = nil
+    @permissions = nil
+    @owner = nil
+  end
+
+  def hash
+    return nil unless exists?
+    @hash ||= @context.run("sha1sum #{path}")[0...40]
+  end
+
+  def exists?
+    return @exists unless @exists.nil?
+    result = @context.run(%[if [ -f #{path} ]; then echo "true"; else echo "false"; fi])
+    @exists = result.strip == 'true'
+  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?
+      download(destination)
+    else
+      duplicate(destination)
+    end
+    destination
+  end
+
+  def copy_from(destination)
+    destination.copy_to(self)
+  end
+
+  def duplicate(destination)
+    @context.sudo("cp #{path} #{destination.path}")
+    destination
+  end
+
+  def download(destination)
+    @context.download(path, destination.path)
+  end
+
+  def upload(source)
+    @context.upload(source.path, path)
+  end
+
+  def delete!
+    @context.remove(path)
+    invalidate!
+    self
+  end
+
+  def set_permissions(mask)
+    @context.sudo("chmod -R #{sprintf("%o",mask)} #{path}")
+    invalidate!
+    self
+  end
+
+  def permissions
+    @permissions ||= @context.run("stat --format=%a #{path}").strip.to_i(8)
+  end
+
+  def set_owner(user, group=nil)
+    @context.sudo("chown -R #{user}:#{group} #{path}")
+    invalidate!
+    self
+  end
+
+  def owner
+    @owner ||= begin
+      user, group = @context.run("stat --format=%U:%G #{path}").chomp.split(":")
+      {:user => user, :group => group}
+    end
+  end
+
+  def user
+    owner[:user]
+  end
+
+  def group
+    owner[:group]
+  end
+
+  def is_local?
+    false
+  end
+
+  private
+
+  def invalidate!
+    @permissions = nil
+    @owner = nil
+  end
+end