selfbootstrap 0.1.0

data/lib/selfbootstrap/nochef/defaultvalues.rb

@@ -0,0 +1,258 @@
+# name 'Helper file for chef_workstation_initialize'
+# maintainer 'Jimbo Dragon'
+# maintainer_email 'jimbo_dragon@hotmail.com'
+# license 'MIT'
+# description 'Helper file for chef_workstation_initialize'
+# version '0.1.0'
+# chef_version '>= 16.6.14'
+# issues_url 'https://github.com/jimbodragon/chef_workstation_initialize/issues'
+# source_url 'https://github.com/jimbodragon/chef_workstation_initialize'
+#
+# Chef Infra Documentation
+# https://docs.chef.io/libraries/
+#
+
+#
+# This module name was auto-generated from the cookbook name. This name is a
+# single word that starts with a capital letter and then continues to use
+# camel-casing throughout the remainder of the name.
+#
+
+require 'json'
+require 'date'
+require 'fileutils'
+require 'yaml'
+require 'socket'
+
+module ChefWorkstationInitialize
+  module SelfBootstrap
+    module NoChef
+      module DefaultValuesHelpers
+        def define_resource_requirements
+        end
+
+        def worklog_counter
+          @worklog_counter ||= 0
+          @worklog_counter += 1
+        end
+
+        def worklog(logstr)
+          # if skip_boostrap?
+          #   create_chef_additionnal_dir unless ::File.exist?(workstation_logs_dir)
+          #   ::File.open(::File.join(get_path(workstation_logs_dir), 'knife.log'), 'a+') do |file|
+          #     file.puts logstr
+          #   end
+          # els
+          puts("#{DateTime.now}(#{worklog_counter}):: #{logstr}\n")
+        end
+
+        def error_worklog(logstr)
+          worklog("ERROR:: #{logstr}")
+        end
+
+        def warning_worklog(logstr)
+          worklog("WARN:: #{logstr}")
+        end
+
+        def debug_worklog(logstr)
+          worklog("DEBUG:: #{logstr}")
+        end
+
+        def require_implement_method(method_name, *arguments)
+          warning_worklog("Method '#{method_name}' need to be implement from another module or class with arguments '#{arguments.join(', ')}'")
+        end
+
+        def get_path(dir_obj)
+          dir_obj.is_a?(::Dir) ? dir_obj.path : dir_obj
+        end
+
+        def parent_nil?(hashobject, *names)
+          hashobject.nil? ? true : hashobject.depth_nil?(names)
+        end
+
+        def default_hostname
+          respond_to?('node') ? node['hostname'] : Socket.gethostname
+        end
+
+        def default_chefzero_portrange
+          '48999-49999'
+        end
+
+        def generate_directory(dir_path)
+          corrected_dir_path = get_path(dir_path)
+          FileUtils.mkdir_p(corrected_dir_path) unless ::File.exist?(corrected_dir_path)
+          FileUtils.chown_R(workstation_resource[:user], workstation_resource[:group], corrected_dir_path)
+          FileUtils.chmod_R(0775, corrected_dir_path)
+          corrected_dir_path
+        end
+
+        def get_out_of_folder(folderpath, folder_to_get_out)
+          if get_path(folderpath).include?(folder_to_get_out)
+            get_out_of_folder(::File.dirname(folderpath))
+          else
+            folderpath
+          end
+        end
+
+        def get_out_of_cache_path(cachepath)
+          get_out_of_folder(cachepath, 'cache')
+        end
+
+        def get_out_of_local_chef_path(projectpath)
+          get_out_of_folder(projectpath, '.chef')
+        end
+
+        def search_local_project_folder(projectpath)
+          get_out_of_local_chef_path(get_out_of_cache_path(projectpath))
+        end
+
+        def check_install_dir(dir_to_check)
+          if ::File.basename(get_path(dir_to_check)) == project_name
+            search_local_project_folder(dir_to_check)
+          else
+            ::File.join(get_path(dir_to_check), project_name)
+          end
+        end
+
+        def generate_default_install_dir
+          generic_install_dir = '/usr/local/chef/repo'
+          # generate_directory default_install_dir
+          ::Dir.exist?(generic_install_dir) ? ::Dir.new(generic_install_dir) : generic_install_dir
+        end
+
+        def default_install_dir
+          if @workstation.nil?
+            working_dir = ENV['default_install_dir'].nil? ? ::Dir.getwd : ENV['default_install_dir']
+            install_path = search_local_project_folder(working_dir)
+            if ::Dir.exist?(install_path)
+              ::Dir.new(install_path)
+            else
+              error_worklog("Unable to get the project from '#{install_path}' while in the folder #{working_dir}")
+            end
+          # elsif respond_to?('node')
+          #   check_install_dir ::Dir.new("/usr/local/chef/repo/#{node['infra_chef']['project_name']}")
+          elsif workstation_resource[:install_dir].nil?
+            debug_worklog('workstation defined but install_dir not define')
+            generate_default_install_dir
+          else
+            check_install_dir workstation_resource[:install_dir]
+          end
+        end
+
+        def analyse_object(object)
+          begin
+            debug_worklog("Analyzing object = #{object.class.name}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.methods = #{object.methods}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.singleton_methods = #{object.singleton_methods}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.public_constant = #{object.public_constant}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.public_class_method = #{object.public_class_method}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.singleton_methods = #{object.singleton_methods}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.public_methods = #{object.public_methods}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.included_modules = #{object.included_modules}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.local_variables = #{object.local_variables}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.instance_variables = #{object.instance_variables}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.global_variables = #{object.global_variables}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.class_variables = #{object.class_variables}")
+            debug_worklog("Empty = \n\n\n")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.constants = #{object.constants}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.params = #{object.resource_name}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.resource_initializing = #{object.resource_initializing}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.resources = #{object.resources}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.params = #{object.params}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          begin
+            debug_worklog("#{object.class.name}.find_resource(\"git_resource[YP]\") = #{object.find_resource(:git_resource, "YP")}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+          # begin
+          #   analyse_object(object.find_resource(:git_resource, "YP"), logger)
+          # rescue StandardError => exception
+          #   debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          # end
+          begin
+            debug_worklog("Chef::Provider::GitResource.public_class_method(:init_git) = #{Chef::Provider::GitResource.public_class_method(:init_git)}")
+          rescue StandardError => exception
+            debug_worklog("StandardError catch for: (#{exception.class.name}): #{exception.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selfbootstrap/nochef/defaultworkstationresource.rb

@@ -0,0 +1,95 @@
+#
+# Chef Infra Documentation
+# https://docs.chef.io/libraries/
+#
+
+#
+# This module name was auto-generated from the cookbook name. This name is a
+# single word that starts with a capital letter and then continues to use
+# camel-casing throughout the remainder of the name.
+#
+module ChefWorkstationInitialize
+  module SelfBootstrap
+    module NoChef
+      module WorkstationResourceHelpers
+        class DefaultWorkstationResource
+          include ChefWorkstationInitialize::SelfBootstrap::NoChef
+
+          def workstation_resource_keys
+            @selfbootstrap_resource.keys
+          end
+
+          def [](key)
+            @selfbootstrap_resource ||= {
+              install_dir: ::Dir.getwd,
+              project_name: ::File.basename(::Dir.getwd),
+              cookbook_source: 'infra_chef',
+              project_description: nil,
+              environments: nil,
+              initial_command: nil,
+              cron_chef_solo_command: nil,
+              chef_boostrapped: nil,
+              environment: nil,
+              user: ENV['USER'],
+              group: ENV['GROUP'].nil? ? ENV['USER'] : ENV['GROUP'],
+              home: ENV['HOME'],
+              run_for_type: nil,
+              gitinfo: nil,
+              cron: nil,
+              provisioners: nil,
+              verifiers: nil,
+              platforms: nil,
+              suites: nil,
+              default_attributes: nil,
+              override_attributes: nil,
+              solo: true,
+              data_bag_encrypt_version: 3,
+              file_cache_path: '',
+              debug: false,
+            }
+            if @selfbootstrap_resource.key?(key.to_sym)
+              @selfbootstrap_resource[key.to_sym]
+            elsif @selfbootstrap_resource.key?(key.to_s)
+              @selfbootstrap_resource[key.to_s]
+            end
+          end
+
+          def get_workstation_property(property_name)
+            debug_worklog("Get property #{property_name}") # if property_name == 'group'
+            self[property_name]
+          end
+
+          def set_workstation_property(property_name, value)
+            debug_worklog("Assign property #{property_name} is value #{value.is_a?(::Dir) ? get_path(value) : value}")
+            self[property_name] = value
+          end
+        end
+      end
+    end
+    #
+    # Define the methods that you would like to assist the work you do in recipes,
+    # resources, or templates.
+    #
+    # def my_helper_method
+    #   # help method implementation
+    # end
+  end
+end
+
+#
+# The module you have defined may be extended within the recipe to grant the
+# recipe the helper methods you define.
+#
+# Within your recipe you would write:
+#
+#     extend ChefWorkstationInitialize::SelfbootstrapNochefDefaultworkstationresourceHelpers
+#
+#     my_helper_method
+#
+# You may also add this to a single resource within a recipe:
+#
+#     template '/etc/app.conf' do
+#       extend ChefWorkstationInitialize::SelfbootstrapNochefDefaultworkstationresourceHelpers
+#       variables specific_key: my_helper_method
+#     end
+#

data/lib/selfbootstrap/nochef/git.rb

@@ -0,0 +1,128 @@
+# name 'Helper file for chef_workstation_initialize'
+# maintainer 'Jimbo Dragon'
+# maintainer_email 'jimbo_dragon@hotmail.com'
+# license 'MIT'
+# description 'Helper file for chef_workstation_initialize'
+# version '0.1.0'
+# chef_version '>= 16.6.14'
+# issues_url 'https://github.com/jimbodragon/chef_workstation_initialize/issues'
+# source_url 'https://github.com/jimbodragon/chef_workstation_initialize'
+#
+# Chef Infra Documentation
+# https://docs.chef.io/libraries/
+#
+
+#
+# This module name was auto-generated from the cookbook name. This name is a
+# single word that starts with a capital letter and then continues to use
+# camel-casing throughout the remainder of the name.
+#
+
+require_relative 'ssh'
+
+module ChefWorkstationInitialize
+  module SelfBootstrap
+    module NoChef
+      module GitHelpers
+        include ChefWorkstationInitialize::SelfBootstrap::NoChef::SSHHelpers
+
+        def get_git_submodule(git_name, git_info, action, compile_time)
+          require_implement_method('get_git_submodule', %w(git_name git_info action compile_time))
+        end
+
+        def get_git_server(git_action)
+          require_implement_method('get_git_server', %w(git_action))
+        end
+
+        def git_exec(*args, **run_opts)
+          base_command('git', args, run_opts)
+        end
+
+        def git_submodule_init
+          git_exec('submodule' + 'init')
+          git_exec('submodule' + 'update')
+        end
+
+        def repository_list
+          if parent_nil?(workstation_resource, 'gitinfo', 'submodules')
+            worklog('Use default repository')
+            [project_name, "#{project_name}_generator", new_cookbook_name]
+          else
+            worklog("workstation_resource[:gitinfo][\"submodules\"] = #{JSON.pretty_generate(workstation_resource[:gitinfo]['submodules'])}")
+            [project_name, "#{project_name}_generator", new_cookbook_name] + workstation_resource[:gitinfo]['submodules'].keys
+          end
+        end
+
+        def all_cookbooks
+          cookbooks_Arr = []
+          workstation_resource[:gitinfo]['submodules'].each do |gitname, git_info|
+            case git_info['type']
+            when 'cookbooks', 'libraries', 'resources'
+              cookbooks_Arr.push(gitname)
+            end
+          end unless parent_nil?(workstation_resource[:gitinfo], 'submodules')
+          cookbooks_Arr
+        end
+
+        def get_git_relative_path(gitname)
+          if gitname == project_name
+            ''
+          elsif workstation_resource[:gitinfo]['submodules'][gitname].nil?
+            ''
+          else
+            ::File.join(workstation_resource[:gitinfo]['submodules'][gitname]['type'], gitname)
+          end
+        end
+
+        def get_git_path(gitname)
+          ::File.join(get_path(workstation_chef_repo_path), get_git_relative_path(gitname))
+        end
+
+        def get_self_git(action, compile_time)
+          get_git_submodule(project_name, workstation_resource[:gitinfo], action, compile_time)
+        end
+
+        def generate_json_repo(type, repository, revision = 'master', remote = 'origin', submodule_list = nil, additional_remotes = nil)
+          json_output = {
+            type: type,
+            repository: repository,
+            revision: revision,
+            remote: remote,
+            submodules: submodule_list,
+            additional_remotes: additional_remotes,
+          }
+          worklog("Generate json for #{JSON.pretty_generate(json_output)}")
+          json_output
+        end
+
+        def generate_git_submodules(modules)
+          json_submodules = {}
+          modules.each do |module_name, module_info|
+            json_submodules[module_name] = { path: get_git_path(module_name), repository: module_info['repository'] }
+          end
+          json_submodules
+        end
+      end
+    end
+  end
+end
+
+#
+# The module you have defined may be extended within the recipe to grant the
+# recipe the helper methods you define.
+#
+# Within your recipe you would write:
+#
+#     extend ChefWorkstationInitialize::ChefHelpers
+#
+#     my_helper_method
+#
+# You may also add this to a single resource within a recipe:
+#
+#     template '/etc/app.conf' do
+#       extend ChefWorkstationInitialize::ChefHelpers
+#       variables specific_key: my_helper_method
+#     end
+#
+
+# require_relative "../providers/git_resource"

data/lib/selfbootstrap/nochef/kitchen.rb

@@ -0,0 +1,84 @@
+# name 'Helper file for chef_workstation_initialize'
+# maintainer 'Jimbo Dragon'
+# maintainer_email 'jimbo_dragon@hotmail.com'
+# license 'MIT'
+# description 'Helper file for chef_workstation_initialize'
+# version '0.1.0'
+# chef_version '>= 16.6.14'
+# issues_url 'https://github.com/jimbodragon/chef_workstation_initialize/issues'
+# source_url 'https://github.com/jimbodragon/chef_workstation_initialize'
+#
+# Chef Infra Documentation
+# https://docs.chef.io/libraries/
+#
+
+#
+# This module name was auto-generated from the cookbook name. This name is a
+# single word that starts with a capital letter and then continues to use
+# camel-casing throughout the remainder of the name.
+#
+
+require_relative 'chef'
+require_relative 'provisioners'
+
+module ChefWorkstationInitialize
+  module SelfBootstrap
+    module NoChef
+      module KitchenHelpers
+        include ChefWorkstationInitialize::SelfBootstrap::NoChef::ChefHelpers
+        include ChefWorkstationInitialize::SelfBootstrap::NoChef::ProvisionersHelpers
+
+        def kitchen(*args, **run_opts)
+          base_command('kitchen', args, run_opts)
+        end
+
+        def kitchen_root
+          get_path(workstation_chef_repo_path)
+        end
+
+        def generate_kitchen(machine_name)
+          kitchen_machine(machine_name, workstation_resource[:user], workstation_resource[:group], workstation_chef_repo_path)
+        end
+
+        def generate_machine(machine_name)
+          kitchen_machine(machine_name, workstation_resource[:user], workstation_resource[:group], workstation_chef_repo_path)
+        end
+
+        def building_kitchen
+          worklog 'kitchen converge'
+          kitchen 'converge', cwd: workstation_chef_repo_path
+        end
+
+        def kitchen_machine(machine_name, kitchen_user, kitchen_group, kitchen_dir)
+          change_unix_permission
+
+          worklog "kitchen converge #{machine_name}"
+          kitchen "converge #{machine_name}"
+
+          change_unix_permission
+        end
+      end
+    end
+  end
+end
+
+#
+# The module you have defined may be extended within the recipe to grant the
+# recipe the helper methods you define.
+#
+# Within your recipe you would write:
+#
+#     extend ChefWorkstationInitialize::ChefHelpers
+#
+#     my_helper_method
+#
+# You may also add this to a single resource within a recipe:
+#
+#     template '/etc/app.conf' do
+#       extend ChefWorkstationInitialize::ChefHelpers
+#       variables specific_key: my_helper_method
+#     end
+#
+
+# require_relative "../providers/git_resource"
+  

data/lib/selfbootstrap/nochef/knife.rb

@@ -0,0 +1,95 @@
+# name 'Helper file for chef_workstation_initialize'
+# maintainer 'Jimbo Dragon'
+# maintainer_email 'jimbo_dragon@hotmail.com'
+# license 'MIT'
+# description 'Helper file for chef_workstation_initialize'
+# version '0.1.0'
+# chef_version '>= 16.6.14'
+# issues_url 'https://github.com/jimbodragon/chef_workstation_initialize/issues'
+# source_url 'https://github.com/jimbodragon/chef_workstation_initialize'
+#
+# Chef Infra Documentation
+# https://docs.chef.io/libraries/
+#
+
+#
+# This module name was auto-generated from the cookbook name. This name is a
+# single word that starts with a capital letter and then continues to use
+# camel-casing throughout the remainder of the name.
+#
+
+require_relative 'chefrepo'
+
+module ChefWorkstationInitialize
+  module SelfBootstrap
+    module NoChef
+      module KnifeHelpers
+        include ChefWorkstationInitialize::SelfBootstrap::NoChef::ChefRepoHelpers
+
+        def knife(*args, **run_opts)
+          base_command('knife', *args, **run_opts)
+        end
+
+        def get_solo_cmd
+          worklog 'Get solo from knife'
+          knife 'config show solo --format json', live: true
+        end
+
+        def knife_search_self_cmd
+          knife_options = ['search']
+          knife_options << 'node'
+          knife_options << "name:#{default_hostname}"
+          knife_options << '--format json'
+          knife_options << '-z' if is_solo?
+          knife knife_options
+        end
+
+        def self_bootstrap_options
+          "-N #{default_hostname}"
+        end
+
+        def knife_get_node_attribute(nodename, attribute)
+          knife "node show #{nodename} -a #{attribute}"
+        end
+
+        def knife_self_bootstrap_cmd
+          knife "bootstrap #{self_bootstrap_options} --policy-group #{project_name} --policy-name #{project_name} #{default_hostname}"
+        end
+
+        def chef_client_self_bootstrap_cmd
+          chef_client_options = [self_bootstrap_options]
+          chef_client_options << "--runlist #{project_name}"
+          if ::File.exist?('solo.rb')
+            chef_client_options << '-c solo.rb'
+          else
+            chef_client_options << chef_solo_options_command
+            chef_client_options << "--chef-zero-host #{default_hostname}"
+            chef_client_options << "--chef-zero-port #{default_chefzero_portrange}"
+          end
+          chef_client chef_client_options, debug: true
+        end
+      end
+    end
+  end
+end
+
+#
+# The module you have defined may be extended within the recipe to grant the
+# recipe the helper methods you define.
+#
+# Within your recipe you would write:
+#
+#     extend ChefWorkstationInitialize::ChefHelpers
+#
+#     my_helper_method
+#
+# You may also add this to a single resource within a recipe:
+#
+#     template '/etc/app.conf' do
+#       extend ChefWorkstationInitialize::ChefHelpers
+#       variables specific_key: my_helper_method
+#     end
+#
+
+# require_relative "../providers/git_resource"
+