cany 0.0.2 → 0.1.0

data/lib/cany/recipes/rails.rb

@@ -2,20 +2,37 @@ module Cany
   module Recipes
     class Rails < Recipe
       register_as :rails
+      hook :env
+
+      class DSL < Recipe::DSL
+        delegate :compile_assets
+      end
+
+      attr_accessor :compile_assets
+
+      def initialize(*args)
+        @compile_assets = true
+        super
+      end
 
       def clean
         rmtree 'tmp', 'public/assets'
         inner.clean
       end
 
+      def prepare
+        recipe(:bundler).configure :env_vars, RAILS_ENV: 'production'
+      end
+
       def build
-        ENV['RAILS_ENV'] = 'assets'
-        ruby_bin 'bundle', 'exec', 'rake', 'assets:precompile'
+        run_hook :env, :before
         ENV['RAILS_ENV'] = 'production'
+        ruby_bin 'bundle', 'exec', 'rake', 'assets:precompile' if compile_assets
         inner.build
       end
 
       def binary
+        run_hook :env, :after
         %w(app config.ru db Gemfile Gemfile.lock lib public Rakefile vendor).each do |item|
           install item, "/usr/share/#{spec.name}" if File.exists? item
         end

data/lib/cany/recipes/sidekiq.rb

@@ -0,0 +1,38 @@
+module Cany::Recipes
+  # This recipes installs Sidekiq
+  #   "Simple, efficient, background processing in Ruby"
+  # Sidekiq is registered as service and so automatically started.
+  # @see http://sidekiq.org/ The official website for more information.
+  # @node The recipe relies that 'sidekiq' is listed inside your Gemfile and
+  #   therefore installed via the 'bundler' recipe.
+  class Sidekiq < Cany::Recipe
+    register_as :sidekiq
+
+    attr_accessor :queues
+
+    def initialize(*args)
+      @queues = []
+      super
+    end
+
+    class DSL < Cany::Recipe::DSL
+      def queue(name)
+        @recipe.queues << name
+      end
+    end
+
+    def binary
+      install_service name, %W(/usr/bin/#{spec.name} sidekiq) + sidekiq_args, user: 'www-data', group: 'www-data'
+      inner.binary
+    end
+
+    def sidekiq_args
+      args = %w(--environment production)
+      if queues.any?
+        args << '--queue'
+        args << queues.join(',')
+      end
+      args
+    end
+  end
+end

data/lib/cany/recipes/thin.rb

@@ -1,25 +1,31 @@
 require 'yaml'
 
-module Cany
-  module Recipes
-    # This recipes runs the application with the thin web server. At the moment it installs only a
-    # upstart start script. Other init scripts are planed (e.g. systemd for debian).
-    class Thin < WebServer
-      register_as :thin
+module Cany::Recipes
+  # This recipes install the thin ruby web server. It is registered
+  # and started as service.
+  #
+  # A simple thin configuration file (/etc/<application name>/thin.yml) is
+  # created and can be adjusted to the user needs.
+  #
+  # @see http://code.macournoyer.com/thin/ The project website for more
+  #   information about the project
+  # @note The receives relies that the 'thin' gem is included in your Gemfile
+  #   and therefore installed via bundler (and the bundler recipe).
+  class Thin < WebServer
+    register_as :thin
 
-      def launch_command
-        "thin start -C /etc/#{spec.name}/thin.yml"
-      end
+    def launch_command
+      %W(thin start -C /etc/#{spec.name}/thin.yml")
+    end
 
-      def binary
-        default_options = {
-            'environment' => 'production',
-            'socket' => "/var/run/#{spec.name}/sock",
-            'pid' => "/var/run/#{spec.name}/thin.pid"
-        }
-        install_content "/etc/#{spec.name}/thin.yml", default_options.to_yaml
-        super
-      end
+    def binary
+      default_options = {
+          'environment' => 'production',
+          'socket' => "/var/run/#{spec.name}/sock",
+          'pid' => "/var/run/#{spec.name}/thin.pid"
+      }
+      install_content "/etc/#{spec.name}/thin.yml", default_options.to_yaml
+      super
     end
   end
 end

data/lib/cany/recipes/unicorn.rb

@@ -0,0 +1,16 @@
+module Cany::Recipes
+  # This recipes install the Unicorn Rack HTTP server. It is registered
+  # and started as service.
+  #
+  # @see http://unicorn.bogomips.org/ The project website for more
+  #   information about the project
+  # @note The receives relies that the 'unicorn' gem is included in your
+  #   Gemfile and therefore installed via bundler (and the bundler recipe).
+  class Unicorn < WebServer
+    register_as :unicorn
+
+    def launch_command
+      %W(unicorn start -c /etc/#{spec.name}/unicorn.rb -E production)
+    end
+  end
+end

data/lib/cany/recipes/web_server.rb

@@ -2,25 +2,11 @@ module Cany
   module Recipes
     class WebServer < Recipe
       def binary
-        File.open File.join('debian', "#{spec.name}.upstart"), 'w' do |f|
-          f.write "description  \"#{spec.description}\"\n"
-
-          f.write "start on filesystem or runlevel [2345]\n"
-          f.write "stop on runlevel [!2345]\n"
-
-          f.write "respawn\n"
-          f.write "respawn limit 10 5\n"
-          f.write "umask 022\n"
-
-          f.write "chdir /usr/share/#{spec.name}\n"
-
-          f.write "pre-start script\n"
-          f.write "\tmkdir -p /var/run/#{spec.name}\n"
-          f.write "\tchown www-data /var/run/#{spec.name}\n"
-          f.write "end script\n"
-
-          f.write "exec su www-data --shell /usr/bin/#{spec.name} -- #{launch_command}\n"
-        end
+        recipe(:system).configure :service_pre_scripts, {
+          mkdir_run: "mkdir /var/run/#{spec.name}",
+          chown_run: "chown /var/run/#{spec.name}"
+        }
+        install_service name, ["/usr/bin/#{spec.name}"] + launch_command, user: 'www-data', group: 'www-data'
         inner.binary
       end
     end

data/lib/cany/specification.rb

@@ -6,16 +6,64 @@ module Cany
     EXT = 'canspec'
 
     attr_accessor :name, :description, :maintainer_name, :maintainer_email, :website, :licence, :version
-    attr_accessor :base_dir, :recipes
+    attr_accessor :base_dir, :recipes, :dependencies, :cany_version_constraint
     attr_accessor :build, :binary
 
     def initialize(dsl=Cany::Specification::DSL, &block)
       @recipes = []
+      @dependencies = []
       setup dsl, &block
     end
 
     def setup(dsl=Cany::Specification::DSL, &block)
       dsl.new(self).exec(&block)
     end
+
+    # @api public
+    # Return all dependencies needed to build this package
+    # @return [Array<Dependency>] A list of dependencies.
+    def build_dependencies
+      dependencies.select(&:build?)
+    end
+
+    # @api public
+    # Return all dependencies needed to build this package
+    # @return [Array<Dependency>] A list of dependencies.
+    def runtime_dependencies
+      dependencies.select(&:runtime?)
+    end
+
+    # Define the given recipe instance as system recipe. It can be accessed by other recipes under
+    # the system name and it is added as last recipe and do system specific things.
+    # At the moment the only recipe designed to work as system recipe is the DebHelperRecipe
+    # The attribute should be set after all recipe changes are over.
+    # @param recipe[Recipe] the system recipe instance
+    def system_recipe=(recipe)
+      @system_recipe = recipe
+      @recipes << recipe
+    end
+    # Return the system recipe for this specification.
+    # @return [Recipe] The system reciep
+    # @raise [NoSystemRecipe] if no system recipe was specified.
+    def system_recipe
+      raise NoSystemRecipe.new unless @system_recipe
+      @system_recipe
+    end
+
+    # @api private
+    # This method creates recipe instances for all required recipes from the given spec.
+    def setup_recipes
+      last_recipe = nil
+      recipes.reverse.each do |recipe|
+        recipe.inner = last_recipe unless last_recipe.nil?
+        last_recipe = recipe
+      end
+      recipes.map(&:prepare)
+    end
+
+    def to_s
+      "Cany::Specification<#{object_id}>(name=#{name}, recipes=[#{recipes.map(&:name).join(', ')}]"
+    end
+    alias_method :inspect, :to_s
   end
 end

data/lib/cany/specification/dsl.rb

@@ -6,7 +6,7 @@ module Cany
       end
 
       def exec(&block)
-        instance_eval &block
+        instance_eval(&block)
       end
 
       def self.delegate(*methods)
@@ -21,10 +21,21 @@ module Cany
 
       delegate :name, :description, :maintainer_name, :maintainer_email, :website, :licence, :version
 
+      # This directive ensures that Cany is used in a specific version. It will pass if the version
+      # match or raise an exception if it is an unsupported version.
+      # @param version [String] The version constrain the must be satisfied by Cany.
+      # @raise Cany::UnsupportedVersion on version mismatch
+      def require_cany(version)
+        unless Gem::Requirement.create(version).satisfied_by? Gem::Version.new(Cany::VERSION)
+          raise UnsupportedVersion.new version
+        end
+        @specification.cany_version_constraint = version
+      end
+
       # This include the given recipe into the build process.
       # @param [Symbol] name The name of the recipe as symbol.
-      def use(name)
-        @specification.recipes << name
+      def use(name, &block)
+        @specification.recipes << Cany::Recipe.from_name(name).new(@specification, &block)
       end
 
       def build(&block)
@@ -34,6 +45,15 @@ module Cany
       def binary(&block)
         @specification.binary = 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 Mixins::DependMixin
+      def depend(*args)
+        @specification.dependencies << create_dep(*args)
+      end
     end
   end
 end

data/lib/cany/version.rb

@@ -1,8 +1,8 @@
 module Cany
   module VERSION
     MAJOR = 0
-    MINOR = 0
-    PATCH = 2
+    MINOR = 1
+    PATCH = 0
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.')
     def self.to_s; STRING end

data/spec/cany/dependency_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Cany::Dependency do
+  let(:dep) { Cany::Dependency.new }
+  subject { dep.determine(distro, release) }
+  let(:distro) { :ubuntu }
+  let(:release) { :precise }
+
+  context 'without defined packages' do
+    it 'should return a empty list' do
+      expect(subject).to match_array []
+    end
+  end
+
+  context 'without distro information' do
+    context 'and a simple default package' do
+      before { dep.define_default('example') }
+      it 'should return the packages and nil as version' do
+        expect(subject).to match_array [['example', nil]]
+      end
+    end
+
+    context 'and a default package with version' do
+      before { dep.define_default('example', '>= 1.7') }
+      it 'should return the packages and its version' do
+        expect(subject).to match_array [['example', '>= 1.7']]
+      end
+    end
+
+    context 'with multiple default packages' do
+      before do
+        dep.define_default('example')
+        dep.define_default('otto')
+      end
+      it 'should return all default packages' do
+        expect(subject).to match_array [['otto', nil], ['example', nil]]
+      end
+    end
+  end
+
+  context 'with distribution default packages' do
+    before { dep.define_on_distro(distro, 'hans') }
+
+    it 'should return distro packages' do
+      expect(subject).to match_array [['hans', nil]]
+    end
+
+    context 'and with default packages' do
+      before { dep.define_default('default') }
+      it 'should only return distro package' do
+        expect(subject).to match_array [['hans', nil]]
+      end
+    end
+
+    context 'and a second distro package' do
+      before { dep.define_on_distro(distro, 'otto') }
+      it 'should return both packages' do
+        expect(subject).to match_array [['hans', nil], ['otto', nil]]
+      end
+    end
+  end
+
+  context 'with distribution release information' do
+    before { dep.define_on_distro_release(distro, release, 'distrorelease') }
+    it 'should return distro release packages' do
+      expect(subject).to match_array [['distrorelease', nil]]
+    end
+
+    context 'with additional distrorelease packages with version' do
+      before { dep.define_on_distro_release(distro, release, 'add', '!= 2.8') }
+      it 'should return both packages with its version or nil' do
+        expect(subject).to match_array [['distrorelease', nil], ['add', '!= 2.8']]
+      end
+    end
+
+    context 'with distro packages' do
+      before { dep.define_on_distro(distro, 'other') }
+      it 'should return only distrorelease packages' do
+        expect(subject).to match_array [['distrorelease', nil]]
+      end
+    end
+  end
+
+  context 'situations property' do
+    subject { dep.situations }
+    it 'should be runtime per default' do
+      should match_array [:runtime]
+    end
+
+    context 'set to single value' do
+      before { dep.situations = :build }
+      it 'should convert them to an array' do
+        should match_array [:build]
+      end
+    end
+
+    context 'set to multiple values' do
+      before { dep.situations = [:build, :runtime] }
+      it 'should remain the array' do
+        should match_array [:build, :runtime]
+      end
+    end
+
+    context 'accessabled via shortcut properties' do
+      subject { dep }
+      it 'should be runtime and not build per default' do
+        should be_runtime
+        should_not be_build
+      end
+
+      context 'with changed value' do
+        before { dep.situations = [:build, :hans] }
+        it 'should behave accordingly' do
+          should_not be_runtime
+          should be_build
+        end
+      end
+    end
+  end
+end

data/spec/cany/dpkg/builder_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Cany::Dpkg::Builder do
+  let!(:dir) { Dir.mktmpdir }
+  after { FileUtils.remove_entry dir}
+  let(:spec) do
+    s = Cany::Specification.new do
+      name 'dpkg-creator-test'
+      version '0.1'
+      description 'Test Project'
+      maintainer_name 'Hans Otto'
+      maintainer_email 'hans.otto@example.org'
+      website 'http://example.org'
+      licence 'GPL-2+'
+    end
+    s.base_dir = dir
+    s
+  end
+  let(:builder) { Cany::Dpkg::Builder.new(spec) }
+
+  describe '#run' do
+    subject { builder.run 'clean' }
+    it 'should set system_recipe' do
+      expect(spec).to receive(:system_recipe=).with(kind_of(Cany::Dpkg::DebHelperRecipe)).and_call_original
+      subject
+    end
+
+    it 'should setup recipes' do
+      expect(spec).to receive(:setup_recipes).and_call_original
+      subject
+    end
+
+    it 'should call delegate the clean action to the loaded recipes' do
+      expect_any_instance_of(Cany::Dpkg::DebHelperRecipe).to receive(:clean)
+      subject
+    end
+  end
+end