wright 0.0.1 → 0.1.0

data/lib/wright/provider/symlink.rb

@@ -0,0 +1,86 @@
+require 'wright/provider'
+require 'fileutils'
+
+module Wright
+  class Provider
+    # Public: Symlink provider. Used as a Provider for Resource::Symlink.
+    class Symlink < Wright::Provider
+      # Public: Create or update the Symlink.
+      #
+      # Returns nothing.
+      def create
+        if exist?
+          symlink = symlink_to_s(@resource.name, @resource.to)
+          Wright.log.debug "symlink already created: #{symlink}"
+          return
+        end
+
+        fail Errno::EEXIST, link_name if regular_file?
+        create_link
+        @updated = true
+      end
+
+      # Public: Remove the Symlink.
+      #
+      # Returns nothing.
+      def remove
+        if ::File.exist?(link_name) && !::File.symlink?(link_name)
+          fail "'#{link_name}' is not a symlink"
+        end
+
+        if ::File.symlink?(link_name)
+          remove_symlink
+          @updated = true
+        else
+          Wright.log.debug "symlink already removed: '#{@resource.name}'"
+        end
+      end
+
+      private
+
+      # Internal: Checks if the specified link exists.
+      #
+      # Returns true if the link exists and points to the specified target
+      # and false otherwise.
+      def exist? #:doc:
+        ::File.symlink?(link_name) &&
+          ::File.readlink(link_name) == link_to
+      end
+
+      def create_link
+        symlink = symlink_to_s(@resource.name, @resource.to)
+        if Wright.dry_run?
+          Wright.log.info "(would) create symlink: #{symlink}"
+        else
+          Wright.log.info "create symlink: #{symlink}"
+          Wright::Util::File.ln_sfn(link_to, link_name)
+        end
+      end
+
+      def symlink_to_s(link_name, target)
+        "'#{link_name}' -> '#{target}'"
+      end
+
+      def remove_symlink
+        if Wright.dry_run?
+          Wright.log.info "(would) remove symlink: '#{@resource.name}'"
+        else
+          Wright.log.info "remove symlink: '#{@resource.name}'"
+          FileUtils.rm(link_name)
+        end
+      end
+
+      def regular_file?
+        ::File.exist?(link_name) && !::File.symlink?(link_name)
+      end
+
+      def link_to
+        Wright::Util::File.expand_tilde_path(@resource.to)
+      end
+
+      def link_name
+        Wright::Util::File.expand_tilde_path(@resource.name)
+      end
+    end
+  end
+end

data/lib/wright/provider.rb

@@ -0,0 +1,30 @@
+require 'wright/util/recursive_autoloader'
+
+module Wright
+  # Public: Provider class.
+  class Provider
+    # Public: Wright standard provider directory.
+    PROVIDER_DIR = File.expand_path('provider', File.dirname(__FILE__))
+
+    Wright::Util::RecursiveAutoloader.add_autoloads(PROVIDER_DIR, name)
+
+    # Public: Initialize a Provider.
+    #
+    # resource - The resource used by the provider, typically a
+    #            Wright::Resource.
+    def initialize(resource)
+      @resource = resource
+      @updated = false
+    end
+
+    # Public: Checks if the provider was updated since the last call
+    # to updated?.
+    #
+    # Returns true if the provider was updated and false otherwise.
+    def updated?
+      updated = @updated
+      @updated = false
+      updated
+    end
+  end
+end

data/lib/wright/resource/directory.rb

@@ -0,0 +1,67 @@
+require 'wright/resource'
+require 'wright/dsl'
+
+module Wright
+  class Resource
+    # Public: Directory resource, represents a directory.
+    #
+    # Examples
+    #
+    #   dir = Wright::Resource::Directory.new('/tmp/foobar')
+    #   dir.create
+    class Directory < Wright::Resource
+      # Public: Initialize a Directory.
+      #
+      # name - The directory's name.
+      def initialize(name)
+        super
+        @mode = nil
+        @owner = nil
+        @group = nil
+        @action = :create
+      end
+
+      # Public: Get/Set the directory's mode.
+      attr_accessor :mode
+
+      # Public: Get the directory's owner.
+      attr_reader :owner
+
+      # Public: Set the directory's owner.
+      def owner=(owner)
+        target_owner, target_group =
+          Wright::Util::User.owner_to_owner_group(owner)
+        @owner = target_owner unless target_owner.nil?
+        @group = target_group unless target_group.nil?
+      end
+
+      # Public: Get the directory's group.
+      attr_reader :group
+
+      # Public: Set the directory's group
+      def group=(group)
+        @group = Wright::Util::User.group_to_gid(group)
+      end
+
+      # Public: Create or update the directory.
+      #
+      # Returns true if the directory was updated and false otherwise.
+      def create
+        might_update_resource do
+          @provider.create
+        end
+      end
+
+      # Public: Remove the directory.
+      #
+      # Returns true if the directory was updated and false otherwise.
+      def remove
+        might_update_resource do
+          @provider.remove
+        end
+      end
+    end
+  end
+end
+
+Wright::DSL.register_resource(Wright::Resource::Directory)

data/lib/wright/resource/file.rb

@@ -0,0 +1,67 @@
+require 'wright/resource'
+require 'wright/dsl'
+
+module Wright
+  class Resource
+    # Public: Symlink resource, represents a symlink.
+    #
+    # Examples
+    #
+    #   file = Wright::Resource::File.new('/tmp/foo')
+    #   file.content = 'bar'
+    #   file.create
+    class File < Wright::Resource
+      # Public: Get/Set the file's content.
+      attr_accessor :content
+
+      # Public: Get/Set the file's group.
+      attr_accessor :group
+
+      # Public: Get/Set the file's mode.
+      attr_accessor :mode
+
+      # Public: Get the file's owner.
+      attr_reader :owner
+
+      # Public: Initialize a File.
+      #
+      # name - The file's name.
+      def initialize(name)
+        super
+        @content = nil
+        @mode = nil
+        @owner = nil
+        @group = nil
+        @action = :create
+      end
+
+      # Public: Set the file's owner.
+      def owner=(owner)
+        target_owner, target_group =
+          Wright::Util::User.owner_to_owner_group(owner)
+        @owner = target_owner unless target_owner.nil?
+        @group = target_group unless target_group.nil?
+      end
+
+      # Public: Create or update the File.
+      #
+      # Returns true if the file was updated and false otherwise.
+      def create
+        might_update_resource do
+          @provider.create
+        end
+      end
+
+      # Public: Remove the File.
+      #
+      # Returns true if the file was updated and false otherwise.
+      def remove
+        might_update_resource do
+          @provider.remove
+        end
+      end
+    end
+  end
+end
+
+Wright::DSL.register_resource(Wright::Resource::File)

data/lib/wright/resource/package.rb

@@ -0,0 +1,70 @@
+require 'wright/resource'
+require 'wright/dsl'
+
+module Wright
+  class Resource
+    # Public: Package resource, represents a package.
+    #
+    # Examples
+    #
+    #   vim = Wright::Resource::Package.new('vim')
+    #   vim.installed_versions
+    #   # => []
+    #   vim.install
+    #   vim.installed_versions
+    #   # => ["2:7.3.547-7"]
+    #
+    #   htop = Wright::Resource::Package.new('htop')
+    #   htop.installed_versions
+    #   # => ["1.0.1-1"]
+    #   htop.remove
+    #   htop.installed_versions
+    #   # => []
+    class Package < Wright::Resource
+      # Public: Get/Set the package version to install/remove.
+      attr_accessor :version
+
+      # Public: Initialize a Package.
+      #
+      # name - The package name.
+      def initialize(name)
+        super
+        @version = nil
+        @action = :install
+      end
+
+      # Public: Get the installed version of a package.
+      #
+      # Returns an array of installed package version Strings.
+      def installed_versions
+        @provider.installed_versions
+      end
+
+      # Public: Install the Package.
+      #
+      # Returns true if the package was updated and false otherwise.
+      def install
+        might_update_resource do
+          @provider.install
+        end
+      end
+
+      # Public: Remove the Package.
+      #
+      # Returns true if the package was updated and false otherwise.
+      def remove
+        might_update_resource do
+          @provider.remove
+        end
+      end
+    end
+  end
+end
+
+Wright::DSL.register_resource(Wright::Resource::Package)
+
+# hard-coded for now
+# TODO: remove this
+Wright::Config[:resources] ||= {}
+Wright::Config[:resources][:package] =
+  { provider: 'Wright::Provider::Package::Apt' }

data/lib/wright/resource/symlink.rb

@@ -0,0 +1,47 @@
+require 'wright/resource'
+require 'wright/dsl'
+
+module Wright
+  class Resource
+    # Public: Symlink resource, represents a symlink.
+    #
+    # Examples
+    #
+    #   link = Wright::Resource::Symlink.new('/tmp/fstab')
+    #   link.to = '/etc/fstab'
+    #   link.create
+    class Symlink < Wright::Resource
+      # Public: Initialize a Symlink.
+      #
+      # name - The link's name.
+      def initialize(name)
+        super
+        @to = nil
+        @action = :create
+      end
+
+      # Public: Get/Set the link's target.
+      attr_accessor :to
+
+      # Public: Create or update the Symlink.
+      #
+      # Returns true if the symlink was updated and false otherwise.
+      def create
+        might_update_resource do
+          @provider.create
+        end
+      end
+
+      # Public: Remove the Symlink.
+      #
+      # Returns true if the symlink was updated and false otherwise.
+      def remove
+        might_update_resource do
+          @provider.remove
+        end
+      end
+    end
+  end
+end
+
+Wright::DSL.register_resource(Wright::Resource::Symlink)

data/lib/wright/resource.rb

@@ -0,0 +1,157 @@
+require 'wright/config'
+require 'wright/util'
+require 'wright/logger'
+require 'wright/dry_run'
+
+module Wright
+  # Public: Resource base class.
+  class Resource
+    # Public: Initialize a Resource.
+    #
+    # name - The resource's name.
+    def initialize(name = nil)
+      @name = name
+      @resource_name = Util.class_to_resource_name(self.class).to_sym
+      @provider = provider_for_resource
+      @action = nil
+      @on_update = nil
+      @ignore_failure = false
+    end
+
+    # Public: Get/Set the name Symbol of the method to be run by run_action.
+    attr_accessor :action
+
+    # Public: Get/Set the ignore_failure attribute.
+    attr_accessor :ignore_failure
+
+    # Public: Get/Set the resource's name attribute.
+    #
+    # Examples
+    #
+    #   foo = Wright::Resource::Symlink.new('/tmp/fstab')
+    #   foo.name
+    #   # => "/tmp/fstab"
+    #
+    #   bar = Wright::Resource::Symlink.new
+    #   bar.name = '/tmp/passwd'
+    #   bar.name
+    #   # => "/tmp/passwd"
+    attr_accessor :name
+
+    # Public: Returns a compact resource name Symbol.
+    #
+    # Examples
+    #
+    #   foo = Wright::Resource::Symlink.new
+    #   foo.resource_name
+    #   # => :symlink
+    attr_reader :resource_name
+
+    # Public: Set an update action for a resource.
+    #
+    # on_update - The block that is called if the resource is
+    #             updated. Has to respond to :call.
+    #
+    # Returns nothing.
+    # Raises ArgumentError if on_update is not callable
+    def on_update=(on_update)
+      if on_update.respond_to?(:call) || on_update.nil?
+        @on_update = on_update
+      else
+        fail ArgumentError, "#{on_update} is not callable"
+      end
+    end
+
+    # Public: Run the resource's current action.
+    #
+    # Examples
+    #
+    #   fstab = Wright::Resource::Symlink.new('/tmp/fstab')
+    #   fstab.action = :remove
+    #   fstab.run_action
+    def run_action
+      send @action if @action
+    end
+
+    private
+
+    # Public: Mark a code block that might update a resource.
+    #
+    # Usually this method is called in the definition of a new
+    # resource class in order to mark those methods that should be
+    # able to trigger update actions. Runs the current update action
+    # if the provider was updated by the block method.
+    #
+    # Examples
+    #
+    #   class BalloonAnimal < Wright::Provider
+    #     def inflate
+    #       puts "It's a giraffe!"
+    #       @updated = true
+    #     end
+    #   end
+    #
+    #   class Balloon < Wright::Resource
+    #     def inflate
+    #       might_update_resource { @provider.inflate }
+    #     end
+    #   end
+    #   Wright::Config[:resources] = { balloon: { provider: 'BalloonAnimal' } }
+    #
+    #   balloon = Balloon.new.inflate
+    #   # => true
+    #
+    # Returns true if the provider was updated and false otherwise.
+    def might_update_resource #:doc:
+      begin
+        yield
+      rescue => e
+        log_error(e)
+        raise e unless @ignore_failure
+      end
+      updated = @provider.updated?
+      run_update_action if updated
+      updated
+    end
+
+    def log_error(exception)
+      resource = "#{@resource_name}"
+      resource << " '#{@name}'" if @name
+      Wright.log.error "#{resource}: #{exception}"
+    end
+
+    def run_update_action
+      return if @on_update.nil?
+
+      if Wright.dry_run?
+        resource = "#{@resource_name} '#{@name}'"
+        Wright.log.info "Would trigger update action for #{resource}"
+      else
+        @on_update.call
+      end
+    end
+
+    def resource_class
+      Util::ActiveSupport.camelize(@resource_name)
+    end
+
+    def provider_name
+      if Wright::Config.nested_key?(:resources, @resource_name, :provider)
+        Wright::Config[:resources][@resource_name][:provider]
+      else
+        "Wright::Provider::#{resource_class}"
+      end
+    end
+
+    def provider_for_resource
+      klass = Util::ActiveSupport.safe_constantize(provider_name)
+      if klass
+        klass.new(self)
+      else
+        warning = "Could not find a provider for resource #{resource_class}"
+        Wright.log.warn warning
+        nil
+      end
+    end
+  end
+end

data/lib/wright/util/color.rb

@@ -0,0 +1,51 @@
+module Wright
+  module Util
+    # Internal: ANSI color helpers.
+    module Color
+      # Internal: Colorize a string (red).
+      #
+      # string - The string to colorize.
+      #
+      # Returns the colorized String.
+      def self.red(string)
+        colorize(string, :red)
+      end
+
+      # Internal: Colorize a string (yellow).
+      #
+      # string - The string to colorize.
+      #
+      # Returns the colorized String.
+      def self.yellow(string)
+        colorize(string, :yellow)
+      end
+
+      # Internal: Colorize a string.
+      #
+      # string - The string to colorize.
+      # color - The color that should be used.
+      #
+      # Examples
+      #
+      #   Wright::Util::Color.colorize('Hello world', :red)
+      #   # => "\e[31mHello world\e[0m"
+      #
+      #   Wright::Util::Color.colorize('Hello world', :yellow)
+      #   # => "\e[32mHello world\e[0m"
+      #
+      # Returns the colorized String.
+      def self.colorize(string, color)
+        no_color = COLOR_MAP[:none]
+        color = COLOR_MAP.fetch(color, no_color)
+        "#{color}#{string}#{no_color}"
+      end
+
+      COLOR_MAP = { #:nodoc:
+        none: "\e[0m",
+        red: "\e[31m",
+        yellow: "\e[32m"
+      }
+      private_constant :COLOR_MAP
+    end
+  end
+end