deploy-context 2.13.23 → 2.13.25

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/chef.rb

@@ -0,0 +1,57 @@
+module Context
+  module DeployHelpers
+    module ChefHelper
+      def prepare_workplan
+        FileUtils.mkdir 'workstation-space' unless Dir.exist?('workstation-space')
+        prepare_chef
+        prepare_gem
+        prepare_ssh
+        prepare_git
+      end
+
+      def prepare_chef
+        FileUtils.cp_r '/etc/chef', 'workstation-space/chef-client'
+
+        chef_user_keys_folder = 'workstation-space/chef_user_keys'
+
+        FileUtils.mkdir chef_user_keys_folder unless Dir.exist?(chef_user_keys_folder)
+
+        FileUtils.cp File.join(ENV['HOME'],'.chef/credentials'), 'workstation-space/chef_credentials'
+        client_keys = File.read('workstation-space/chef_credentials').split("\n").select do |line_str|
+          line_str.include?('client_key')
+        end
+        client_keys.each do |key_line|
+          key_file = key_line.split('=')[1].strip.split("'")[1]
+          debug_context_log 'Knife keys', "Copy file #{key_file} to #{chef_user_keys_folder}"
+          FileUtils.cp key_file, File.join(chef_user_keys_folder, File.basename(key_file))
+        end
+      end
+
+      def prepare_gem
+        FileUtils.cp File.join(ENV['HOME'],'.local/share/gem/credentials'), 'workstation-space/gem_credentials'
+      end
+
+      def prepare_ssh
+        FileUtils.cp_r File.join(ENV['HOME'],'.ssh'), 'workstation-space/ssh'
+      end
+
+      def prepare_git
+        FileUtils.cp File.join(ENV['HOME'],'.gitconfig'), 'workstation-space/gitconfig'
+      end
+
+      def generate_user_json
+        warning_context_log 'Habitat origin secrets', JSON.pretty_generate({
+          HAB_STUDIO_SECRET_CHEF_SERVER_URL: 'https://api.chef.io/organizations/jimbodragon',
+          HAB_STUDIO_SECRET_CHEFVALIDATORKEY: File.read('workstation-space/chef-client/validation.pem'),
+          HAB_STUDIO_SECRET_SSHPRIVATEKEY: File.read('workstation-space/ssh/id_rsa'),
+          HAB_STUDIO_SECRET_SSHPUBLICKEY: File.read('workstation-space/ssh/id_rsa.pub'),
+          HAB_STUDIO_SECRET_CLIENT_NAME: 'jprovencher',
+          HAB_STUDIO_SECRET_CLIENT_KEY: File.read('workstation-space/chef_user_keys/jprovencher.pem'),
+          HAB_STUDIO_SECRET_GEMAPI: File.read('workstation-space/gem_credentials'),
+          HAB_STUDIO_SECRET_EMAIL: 'jimmy.provencher@hotmail.ca',
+          HAB_STUDIO_SECRET_FULLNAME: 'Jimmy Provencher'
+        })
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/context.rb

@@ -0,0 +1,42 @@
+module Context
+  module DeployHelpers
+    module ContextHelper
+      def present_localy?
+        Dir.exist?(context_folder)
+      end
+
+      def shorten_version(context)
+        context. debug_context_log "Shorten Version", "Getting shorten version #{context.version}"
+        context.version.canonical_segments[0..2].join('.')
+      end
+
+      def actual_working_directory?
+        Dir.pwd == context_folder
+      end
+  
+      def move_folder(folder)
+        @context_folder = folder.include?(context_name) ? folder : File.join(folder, context_name)
+      end
+  
+      def check_folder(folder)
+        FileUtils.mkdir_p(context_folder) unless present_localy?
+      end
+  
+      def show_new_version(level)
+        context_log "#{level} bump #{context_name} at newer version #{version}"
+      end
+  
+      def is_present_publicly?
+        ruby_check_if_available_public(self)
+      end
+  
+      def new_update_available?
+        git_update_available?(self)
+      end
+  
+      def ready_for_major_update?
+        false
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/cookbook.rb

@@ -0,0 +1,121 @@
+
+module Context
+  module DeployHelpers
+    module CookbookHelper
+      def bundle_chef(context, commands, command_type = :system)
+        context.debug_context_log context.context_name, "Executing chef command #{commands}"
+        context.execute_command(%w(chef) + commands, command_type)
+      end
+
+      def chef_exec(context, commands, command_type = :system)
+        context.bundle_chef(context, %w(exec) + commands, command_type)
+      end
+
+      def knife(context, commands, command_type = :system)
+        context.chef_exec(context, %w(knife) + commands, command_type)
+      end
+
+      def kitchen(context, commands = %w(test), command_type = :system)
+        context.execute_command(%w(kitchen) + commands, command_type)
+      end
+
+      def cookbook_path(context)
+        File.dirname(context.context_folder)
+      end
+
+      def chef_generate(context, commands)
+        context.debug_context_log(context.context_name, "\n\nGenerating Chef components with command #{commands}")
+        context.bundle_chef(context, %w(generate) + commands)
+      end
+
+      def generate_cookbook(context, cookbookname)
+        context.chef_generate(context, %w(cookbook) + cookbookname)
+      end
+
+      def cookbook_build(context)
+        context.debug_context_log(context.context_name, "\n\nBuilding cookbook #{context.context_name}\n\n")
+        context.git_build(context)
+
+        Dir.chdir File.dirname(context.context_folder)
+        # context.generate_cookbook(context, [context.context_name]) unless Dir.exist?(context.get_context_file(context, 'recipes'))
+        
+        Dir.chdir context.context_folder
+        context.debug_context_log(context.context_name, "\n\nBuilding cookbook #{context.context_name} in path #{Dir.pwd} for folder #{context.context_folder}\n\n")
+        context.set_cookbook_version(context)
+      end
+
+      def cookbook_test(context)
+        context.cookbook_build(context)
+        context.debug_context_log context.context_name, "\n\nExecuting kitchen in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.kitchen(context)
+      end
+
+      def cookbook_test_successful?(context)
+        result = cookbook_test(context)
+        context.debug_context_log context.context_name, "\n\nCookbook test result: #{result}"
+        result
+      end
+
+      def cookbook_install(context)
+        cookbook_build(context)
+        context.debug_context_log context.context_name, "\n\nInstalling cookbook in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.bundle_chef(context, %w(install))
+      end
+
+      def knife_push(context)
+        cookbook_build(context)
+        context.debug_context_log context.context_name, "\n\nKnife pushing cookbook in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.knife context, ['cookbook', 'upload', context.context_name, '--cookbook-path', context.cookbook_path(context)]
+      end
+
+      def cookbook_push(context)
+        cookbook_build(context)
+        context.debug_context_log context.context_name, "\n\nChef pushing cookbook in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.bundle_chef(context, ['push', context.context_name, 'Policyfile.lock.json'])
+      end
+
+      def supermarket_push(context)
+        cookbook_build(context)
+        context.debug_context_log context.context_name, "\n\nPushing cookbook in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.bundle_chef(context, ['supermarket', 'share', context.context_name, '--cookbook-path', context.cookbook_path(context)])
+      end
+
+      def clean_file(context, file)
+        clean_file = context.get_context_file(context, file)
+        context.debug_context_log context.context_name, "Clean file #{clean_file}"
+        FileUtils.rm(clean_file) if File.exist?(clean_file)
+      end
+
+      def cookbook_clean(context)
+        context.cookbook_build(context)
+        context.debug_context_log context.context_name, "\n\nCleaning cookbook in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.clean_file(context, 'Policyfile.lock.json')
+      end
+
+      def mix_run_list(context, run_list)
+        context.bundle_exec(context, ['chef-client', '-o', run_list])
+      end
+
+      def cookbook_version(context)
+        context_version_file = context.get_context_file(context, 'VERSION')
+        context_version_file = if File.exist? context_version_file
+          context_version_file
+        else
+          File.join(__dir__, '../../../VERSION')
+        end
+        context.context_log "context_version_file = #{context_version_file}"
+        File.read(context_version_file)
+      end
+
+      def set_cookbook_version(context)
+        context.git_build(context)
+        if(defined?(GVB))
+          File.write(context.get_context_file(context, 'VERSION'), context.shorten_version(context).strip)
+          File.write(context.get_context_file(context, 'DATE'), GVB.date)
+        else
+          context.warning_context_log(context.context_name, "Unable to set the cookbook version as GVB is not defined")
+        end
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/cucumber.rb

@@ -0,0 +1,42 @@
+module Context
+  module DeployHelpers
+    module CucumberHelper
+      def cucumber_configuration(context, commands)
+        context.existing_cucumber_configuration = Cucumber::Cli::Main.new(commands.dup).configuration unless context.existing_cucumber_configuration
+        context.existing_cucumber_configuration
+      end
+
+      def cucumber_runtime(context, commands)
+        return Cucumber::Runtime.new(context.cucumber_configuration(context, commands)) unless context.existing_cucumber_runtime
+
+        context.existing_cucumber_runtime.configure(context.cucumber_configuration(context, commands))
+        context.existing_cucumber_runtime
+      end
+
+      def cucumber(context, commands = [])
+        # begin
+        #   require 'cucumber'
+        #   context.existing_cucumber_runtime = context.cucumber_runtime(context, commands)
+        #   context.cucumber_runtime(context, commands).run!
+        # rescue Exception => e
+        #   context.warning_context_log context.context_name, "Cucumber library not available", "Unable to use internal cucumber, using external application instead for command #{commands}"
+        #   context.execute_command(%w(chef exec cucumber) + commands)
+        # end
+        # # context.bundle_exec(context,['cucumber'] + commands)
+        context.execute_command(%w(chef exec cucumber) + commands)
+      end
+
+      def cucumber_test(context)
+        context.git_build(context)
+        context.debug_context_log context.context_name, "Working in folder #{Dir.pwd}\nAnd context #{context.context_name} is created in folder #{context.context_folder} at version #{context.version}"
+        context.cucumber(context)
+      end
+
+      def cucumber_test_successful?(context)
+        result = cucumber_test(context)
+        context.debug_context_log context.context_name, "\n\nCucumber test result: #{result}"
+        result
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/deployer.rb

@@ -0,0 +1,83 @@
+module Context
+  module DeployHelpers
+    module DeployerHelper
+      def load_public_dependencies
+        require 'rubygems'
+        require 'bundler'
+        # require 'bundler/setup'
+        # require 'bundler/installer'
+        
+        require 'rdoc/task'
+        
+        require 'git-version-bump'
+        require 'git-version-bump/rake-tasks'
+        
+        require 'cucumber'
+        require 'cucumber/rake/task'
+  
+        require_relative '../../deploy-context'
+      end
+  
+      def get_context_file(context, file)
+        File.join(context.context_folder, file)
+      end
+
+      def build_folder(context)
+        context.get_context_file(context, 'build')
+      end
+    
+      def contexts_container(context)
+        context.get_context_file(context, 'contexts')
+      end
+
+      def show_help(context)
+        help_message = <<MESSAGE_END
+#{
+  context.actions_permitted.each do |action|
+    puts "Available action '#{action}'"
+  end
+}
+Use not option or the option 'cycle' to cycle through the deployer once
+Use the option 'agent' to made a continual loop of the cycle
+Use the option 'bump' to bump the patch version
+Use the option 'release' to bump the minor version
+Use the option 'upgrade' to bump the major version
+Use the option 'test' to test the context
+Use the option 'reset' to execute the local cycle once
+Use the option 'help' to show this message
+MESSAGE_END
+        context.warning_context_log(context.context_name, help_message)
+      end
+
+      def actions_permitted?(action)
+        context_log "Is Default action '#{action}' permitted?"
+        action_is_permit = actions_permitted.include?(action)
+  
+        context_log "The answer is #{action_is_permit} through '#{actions_permitted}'"
+        action_is_permit
+      end
+
+      def execute_action(context, action)
+        state_action = if action.nil?
+          show_help(context)
+          false
+        else
+          if context.respond_to?(action)
+            context.debug_context_log(context.context_name, "\n\nStarting Action '#{action}'")
+            context.send(action)
+          else
+            context.error_context_log(context, "Action '#{action}' is unavailable")
+            false
+          end
+        end
+        # context.commit
+        if state_action || ! state_action.kind_of?(Integer)
+          context.debug_context_log context.context_name, "\n\nAction #{action} executed correctly in context #{context}.context_name"
+          state_action.perform unless state_action.kind_of?(TrueClass)
+        else
+          context.error_context_log(context.context_name, "Failed to execute action #{action} in context #{context.context_name} resulting to a #{state_action}")
+        end
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/git.rb

@@ -0,0 +1,62 @@
+module Context
+  module DeployHelpers
+    module GitHelper
+      def bundle_git(context, commands, command_type = :system)
+        context.execute_command(%w(git) + commands, command_type)
+      end
+
+      def git_build(context)
+        if context.present_localy?
+          Dir.chdir(context.context_folder)
+          context.git_pull(context)
+          true
+        else
+          context.error_context_log context.context_name, "Cloning from source in #{Dir.pwd}"
+          local_dir = File.join(Dir.pwd, context.context_name)
+          context.bundle_git context, ["clone git@github.com:JimboDragonGit/#{context.context_name}.git"] unless ::Dir.exist?(local_dir)
+          context.move_folder(local_dir)
+          true
+        end
+      end
+
+      def git_pull(context)
+        context.git_build(context) unless context.actual_working_directory?
+        context.debug_context_log context.context_name, "Git pull result: #{context.bundle_git context, %w(pull origin master)}"
+      end
+
+      def git_commit(context)
+        context.git_build(context)
+        context.bundle_git context, ['add .']
+        context.bundle_git context, ["commit -m 'Create #{context.context_name} automatic commit'"]
+      end
+
+      # def git_release(context)
+      #   context.git_build(context)
+      #   context.git context, ['push', '--follow-tags']
+      # end
+
+      # def git_bump(context, level)
+      #   context.git_build(context)
+      #   context.git context, ['version-bump', level]
+      #   context.git_commit(context)
+      # end
+
+      # def patch_reset(context)
+      #   context.git_build(context)
+      #   context.git_bump(context, 'minor')
+      # end
+
+      def git_update_available?(context)
+        context.git_build(context)
+        # context.git ['log', "v#{context.version}"]
+        context.bundle_git(context, ['ls-remote origin', "v#{context.version}"], :get_data)
+      end
+
+      def git_dirty_state?(context)
+        context.git_build(context)
+        # context.git ['log', "v#{context.version}"]
+        context.bundle_git(context, ["status --porcelain"], :get_data).split('\n').count > 0
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/habitat.rb

@@ -0,0 +1,112 @@
+module Context
+  module DeployHelpers
+    module HabitatHelper
+      def habitat_organisation_name(context)
+        context.organisation_name
+      end
+
+      def habitat(context, commands = [], command_type = :system)
+        context.bundle_exec(context, ['hab'] + commands, command_type)
+      end
+
+      def intialize_habitat(context, commands = [], command_type = :system)
+        context.habitat(context, ['plan', 'init'] + commands, command_type)
+      end
+
+      def render_habitat(context, commands = [], command_type = :system)
+        context.habitat(context, ['plan', 'render'] + commands, command_type)
+      end
+
+      def build_habitat(context, commands = [], command_type = :system)
+        context.habitat(context, ['studio', 'build', 'habitat/plan.sh'] + commands, command_type)
+      end
+
+      def start_habitat_job(context, commands = [], command_type = :system)
+        context.debug_context_log(context.context_name, "Starting an Habitat job #{context.get_shell_data(['hab', 'bldr', 'job', 'start', 'habitat/plan.sh'])}", command_type)
+        true
+      end
+
+      def promote_habitat(context, job_id = File.read(get_context_file(context, 'HAB_BUILD_ID')), channel = 'unstable')
+        if ! context.already_promoted?(context) && context.latest_hab_build_succeed?(context)
+          context.set_hab_build_id(context, context.hab_latest_build_status(context).id)
+          context.habitat(context, ['bldr', 'job', 'promote', job_id, channel]) 
+        else
+          context.error_context_log(context.context_name, "Promote context #{context.context_name} impossible")
+        end
+      end
+
+      def load_habitat(context, commands = [], command_type = :system)
+        supervisor_command = %w(hab svc load) + ["#{habitat_organisation_name(context)}/#{context.context_name}", '--strategy at-once']
+        if context.is_admin?
+          context.habitat(context, supervisor_command + commands, command_type)
+        else
+          context.execute_command(%w(sudo hab) + supervisor_command + commands, command_type) unless Gem.win_platform?
+        end
+      end
+
+      def run_habitat_supervisor(context, commands = [], command_type = :system)
+        supervisor_command = %w(sup run)
+        if context.is_admin?
+          context.habitat(context, supervisor_command + commands, command_type)
+        else
+          context.execute_command(%w(sudo hab) + supervisor_command + commands, command_type) unless Gem.win_platform?
+        end
+      end
+
+      def install_habitat_supervisor(context, commands = [], command_type = :system)
+        supervisor_command = %w(sup run)
+        if context.is_admin?
+          context.habitat(context, supervisor_command + commands, command_type)
+        else
+          context.execute_command(%w(sudo hab) + supervisor_command + commands, command_type) unless Gem.win_platform?
+        end
+      end
+
+      def hab_latest_build_status(context)
+        build_result = OpenStruct.new
+        build_result.command = [
+          'hab bldr job status',
+          '--showjobs -l 25 --origin',
+          context.organisation_name,
+          "| grep '#{context.context_name}' | head -n 1",
+        ]
+        # build_result.result_file = File.join(context.temp_dir, 'raw_return.txt')
+        # context.debug_context_log context.context_name, "Getting data from command #{build_result.command} and result at #{build_result.result_file}"
+        # File.write(build_result.result_file, context.get_shell_data(build_result.command))
+        # build_result.build_id_raw = "#{File.read(build_result.result_file)}"
+        # context.debug_context_log context.context_name, "And raw return from file is #{build_result.build_id_raw}"
+        # build_result.return_arr = build_result.build_id_raw.split("\n")
+        # context.debug_context_log context.context_name, "And return array is #{build_result.return_arr}"
+        # build_result.return_str = build_result.return_arr[3]
+        # context.debug_context_log context.context_name, "And return string is #{build_result.return_str}"
+        # build_result.result_arr = build_result.return_str.split(' ')
+        # context.debug_context_log context.context_name, "And result array is #{build_result.result_arr}"
+
+        result_array = context.get_shell_data(build_result.command).split("\n")[0].split(' ')
+        build_result.id = result_array[1]
+        build_result.status = result_array[2]
+        build_result
+      end
+
+      def hab_build_id(context)
+        File.read(context.get_context_file(context, 'HAB_BUILD_ID'))
+      end
+
+      def already_promoted?(context)
+        context.hab_latest_build_status(context).id == context.hab_build_id(context)
+      end
+
+      def latest_hab_build_succeed?(context)
+        context.hab_latest_build_status(context).status == 'Complete'
+      end
+
+      def set_hab_build_id(context, new_build_id)
+        context.git_build(context)
+        # , "#{organisation_name}/#{context_name}"
+        context.debug_context_log context.context_name, "Setting the build ID from #{context.hab_build_id(context)} to #{new_build_id}"
+
+        File.write(context.get_context_file(context, 'HAB_BUILD_ID'), new_build_id)
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/ruby.rb

@@ -0,0 +1,138 @@
+module Context
+  module DeployHelpers
+    module RubyHelper
+      def bundle(context, commands, command_type = :system)
+        context.debug_context_log context.context_name, "Executing chef command #{commands}"
+        context.execute_command(%w(bundle) + commands, command_type)
+      end
+
+      def bundle_exec(context, commands, command_type = :system)
+        context.bundle(context, %w(exec) + commands, command_type)
+      end
+
+      def bundle_install(context, commands, command_type = :system)
+        context.bundle(context, %w(install) + commands, command_type)
+      end
+
+      def bundle_gem(context, commands, command_type = :system)
+        context.execute_command(%w(gem) + commands, command_type)
+      end
+      
+      def bundle_rake(context, commands = [], command_type = :system)
+        context.execute_command(%w(rake) + commands, command_type)
+      end
+
+      def ruby_build(context)
+        context.git_build(context)
+        context.debug_context_log context.context_name, "Working in folder #{Dir.pwd}\nAnd context #{context.context_name} is created"
+        check_folder get_context_file(context, 'build')
+      end
+
+      def ruby_release(context)
+        context.git_build(context)
+        # gem ["push #{context.context_name}-#{GVB.version}.gem"]
+        # context.patch_bump if gem_installed?(context, context.context_name)
+        context.bundle_rake context, ['release']
+        # context.commit
+      end
+
+      def ruby_install(context)
+        context.bundle_gem context, ['install', context.context_name]
+      end
+
+      def clean_folder(context, folder)
+        clean_folder = context.get_context_file(context, folder)
+        puts "Clean folder #{clean_folder}"
+        FileUtils.remove_dir(clean_folder) if Dir.exist?(clean_folder)
+      end
+
+      def ruby_clean(context)
+        context.bundle_gem('cleanup')
+        context.clean_folder(context, 'pkg')
+      end
+
+      def ruby_remove_gem(context)
+        context.bundle_gem(['remove', context.context_name])
+      end
+
+      def ruby_check_if_available_public(context)
+        context.context_log "Waiting a minute before installing #{context.context_name} in folder #{context.context_folder}"
+        `chef gem list #{context.context_name}`
+        # sleep(60)
+      end
+
+      def gem_available?(context, gemname, compare_version = nil)
+        begin
+          available_version = Gem::Specification.find_by_name(gemname)
+        rescue Gem::MissingSpecError => e
+          context.error_context_log(context, "The gem '#{gemname}' is missing")
+          # sleep(5)
+          available_version = nil
+        rescue Exception => e
+          context.error_context_log(context, "The gem '#{gemname}' got issue with #{e}")
+          sleep(5)
+          available_version = nil
+        end
+        # context.debug_context_log(context.context_name, "Compare #{context.context_name} available_version #{available_version} with #{context.version} in folder #{context.context_folder}")
+        available = if compare_version.nil? || available_version.nil?
+          not available_version.nil?
+        else
+          available_version.version == context.version
+        end
+        puts "available = #{available}"
+        available
+      end
+
+      def gem_installed?(context, gemname, compare_version = nil)
+        gem_list = context.bundle_gem(context, ['list', gemname, "| grep #{gemname}"], :get_data)
+        context.debug_context_log context.context_name, "gemlist = #{gem_list}"
+        is_installed = gem_list.include?(gemname)
+        is_correct_version = gem_list.split(',').detect do |gem_app|
+          gem_app.include?(gemname)
+        end
+        context.debug_context_log context.context_name, "is_correct_version = #{is_correct_version}"
+        is_correct_version.include?(gemname)
+      end
+
+      def load_dependency(context, gemname, require_file)
+        context.gem(context, ['install', gemname]) unless context.gem_installed?(context, gemname)
+        context.debug_context_log(context.context_name, "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.debug_context_log context.context_name, "\n\nBuilding Ruby application for #{context.context_name}"
+        if context.new_update_available?
+          context.debug_context_log context.context_name, "\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
+          context.debug_context_log context.context_name, "\n\nBuilding project #{context.context_name} now ..."
+          context.build
+          # context.commit
+          context.debug_context_log context.context_name, "\n\nReleasing project #{context.context_name}"
+          context.release
+          context.wait_until_release_available
+          context.debug_context_log context.context_name, "\n\nInstalling project #{context.context_name}"
+          context.install
+          if context.test_context_successful?
+            context.debug_context_log context.context_name, "newer version installed successfully for #{context.context_name} on version #{context.version}"
+            # context.patch_bump
+            # patch_reset(context)
+          else
+            context.debug_context_log context.context_name, "newer version not installed for #{context.context_name} on version #{context.version}"
+          end
+        else
+          context.debug_context_log context.context_name, "No update available"
+        end
+      end
+    end
+  end
+end

data/home/jimboadmin/deploy-context/habitat/plan.sh/x86_64-linux/lib/deploy-context/deploy/vagrant.rb

@@ -0,0 +1,7 @@
+module Context
+  module VagrantHelper
+    def delete_vagrant_box(context, box_name, command_type = :system)
+      context.execute_command(%w(vagrant box remove ) + [box_name], command_type)
+    end
+  end
+end