rake_task.rb in dockly-3.0.0

- old
+ new
@@ -1,173 +1,168 @@
 require 'rake'
 require 'dockly'
 
-class Rake::DebTask < Rake::Task
-  def needed?
-    raise "Package does not exist" if package.nil?
-    !!ENV['FORCE'] || !package.exists?
-  end
+module Dockly::RakeHelper
+  module_function
 
-  def package
-    Dockly::Deb[name.split(':').last.to_sym]
+  def find_deb!(name)
+    deb = Dockly.debs[name]
+    raise "No deb named #{name}" if deb.nil?
+    deb
   end
-end
 
-class Rake::RpmTask < Rake::Task
-  def needed?
-    raise "Package does not exist" if package.nil?
-    !!ENV['FORCE'] || !package.exists?
+  def find_docker!(name)
+    docker = Dockly.dockers[name]
+    raise "No docker named #{name}" if docker.nil?
+    docker
   end
 
-  def package
-    Dockly::Rpm[name.split(':').last.to_sym]
+  def find_rpm!(name)
+    rpm = Dockly.rpms[name]
+    raise "No rpm named #{name}" if rpm.nil?
+    rpm
   end
 end
 
-class Rake::DockerTask < Rake::Task
-  def needed?
-    raise "Docker does not exist" if docker.nil?
-    !docker.exists?
+namespace :dockly do
+  # Dockly needs to be able to perform HTTP requests, and unfortunately for us
+  # WebMock is enabled by default.
+  task :enable_http do
+    if defined?(WebMock::HttpLibAdapters::NetHttpAdapter)
+      WebMock::HttpLibAdapters::NetHttpAdapter.disable!
+    end
   end
 
-  def docker
-    Dockly::Docker[name.split(':').last.to_sym]
+  task :load do
+    raise "No #{Dockly.load_file} found!" unless File.exist?(Dockly.load_file)
+    Dockly.inst
   end
-end
 
-module Rake::DSL
-  def deb(*args, &block)
-    Rake::DebTask.define_task(*args, &block)
+  task :assume_role => 'dockly:load' do
+    Dockly.perform_role_assumption
   end
 
-  def rpm(*args, &block)
-    Rake::RpmTask.define_task(*args, &block)
-  end
+  task :init => ['dockly:enable_http', 'dockly:load', 'dockly:assume_role']
 
-  def docker(*args, &block)
-    Rake::DockerTask.define_task(*args, &block)
-  end
-end
+  namespace :deb do
+    task :prepare, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper.find_deb!(args[:name]).create_package!
+    end
 
-namespace :dockly do
-  task :load do
-    raise "No dockly.rb found!" unless File.exist?('dockly.rb')
-  end
+    task :upload, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper.find_deb!(args[:name]).upload_to_s3
+    end
 
-  prepare_targets = []
-  upload_targets = []
-  build_targets = []
-  copy_targets = []
+    task :copy, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper
+        .find_deb!(args[:name])
+        .copy_from_s3(Dockly::History.duplicate_build_sha[0..6])
+    end
 
-  namespace :deb do
-    Dockly.debs.values.each do |inst|
-      namespace :prepare do
-        task inst.name => 'dockly:load' do |name|
-          inst.create_package!
-        end
-      end
+    task :build, [:name] => 'dockly:init' do |t, args|
+      deb = Dockly::RakeHelper.find_deb!(args[:name])
+      deb.build unless deb.exists?
+    end
+  end
 
-      namespace :upload do
-        deb inst.name => 'dockly:load' do |name|
-          inst.upload_to_s3
-        end
-      end
+  namespace :rpm do
+    task :prepare, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper.find_rpm!(args[:name]).create_package!
+    end
 
-      namespace :copy do
-        task inst.name => 'dockly:load' do |name|
-          inst.copy_from_s3(Dockly::History.duplicate_build_sha[0..6])
-        end
-      end
+    task :upload, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper.find_rpm!(args[:name]).upload_to_s3
+    end
 
-      deb inst.name => 'dockly:load' do |name|
-        inst.build
-      end
+    task :copy, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper
+        .find_rpm!(args[:name])
+        .copy_from_s3(Dockly::History.duplicate_build_sha[0..6])
+    end
 
-      prepare_targets << "dockly:deb:prepare:#{inst.name}"
-      upload_targets << "dockly:deb:upload:#{inst.name}"
-      copy_targets << "dockly:deb:copy:#{inst.name}"
-      build_targets << "dockly:deb:#{inst.name}"
+    task :build, [:name] => 'dockly:init' do |t, args|
+      rpm = Dockly::RakeHelper.find_rpm!(args[:name])
+      rpm.build unless rpm.exists?
     end
   end
 
-  namespace :rpm do
-    Dockly.rpms.values.each do |inst|
-      namespace :prepare do
-        task inst.name => 'dockly:load' do |name|
-          inst.create_package!
-        end
-      end
+  namespace :docker do
+    task :prepare, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper.find_docker!(args[:name]).generate_build
+    end
 
-      namespace :upload do
-        rpm inst.name => 'dockly:load' do |name|
-          inst.upload_to_s3
-        end
-      end
+    task :upload, [:name] => 'dockly:init' do |t, args|
+      docker = Dockly::RakeHelper.find_docker!(args[:name])
+      docker.export_only unless docker.exists?
+    end
 
-      namespace :copy do
-        task inst.name => 'dockly:load' do |name|
-          inst.copy_from_s3(Dockly::History.duplicate_build_sha[0..6])
-        end
-      end
+    task :copy, [:name] => 'dockly:init' do |t, args|
+      Dockly::RakeHelper
+        .find_docker!(args[:name])
+        .copy_from_s3(Dockly::History.duplicate_build_sha[0..6])
+    end
 
-      rpm inst.name => 'dockly:load' do |name|
-        inst.build
-      end
+    task :build, [:name] => 'dockly:init' do |t, args|
+      docker = Dockly::RakeHelper.find_docker!(args[:name])
+      docker.generate! unless docker.exists?
+    end
+  end
 
-      prepare_targets << "dockly:rpm:prepare:#{inst.name}"
-      upload_targets << "dockly:rpm:upload:#{inst.name}"
-      copy_targets << "dockly:rpm:copy:#{inst.name}"
-      build_targets << "dockly:rpm:#{inst.name}"
+  task :prepare_all => 'dockly:init' do
+    Dockly.debs.keys.each do |deb|
+      Rake::Task['dockly:deb:prepare'].tap(&:reenable).invoke(deb)
     end
+
+    Dockly.rpms.values.each do |rpm|
+      Rake::Task['dockly:rpm:prepare'].tap(&:reenable).invoke(rpm)
+    end
+
+    Dockly.dockers.values.each do |docker|
+      Rake::Task['dockly:docker:prepare'].tap(&:reenable).invoke(docker)
+    end
   end
 
-  namespace :docker do
-    Dockly.dockers.values.each do |inst|
-      # For backwards compatibility
-      namespace :noexport do
-        task inst.name => "dockly:docker:prepare:#{inst.name}"
-      end
+  task :upload_all => 'dockly:init' do
+    Dockly.debs.keys.each do |deb|
+      Rake::Task['dockly:deb:upload'].tap(&:reenable).invoke(deb)
+    end
 
-      namespace :prepare do
-        task inst.name => 'dockly:load' do
-          Thread.current[:rake_task] = inst.name
-          inst.generate_build
-        end
-      end
+    Dockly.rpms.keys.each do |rpm|
+      Rake::Task['dockly:rpm:upload'].tap(&:reenable).invoke(rpm)
+    end
 
-      namespace :upload do
-        docker inst.name => 'dockly:load' do
-          Thread.current[:rake_task] = inst.name
-          inst.export_only
-        end
-      end
+    Dockly.dockers.keys.each do |docker|
+      Rake::Task['dockly:docker:upload'].tap(&:reenable).invoke(docker)
+    end
+  end
 
-      namespace :copy do
-        task inst.name => 'dockly:load' do
-          Thread.current[:rake_task] = inst.name
-          inst.copy_from_s3(Dockly::History.duplicate_build_sha[0..6])
-        end
-      end
+  task :build_all => 'dockly:init' do
+    Dockly.debs.keys.each do |deb|
+      Rake::Task['dockly:deb:build'].tap(&:reenable).invoke(deb)
+    end
 
-      docker inst.name => 'dockly:load' do
-        Thread.current[:rake_task] = inst.name
-        inst.generate!
-      end
+    Dockly.rpms.keys.each do |rpm|
+      Rake::Task['dockly:rpm:build'].tap(&:reenable).invoke(rpm)
+    end
 
-      # Docker image will be generated by 'dockly:deb:package'
-      unless inst.s3_bucket.nil?
-        prepare_targets << "dockly:docker:prepare:#{inst.name}"
-        upload_targets << "dockly:docker:upload:#{inst.name}"
-        copy_targets << "dockly:docker:copy:#{inst.name}"
-        build_targets << "dockly:docker:#{inst.name}"
-      end
+    Dockly.dockers.keys.each do |docker|
+      Rake::Task['dockly:docker:build'].tap(&:reenable).invoke(docker)
     end
   end
 
-  multitask :prepare_all => prepare_targets
-  multitask :upload_all => upload_targets
-  multitask :build_all => build_targets
-  multitask :copy_all => copy_targets
+  task :copy_all => 'dockly:init' do
+    Dockly.debs.keys.each do |deb|
+      Rake::Task['dockly:deb:copy'].tap(&:reenable).invoke(deb)
+    end
+
+    Dockly.rpms.keys.each do |rpm|
+      Rake::Task['dockly:rpm:copy'].tap(&:reenable).invoke(rpm)
+    end
+
+    Dockly.dockers.keys.each do |docker|
+      Rake::Task['dockly:docker:copy'].tap(&:reenable).invoke(docker)
+    end
+  end
 
   task :build_or_copy_all do
     if Dockly::History.duplicate_build?
       Rake::Task['dockly:copy_all'].invoke
     else