cany 0.0.2 → 0.1.0

data/lib/cany/errors.rb

@@ -0,0 +1,62 @@
+module Cany
+  # Cany base error, design to catch all Cany errors at once
+  class Error < StandardError
+  end
+
+  class MissingSpecification < Error
+    def initialize(directory)
+      super "No #{Specification::EXT} found in #{directory}"
+    end
+  end
+
+  class MultipleSpecifications < Error
+    def initialize(directory)
+      super "Multiple #{Specification::EXT} found in #{directory}"
+    end
+  end
+
+  class CommandExecutionFailed < Error
+    def initialize(args)
+      super "Could not execute: #{args.join(' ')}"
+    end
+  end
+
+  class UnknownHook < Error
+    def initialize(hook)
+      super "Unknown hook \"#{hook}\""
+    end
+  end
+
+  class UnknownOption < Error
+    def initialize(option)
+      super "Unknown option \"#{option}\""
+    end
+  end
+
+  class UnloadedRecipe < Error
+    def initialize(name)
+      super "The recipe \"#{name}\" is not loaded by the specification."
+    end
+  end
+
+  class UnknownRecipe < Error
+    def initialize(name)
+      super "The recipe \"#{name}\" is not registered!"
+    end
+  end
+
+  class NoSystemRecipe < Error
+    def initialize
+      super "The specification has no loaded system recipe."
+    end
+  end
+
+  # This exception is raised if the running Cany version satisfies not the
+  # required Cany version constraint from the canspec.
+  class UnsupportedVersion < Error
+    def initialize(required_version)
+      super "The package specification requires Cany in version" \
+        " \"#{required_version}\" but Cany has version \"#{Cany::VERSION}\""
+    end
+  end
+end

data/lib/cany/mixins/depend_mixin.rb

@@ -0,0 +1,22 @@
+module Cany::Mixins::DependMixin
+  # @overload depend(dep)
+  #   @param depend[Cany::Dependency] A complete Dependency object
+  # @overload depend(default, opts)
+  #   Creates a new dependency object
+  #   @param depend[Symbol] The default
+  #   @param opts[Hash] Options influencing the create Dependency object.
+  #   @option opts[Symbol, Array<Symbol>] :situation For which situations
+  #     is this dependency. Default is :runtime
+  #   @option opts[Symbol] :version The default version
+  def create_dep(depend, opts={})
+    if depend.kind_of? Cany::Dependency
+      depend
+    else
+      opts = { situation: :runtime, version: nil }.merge opts
+      dep = Cany::Dependency.new
+      dep.define_default depend, opts[:version]
+      dep.situations = opts[:situation]
+      dep
+    end
+  end
+end

data/lib/cany/recipe.rb

@@ -11,23 +11,41 @@ module Cany
     def self.register_as(name)
       @@recipes ||= {}
       @@recipes[name] = self
+      module_eval(<<-EOS, __FILE__, __LINE__)
+        def name
+          :#{name}
+        end
+        EOS
     end
 
     # @api public
     # Looks for the class registered for the given name
     # @param [Symbol] name the name the class is search for
-    # @return [Cany::Recipe, nil] Returns the found class or nil if no class is registered on this
-    #  name
+    # @return [Cany::Recipe] Returns the found class or nil
+    # @raise UnknownRecipe if there is no recipe registered for this name.
     def self.from_name(name)
+      raise UnknownRecipe.new(name) unless @@recipes[name]
       @@recipes[name]
     end
 
     # Creates a new instance of this recipe
     # @param [Cany::Specification] spec Specification object
+    def initialize(spec, &configure_block)
+      @spec = spec
+      @inner = nil
+      @hooks = Hash[(self.class.defined_hooks || []).map do |name|
+        [name, Cany.hash_with_array_as_default]
+      end]
+      @options = Hash[(self.class.defined_options || []).map do |name|
+        [name, Cany.hash_with_array_as_default]
+      end]
+      self.class.const_get(:DSL).new(self).exec(&configure_block) if configure_block
+    end
+
+    # Specify the inner recipe for the current one.
     # @param [Cany::Recipe, nil] inner Inner recipes should should be call between the pre and post
     #  actions of this class. Nil means most inner recipes.
-    def initialize(spec, inner)
-      @spec = spec
+    def inner=(inner)
       @inner = inner
     end
 
@@ -46,13 +64,20 @@ module Cany
     #   exec 'echo', %w(a b)
     #   exec ['echo', 'a', 'b']
     #   exec 'echo', 'a', 'b'
+    # @raise [CommandExecutionFailed] if the executed program exists with a
+    #   non-zero exit code.
     def exec(*args)
-      puts "   #{args.flatten.join(' ')}"
-      system *args.flatten
+      args.flatten!
+      Cany.logger.info args.join(' ')
+      unless system(*args)
+        raise CommandExecutionFailed.new args
+      end
     end
+    # exec is special name in same situations it may no work but this alias should work always
+    alias :exec_ :exec
 
     # @api public
-    # Run a ruby task (like gem, bundler, rake ...)
+    # Run a ruby task (like gem, bundle, rake ...)
     #
     # The method expects as arguments the program name and additional parameters for the program.
     # See exec for more examples
@@ -62,12 +87,12 @@ module Cany
 
     # @api public
     # Install files or directory from the build directory
-    # @param [String] source The relative file name to a filename or directory inside the build
+    # @param source[String] The relative file name to a filename or directory inside the build
     #   directory that should be installed/copied into the destination package
-    # @param [String] destination The diretory name into that the file or directory should be
+    # @param destination[String] The diretory name into that the file or directory should be
     #   installed
-    def install(src, dest_dir)
-      exec 'dh_install', src, dest_dir
+    def install(source, destination)
+      exec 'dh_install', source, destination
     end
 
     # @api public
@@ -95,6 +120,21 @@ module Cany
       exec 'dh_link', source, destination
     end
 
+    # @api public
+    # Specify a command call (program + args) that should be installed as service and started
+    # automatically.
+    # This method should be only call inside the binary step.
+    # @param name[Symbol] A short identifier. Used to separate different services. E.g. the name
+    #   of the web server that is launched by this command (like puma, unicorn, thin)
+    # @param command[Array<String>] The command that should be started and its parameter. The first
+    #   element is the command name - can be absolute or relative path name (than searched in path)
+    # @param opts[Hash] Service behavior options
+    # @option opts[String] :user As which user should the command executed (default is root)
+    # @option opts[String] :group As which group should the command executed (default is root)
+    def install_service(*args)
+      recipe(:system).install_service(*args)
+    end
+
     # @api public
     # Ensure that the given files or directories are no present. Directories are removed
     # recursively.
@@ -104,9 +144,100 @@ module Cany
       end
     end
 
+    class << self
+      attr_accessor :defined_hooks, :defined_options
+
+      # @api public
+      # Define a new hook
+      # @param name[Symbol]
+      def hook(name)
+        @defined_hooks ||= []
+        @defined_hooks  << name
+      end
+
+      # @api public
+      # Define a configure option. These kind of option are design for other
+      # recipes not for the user. See Recipe::DSL for this.
+      # @param name[Symbol] The name of the option. The option name is scoped
+      #    inside a recipe.
+      def option(name)
+        @defined_options ||= []
+        @defined_options  << name
+      end
+    end
+
+    def hook(name)
+      @hooks[name].tap do |hook|
+        raise UnknownHook.new name unless hook
+      end
+    end
+
+    # @api public
+    # Ask for the current values for a defined option
+    def option(name)
+      @options[name].tap do |option|
+        raise UnknownOption.new name unless option
+      end
+    end
+
+    # @api public
+    # Configure an other recipe
+    # @param name[Symbol] The option name
+    # @param options[Hash] The configuration data itself.
+    def configure(name, options)
+      option(name).merge! options
+    end
+
+    # @api public
+    # Run defined actions for a hook
+    # @param name[Symbol] hook identification, no error is raised on unknown hooks
+    # @param state[Symbol] state that should be executed (:before, :after or :around)
+    def run_hook(name, state)
+      hook(name)[state].each do |block|
+        Cany.logger.info  "run #{block} for hook #{name} in state #{state} ..."
+        instance_eval(&block)
+      end
+    end
+
+    # @api public
+    # Access the recipe instance from another loaded recipe of this
+    # specification
+    # @param name[Symbol] recipe name
+    def recipe(name)
+      return spec.system_recipe if name == :system
+      recipe_class = Recipe.from_name(name)
+      @spec.recipes.each do |one_recipe|
+        return one_recipe if one_recipe.instance_of? recipe_class
+      end
+      raise UnloadedRecipe.new name
+    end
+
+    # @api public
+    # Adds a new dependency for the software. See Cany::Dependency for a more
+    # abstract description about dependencies
+    # See Cany::Mixins::DependMixin for parameter description
+    include Cany::Mixins::DependMixin
+    def depend(*args)
+      @spec.dependencies << create_dep(*args)
+    end
+
     # default implementation:
     #########################
 
+    # @!group Recipe Steps - to be overridden in subclass
+
+    # @api public
+    # Prepares the recipes to run things. This is call exactly once for all recipes before
+    # recipes actions are executed.
+    def prepare
+    end
+
+    # @api public
+    # This step is executed to create the distribution specific packages from canspec. The recipe
+    # can e.g. add additional dependencies or adjust the package meta data.
+    def create(creator)
+    end
+
     # @api public
     # clean the build directory from all temporary and created files
     def clean
@@ -124,5 +255,45 @@ module Cany
     def binary
       inner.binary
     end
+
+    # @!endgroup
+
+
+    # This superclass helps recipes to create easily an own mini DSL to let the user configure the
+    # recipe with it.
+    class DSL
+      def initialize(recipe)
+        @recipe = recipe
+      end
+
+      # Evaluate a given block inside the dsl.
+      def exec(&block)
+        instance_eval(&block)
+      end
+
+      # This is a simple delegate helper. It can be used to pass option directly to recipe instance.
+      # @param [Symbol] param1 Multiple symbol names
+      def self.delegate(*methods)
+        methods.each do |method|
+          module_eval(<<-EOS, __FILE__, __LINE__)
+          def #{method}(*args, &block)
+            @recipe.send :'#{method}=', *args, &block
+          end
+          EOS
+        end
+      end
+
+      def before(hook_name, &block)
+        @recipe.hook(hook_name)[:before] << block
+      end
+
+      def after(hook_name, &block)
+        @recipe.hook(hook_name)[:after] << block
+      end
+
+      def around(hook_name, &block)
+        @recipe.hook(hook_name)[:around] << block
+      end
+    end
   end
 end

data/lib/cany/recipes/bundler.rb

@@ -2,6 +2,7 @@ module Cany
   module Recipes
     class Bundler < Cany::Recipe
       register_as :bundler
+      option :env_vars
 
       def clean
         rmtree 'bundler'
@@ -9,6 +10,23 @@ module Cany
         inner.clean
       end
 
+      def prepare
+        configure :env_vars, GEM_PATH: 'bundler'
+      end
+
+      def create(creator)
+        require 'bundler'
+        lock_path = File.join(spec.base_dir, 'Gemfile.lock')
+        if File.exists? lock_path
+          lock = ::Bundler::LockfileParser.new File.read lock_path
+          lock.specs.each do |spec|
+            Gem.get(spec.name.to_sym).dependencies.each do |dep|
+              depend dep
+            end
+          end
+        end
+      end
+
       def build
         ENV['GEM_PATH'] = 'bundler'
         ENV['PATH'] = 'bundler/bin:' + ENV['PATH']
@@ -21,13 +39,18 @@ module Cany
         install 'bundler', "/usr/share/#{spec.name}"
         install '.bundle', "/usr/share/#{spec.name}"
         install 'vendor/bundle', "/usr/share/#{spec.name}/vendor"
-        install_content "/usr/bin/#{spec.name}", "#!/bin/sh
-cd /usr/share/#{spec.name}
-export GEM_PATH=/usr/share/#{spec.name}/bundler
-exec /usr/share/#{spec.name}/bundler/bin/bundle exec \"$@\"
-"
+        install_content "/usr/bin/#{spec.name}", wrapper_script
         inner.binary
       end
+
+      def wrapper_script
+        content = [ '#!/bin/sh', "cd /usr/share/#{spec.name}" ]
+        option(:env_vars).each do |name, value|
+          content << "export #{name}=\"#{value}\""
+        end
+        content += [ "exec /usr/share/#{spec.name}/bundler/bin/bundle exec \"$@\"", '' ]
+        content.join "\n"
+      end
     end
   end
 end

data/lib/cany/recipes/bundler/gem.rb

@@ -0,0 +1,50 @@
+class Cany::Recipes::Bundler::Gem
+  # @api public
+  # This methods returns the Gem instance for the specified gem
+  # @param gem_name[Symbol] The gem name
+  # @return Cany::recipes::Bundler::Gem
+  def self.get(gem_name)
+    @gems ||= {}
+    @gems[gem_name] ||= new   gem_name
+  end
+
+  # @api public
+  # Specify meta data about the given gem
+  # @param gem_name[Symbol] the gem name
+  # @block: A block that defines the meta data. Executed inside the DSL subclass
+  def self.specify(gem_name, &block)
+    DSL.new(get(gem_name)).run &block
+  end
+
+  # Clear all stored data. Only used in rspec
+  def self.clear
+    @gems = {}
+  end
+
+  attr_reader :name, :dependencies
+
+  private
+  def initialize(gem_name)
+    @name = gem_name
+    @dependencies = []
+  end
+
+  class DSL
+    def initialize(gem)
+      @gem = gem
+    end
+
+    def run(&block)
+      instance_eval(&block)
+    end
+
+    # @api public
+    # Adds a new dependency for the software. See Cany::Dependency for a more
+    # abstract description about dependencies
+    # See Cany::Mixins::DependMixin for parameter description
+    include Cany::Mixins::DependMixin
+    def depend(*args)
+      @gem.dependencies << create_dep(*args)
+    end
+  end
+end

data/lib/cany/recipes/bundler/gem_db.rb

@@ -0,0 +1,27 @@
+class Cany::Recipes::Bundler
+  Gem.specify :charlock_holmes do
+    depend 'libicu-dev', situation: :build
+    depend 'libicu48', situation: :runtime
+  end
+
+  Gem.specify :ethon do
+    depend 'libcurl3-gnutls', situation: [:build, :runtime]
+  end
+
+  Gem.specify :mysql2 do
+    depend 'libmysqlclient-dev', situation: :build
+    depend 'libmysqlclient18', situation: :runtime
+  end
+
+  Gem.specify :nokogiri do
+    depend 'libxml2-dev', situation: :build
+    depend 'libxml2', situation: :runtime
+    depend 'libxslt1-dev', situation: :build
+    depend 'libxslt1.1', situation: :runtime
+  end
+
+  Gem.specify :pg do
+    depend 'libpq-dev', situation: :build
+    depend 'libpq5', situation: :runtime
+  end
+end