deploy-context 2.13.17 → 2.13.20

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

@@ -1,57 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,121 +0,0 @@
-
-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

@@ -1,42 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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