deploy-context 2.2.0.3.gec16643.4.g20d2d42.4.g17e8559.12.g831d0a8.4.gbb2ab14.12.g0bc028d → 2.13.0

data/libraries/deploy-context/deploy/ruby.rb

@@ -18,7 +18,7 @@ module Context
       def ruby_release(context)
         context.git_build(context)
         # gem ["push #{context.context_name}-#{GVB.version}.gem"]
-        # context.patch_bump if gem_installed?(context)
+        # context.patch_bump if gem_installed?(context, context.context_name)
         context.rake context, ['release']
         # context.commit
       end
@@ -47,23 +47,48 @@ module Context
         # sleep(60)
       end
 
-      def gem_installed?(context)
-        installed_version = Gem::Specification.find_by_name(context.context_name).version
-        puts "Compare #{context.context_name} installed_version #{installed_version} with #{context.version} in folder #{context.context_folder}"
-        installed = installed_version == context.version
+      def gem_installed?(context, gemname, compare_version = nil)
+        begin
+          installed_version = Gem::Specification.find_by_name(gemname)
+        rescue Gem::MissingSpecError => e
+          context.error_log(context, "The gem '#{gemname}' is missing")
+          # sleep(5)
+          installed_version = nil
+        rescue Exception => e
+          context.error_log(context, "The gem '#{gemname}' got issue with #{e}")
+          sleep(5)
+          installed_version = nil
+        end
+        # context.log("Compare #{context.context_name} installed_version #{installed_version} with #{context.version} in folder #{context.context_folder}")
+        installed = if compare_version.nil? || installed_version.nil?
+          not installed_version.nil?
+        else
+          installed_version.version == context.version
+        end
         puts "installed = #{installed}"
         installed
       end
 
+      def load_dependency(context, gemname, require_file)
+        context.gem(context, ['install', gemname]) unless context.gem_installed?(context, gemname)
+        context.log("Loading file #{require_file} for gem #{gemname}")
+        sleep 3
+        require require_file
+      end
+
+      def load_all_dependencies(context)
+        context.load_dependencies
+      end
+
       def ruby_cycle(context)
         context.log "\n\nBuilding Ruby application for #{context.context_name}"
         if context.new_update_available?
           context.log "\n\nNew update available for #{context.context_name}\nCleaning the building space"
           context.clean
-          if git_dirty_state?(context)
-            context.patch_bump
-            context.commit
-          end
+          # if git_dirty_state?(context)
+          #   context.patch_bump
+          #   context.commit
+          # end
           context.log "\n\nBuilding project #{context.context_name} now ..."
           context.build
           # context.commit

data/libraries/deploy-context/habitat-studio.rb

@@ -0,0 +1,38 @@
+require_relative 'cookbook-studio'
+
+module Context
+  class HabitatStudio < CookbookStudio
+    def initialize(organisation_name, context_name, deploycontext_folder)
+      super(organisation_name, context_name, deploycontext_folder)
+    end
+    
+    # 4
+    def do_clean
+      super
+      delete_file_only_if_exist(get_context_file(self, 'respond.txt'))
+      true
+    end
+
+    # 9
+    def do_install
+      super
+      Dir.chdir context_folder
+      start_habitat_job(self)
+      true
+    end
+    
+    # 11
+    def do_end
+      super
+      promote_habitat(self)
+    end
+    
+    def do_build_in_habitat
+      build_habitat(self)
+    end
+  
+    def do_promote
+      promote_habitat(self)
+    end
+  end
+end

data/libraries/deploy-context/helpers/command.rb

@@ -21,18 +21,17 @@ module Context
     end
 
     def temp_dir
-      @temp_dir = Dir.tmpdir() if @temp_dir.nil?
-      @temp_dir
+      File.join(context_folder, 'results')
     end
 
-    def get_data(command_line)
+    def get_shell_data(command_line)
       debug_log "Get data from command #{command_line.join(' ')}"
       `#{command_line.join(' ')}`
     end
 
     def execute_command(command)
       command_status = system(command.join(' '))
-      debug_log "executed command #{command.join(' ')}"
+      log "executed command #{command.join(' ')}"
       command_status
     end
 
@@ -50,5 +49,9 @@ module Context
       ::File.write(file, content)
       system("chmod 644 #{file}") unless Gem.win_platform?
     end
+
+    def delete_file_only_if_exist(file)
+      FileUtils.rm file if File.exist? file
+    end
   end
 end

data/libraries/deploy-context/helpers/rake_tasks.rb

@@ -1,54 +1,158 @@
-require 'rubygems'
-require 'bundler'
+module Context
+  module RakeTasks
+    def load_public_dependencies
+      require 'rubygems'
+      require 'bundler'
+      # require 'bundler/setup'
+      # require 'bundler/installer'
+      
+      require 'rdoc/task'
+      
+      require 'git-version-bump/rake-tasks'
+      
+      require 'cucumber'
+      require 'cucumber/rake/task'
 
-Bundler::GemHelper.install_tasks
+      require_relative '../../deploy-context'
+    end
 
-require 'rdoc/task'
+    def define_deploy_context_tasks
+      load_public_dependencies
+      Bundler::GemHelper.install_tasks
 
-Rake::RDocTask.new do |rd|
-	rd.main = "README.md"
-	rd.title = 'deploy-context'
-	rd.rdoc_files.include("README.md", "lib/**/*.rb")
-end
+      Rake::RDocTask.new do |rd|
+        rd.main = "README.md"
+        rd.title = 'deploy-context'
+        rd.rdoc_files.include("README.md", "lib/**/*.rb")
+      end
 
-require 'git-version-bump/rake-tasks'
+      namespace :deploycontext do
+        task :default => "deploycontext:test" do
+          Context::DeployContext.deployer.cycle
+        end
 
-require 'rubygems'
-require 'cucumber'
-require 'cucumber/rake/task'
+        task :bump => "deploycontext:commit" do
+          Context::DeployContext.deployer.bump
+        end
 
-require_relative '../../deploy-context'
+        task :test => "deploycontext:help" do
+          Context::DeployContext.deployer.test
+        end
 
-namespace :deploycontext do
-  task :default => "deploycontext:test" do
-    Context::DeployContext.deployer.execute_action(Context::DeployContext.deployer, 'cycle')
-  end
+        task :release => "deploycontext:commit"  do
+          Context::DeployContext.deployer.release
+        end
 
-  task :bump do
-    Context::DeployContext.deployer.execute_action(Context::DeployContext.deployer, 'bump')
-  end
+        task :commit => "deploycontext:default" do
+          Context::DeployContext.deployer.commit
+        end
 
-  task :test => "deploycontext:help" do
-    Context::DeployContext.deployer.execute_action(Context::DeployContext.deployer, 'test')
-  end
+        task :push => "deploycontext:commit" do
+          Context::DeployContext.deployer.push
+        end
 
-  task :release => "deploycontext:default"  do
-    Context::DeployContext.deployer.execute_action(Context::DeployContext.deployer, 'release')
-  end
+        task :help do
+          Context::DeployContext.deployer.help
+        end
 
-  task :help do
-    Context::DeployContext.deployer.execute_action(Context::DeployContext.deployer, 'help')
-  end
+        namespace :studio do
+          task :promote  => "deploycontext:studio:release" do
+            Context::DeployContext.deployer.do_promote
+          end
 
-  namespace :features do
-    Cucumber::Rake::Task.new(:strict) do |t|
-      t.cucumber_opts = "--format pretty" # Any valid command line option can go here.
-      t.profile = "strict"
-    end
-  
-    Cucumber::Rake::Task.new(:html_report) do |t|
-      t.cucumber_opts = "--format pretty" # Any valid command line option can go here.
-      t.profile = "html_report"
+          task :build  => "deploycontext:studio:habitat" do
+            Context::DeployContext.deployer.do_build
+          end
+
+          task :install  => "deploycontext:studio:build" do
+            Context::DeployContext.deployer.do_install
+          end
+
+          task :release  => "deploycontext:studio:install" do
+            Context::DeployContext.deployer.do_release
+          end
+
+          task :habitat do
+            Context::DeployContext.deployer.do_build_in_habitat
+          end
+
+          task :kitchen do
+            Context::DeployContext.deployer.test_with_kitchen
+          end
+        end
+
+        namespace :plan do
+          task :do_mix_cookbook do
+            Context::DeployContext.deployer.do_mix_cookbook
+          end
+
+          task :do_begin do
+            Context::DeployContext.deployer.do_begin
+          end
+
+          task :do_download do
+            Context::DeployContext.deployer.do_download
+          end
+
+          task :do_verify do
+            Context::DeployContext.deployer.do_verify
+          end
+
+          task :do_clean do
+            Context::DeployContext.deployer.do_clean
+          end
+
+          task :do_unpack do
+            Context::DeployContext.deployer.do_unpack
+          end
+
+          task :do_prepare do
+            Context::DeployContext.deployer.do_prepare
+          end
+
+          task :do_build do
+            Context::DeployContext.deployer.do_build
+          end
+
+          task :do_check do
+            Context::DeployContext.deployer.do_check
+          end
+
+          task :do_install do
+            Context::DeployContext.deployer.do_install
+          end
+
+          task :do_strip do
+            Context::DeployContext.deployer.do_strip
+          end
+
+          task :do_end do
+            Context::DeployContext.deployer.do_end
+          end
+        end
+
+        namespace :deployer do
+          task :cookbook do
+            Context::DeployContext.deployer.cookbook_test(Context::DeployContext.deployer)
+          end
+
+          task :cucumber do
+            Context::DeployContext.deployer.cucumber_test(Context::DeployContext.deployer)
+          end
+        end
+
+        namespace :features do
+          Cucumber::Rake::Task.new(:strict) do |t|
+            t.cucumber_opts = "--format pretty" # Any valid command line option can go here.
+            t.profile = "strict"
+          end
+        
+          Cucumber::Rake::Task.new(:html_report) do |t|
+            t.cucumber_opts = "--format pretty" # Any valid command line option can go here.
+            t.profile = "html_report"
+          end
+        end
+      end
     end
   end
 end

data/libraries/deploy-context/ruby-studio.rb

@@ -0,0 +1,24 @@
+require_relative 'default-studio'
+
+module Context
+  class RubyStudio < DefaultStudio
+    def initialize(organisation_name, context_name, deploycontext_folder)
+      super(organisation_name, context_name, deploycontext_folder)
+    end
+
+    # 2
+    def do_download
+      super
+      do_clean
+      system('bundle install')
+      true
+    end
+    
+    # 4
+    def do_clean
+      super
+      delete_file_only_if_exist(get_context_file(self, 'Gemfile.lock'))
+      true
+    end
+  end
+end

data/libraries/deploy-context/steps/deploy.rb

@@ -0,0 +1,53 @@
+
+module Context
+  module Steps
+    module Deploy
+      def define_steps
+        # Étantdonnéque('le projet {word} à une dernière version de disponible dans git') do |project_name|
+        #   context_exec [project_name, 'cycle']
+          
+        #   if project_name == deployer.context_name
+        #     Dir.chdir deployer.context_folder
+        #   else
+        #     Dir.chdir File.join(deployer.contexts_container(deployer), project_name)
+        #   end
+        # end
+
+        Alors('démarrer un simple cycle de {word}') do |project_name|
+          pending
+          context_exec [project_name, 'cycle'] || abort("#{project_name} ERROR: Issue with life cycle")
+        end
+
+        Alors('déployer le projet {word}') do |project_name|
+          pending
+          context_exec [project_name, 'release'] || abort("#{project_name} ERROR: Issue with deploy steps")
+        end
+
+        Alors('tester le projet {word}') do |project_name|
+          pending
+          context_exec [project_name, 'test'] || abort("#{project_name} ERROR: Issue with testing steps")
+        end
+
+        Étantdonnéque('le projet {word} à du code à updater') do |project_name|
+          pending
+          context_exec [project_name, 'check_code_to_update'] || abort("#{project_name} ERROR: Issue to check updated code")
+        end
+
+        Alors('bumper la version du patch de {word}') do |project_name|
+          pending
+          # context_exec [project_name, 'bump'] || abort("#{project_name} ERROR: Issue with bumping version")
+        end
+
+        Étantdonnéque('le projet {word} à la bonne version d\'installer') do |project_name|
+          pending
+          context_exec [project_name, 'check_installed_version'] || abort("#{project_name} ERROR: Issue to check installed version")
+        end
+
+        Étantdonnéque('le projet {word} à une nouvelle version de disponible') do |project_name|
+          pending
+          context_exec [project_name, 'check_new_version'] || abort("#{project_name} ERROR: Issue to check newer version available")
+        end
+      end
+    end
+  end
+end

data/libraries/deploy-context/studio/base.rb

@@ -0,0 +1,155 @@
+module Context
+  module Studio
+    module Base
+      def help
+        show_help(self)
+      end
+
+      def test
+        log "\nExecute tests\n"
+        log "\n\nTest result: #{test_context_successful?}\n"
+      end
+    
+      def version
+        # do_prepare unless defined?(GitVersionBump)
+        # log "Getting version info for #{context_folder} and version should be #{GitVersionBump.version(true)}"
+        if defined?(GitVersionBump)
+          Gem::Version.new(GitVersionBump.version(true))
+        else
+          cookbook_version
+        end
+      end
+
+      def test_context_successful?
+        log "Check if #{context_name} is install #{version}"
+        
+        if cookbook_test_successful?(self) && cucumber_test_successful?(self) && gem_installed?(self, context_name, version)
+          log "Test context #{context_name} was successfully perform on version #{version}"
+          true
+        else
+          log "Test context #{context_name} has failed to perform #{version}"
+          false
+        end
+      end
+
+      # def cycle
+      #   ruby_cycle(self)
+      # end
+
+      # def build
+      #   ruby_build(self)
+      #   cookbook_build(self)
+      #   build_habitat(self)
+      # end
+
+      # def commit
+      #   cookbook_install(self)
+      #   git_commit(self)
+      # end
+
+      # def push
+      #   commit
+      #   git_release(self)
+      # end
+
+      # def release
+      #   log "\n\nRelease #{context_name} at version #{version}"
+      #   cookbook_push(self)
+      #   ruby_release(self)
+      #   git_release(self)
+      #   start_habitat_job(self)
+      # end
+
+      # def install
+      #   ruby_install(self)
+      # end
+
+      # def clean
+      #   clean_folder(self, 'contexts')
+      #   ruby_clean(self)
+      #   cookbook_clean(self)
+      # end
+
+      # def patch_bump
+      #   GitVersionBump.tag_version("#{GitVersionBump.major_version(true)}.#{GitVersionBump.minor_version(true)}.#{GitVersionBump.patch_version(true) + 1}")
+      #   show_new_version('Patch')
+      # end
+
+      # def minor_bump
+      #   GitVersionBump.tag_version("#{GitVersionBump.major_version(true)}.#{GitVersionBump.minor_version(true) + 1}.0")
+      #   show_new_version('Minor')
+      # end
+
+      # def major_bump
+      #   GitVersionBump.tag_version("#{GitVersionBump.major_version(true) + 1}.0.0")
+      #   show_new_version('Major')
+      # end
+
+      # def wait_until_release_available
+      #   wait_until_release_available unless is_present_publicly?
+      # end
+
+      def load_dependencies
+        require 'simplecov_setup'
+        require 'git-version-bump'
+        require 'cucumber'
+        require 'cucumber/cli/main'
+        require 'cucumber/rspec/disable_option_parser'
+      end
+
+      # def test
+      #   log "\nExecute tests\n"
+      #   log "\n\nTest result: #{test_context_successful?}\n"
+      # end
+    end
+  end
+end
+
+
+          # case action
+          # when 'cycle'
+          #   context.log "\nExecute only the cycle once\n"
+          #   context.cycle
+          #   true
+          # when 'agent'
+          #   context.log "\nAlways in execution\n"
+          #   while true do
+          #     context.cycle
+          #   end
+          #   true
+          # when 'commit'
+          #   context.log "\nBump minor version\n"
+          #   context.commit
+          #   true
+          # when 'push'
+          #   context.log "\nBump minor version\n"
+          #   context.push
+          #   true
+          # when 'bump'
+          #   context.log "\nBump minor version\n"
+          #   context.patch_bump
+          #   true
+          # when 'release'
+          #   context.log "\nBump major version\n"
+          #   context.minor_bump
+          #   true
+          # when 'upgrade'
+          #   context.log "\nBump major version\n"
+          #   context.major_bump
+          #   true
+          # when 'test'
+          #   context.log "\nExecute tests\n"
+          #   context.test_context_successful?
+          # when 'reset'
+          #   context.log "\nReset versionning\n"
+          #   system('rake')
+          #   # context.cucumber_test(deployer)
+          #   true
+          # when 'help'
+          #   context.show_help(context)
+          #   true
+          # else
+          #   context.error_log context.context_name, "Unknown setting #{action}"
+          #   show_help(context)
+          #   false
+          # end

data/libraries/deploy-context/studio/default.rb

@@ -0,0 +1,65 @@
+require_relative 'base'
+
+module Context
+  module Studio
+    module Default
+      def actions_permitted
+        %w(
+          do_begin
+          do_download
+          do_verify
+          do_clean
+          do_unpack
+          do_prepare
+          do_build
+          do_check
+          do_install
+          do_strip
+          do_end
+          help
+          do_build_in_habitat
+          do_promote
+        )
+      end
+
+      def do_mix_cookbook
+        mix_run_list(self, context_name)
+      end
+
+      # 4
+      def do_clean
+        delete_file_only_if_exist(get_context_file(self, 'respond.txt'))
+        true
+      end
+      
+      # 6
+      def do_prepare
+        # load_dependencies
+        git_build(self)
+      end
+      
+      # 7
+      def do_build
+        git_commit(self)
+      end
+      
+      # 8
+      def do_check
+      end
+      
+      # 9
+      def do_install
+        ruby_release(self)
+        true
+      end
+      
+      # 10
+      # def do_strip
+      # end
+      
+      # 11
+      def do_end
+      end
+    end
+  end
+end

data/libraries/deploy-context/studio/deployer.rb

@@ -0,0 +1,20 @@
+module Context
+  module Studio
+    module Deployer
+      def self.set(deployer_class)
+        @deployer = deployer_class if @deployer.nil?
+        @deployer
+      end
+
+      def self.method_missing(method_name, *argv, &block)
+        puts "Searching method #{method_name} in context #{@deployer}"
+        is_deploy_context_respond_to_action = @deployer.respond_to?(method_name) && @deployer.actions_permitted?(method_name.to_s)
+        if is_deploy_context_respond_to_action
+          @deployer.execute_action(@deployer, method_name)
+        else
+          puts "\n\nUnavailable action '#{method_name}' for context #{@deployer.context_name} as #{@deployer.respond_to?(method_name)} and #{@deployer.actions_permitted?(method_name)} for #{@deployer.class}\n"
+        end
+      end
+    end
+  end
+end

data/libraries/deploy-context.rb

@@ -1,21 +1,17 @@
-require_relative 'deploy-context/deploy'
-require_relative 'deploy-context/deploy/ruby'
-require_relative 'deploy-context/deploy/cucumber'
-require_relative 'deploy-context/deploy/cookbook'
+require_relative 'context-manager'
 
 module Context
-  class DeployContext < Deploy
-    include DeployHelpers::RubyHelper
-    include DeployHelpers::CucumberHelper
-    include DeployHelpers::CookbookHelper
-
-    def self.deployer
-      @deployer = Context::DeployContext.new(Dir.pwd) if @deployer.nil?
-      @deployer
+  class DeployContext < Manager
+    def self.deployer(origin_folder = ENV.key?('DEPLOYCONTEXTFOLDER') ? ENV['DEPLOYCONTEXTFOLDER'] : Dir.pwd)
+      Studio::Deployer.set(DeployContext.new(origin_folder))
+      Studio::Deployer
     end
 
     def initialize(deploycontext_folder)
-      super('deploy-context', deploycontext_folder)
+      super('jimbodragon', 'deploy-context', deploycontext_folder)
+      @rubystudio = RubyStudio.new(organisation_name, context_name, deploycontext_folder)
+
+      abort("No context_name :(") if context_name.nil? || context_name.empty?
     end
   end
 end