cheftacular 2.0.0

data/lib/cheftacular/encryptors.rb

@@ -0,0 +1,48 @@
+
+class Cheftacular
+  class Encryptor
+    ALGORITHM = 'aes-256-cbc'
+
+    def initialize data_bag_secret
+      @data_bag_secret = data_bag_secret
+    end
+
+    def return_encrypted_hash hash
+      hash.each_pair do |key, value|
+        hash[key] = encrypt_data_for_databag(value) unless (key =~ /id/) == 0
+      end
+
+      hash
+    end
+
+    #https://github.com/opscode/chef/blob/master/lib/chef/encrypted_data_bag_item/encryptor.rb
+    def encrypt_data_for_databag string
+      encryptor = openssl_encryptor
+
+      {
+        "encrypted_data" => encrypt_string(string, encryptor),
+        "iv" =>  Base64.encode64(@iv),
+        "version" => 1,
+        "cipher" => ALGORITHM
+      }
+    end
+
+    def encrypt_string string, encryptor
+      enc_data = encryptor.update(FFI_Yajl::Encoder.encode(json_wrapper: string))
+      enc_data << encryptor.final
+
+      Base64.encode64(enc_data)
+    end
+
+    def openssl_encryptor
+      openssl_encryptor = begin
+        encryptor = OpenSSL::Cipher::Cipher.new(ALGORITHM)
+        encryptor.encrypt
+        @iv = encryptor.random_iv
+        encryptor.iv = @iv
+        encryptor.key = Digest::SHA256.digest(@data_bag_secret)
+        encryptor
+      end
+    end
+  end
+end

data/lib/cheftacular/getters.rb

@@ -0,0 +1,153 @@
+
+class Cheftacular
+  class Getter
+    def initialize options, config
+      @options, @config  = options, config
+    end
+
+    def get_repository_from_role_name name, *args
+      @config['dummy_sshkit'].get_repository_from_role_name( name, @config['cheftacular']['repositories'], args )
+    end
+
+    #[TODO] if ridley changes its parsing strategy
+    def get_true_node_objects get_all_nodes=false, get_new_nodes=false
+      nodes, all_nodes, names, iter_arr, file_cache_nodes, h = [],[],[],[],[],{}
+
+      @config['chef_nodes'] = @config['ridley'].node.all
+
+      @config['helper'].completion_rate? 0, __method__
+
+      file_cache_nodes = @config['helper'].check_nodes_file_cache if @config['helper'].compare_file_node_cache_against_chef_nodes('equal')
+
+      @config['chef_nodes'].each do |n|
+        true_obj = if !file_cache_nodes.empty? && @config['parser'].array_of_nodes_contains_node_name?(file_cache_nodes, n.name)
+                     file_cache_nodes[@config['parser'].index_of_node_name_in_array_of_nodes(file_cache_nodes, n.name)]
+                   else
+                     @config['helper'].cleanup_file_caches('current')
+
+                     @config['ridley'].node.find(n.name)
+                   end
+
+        iter_arr << n.name
+
+        progress_value = (( iter_arr.length.to_f/@config['chef_nodes'].length.to_f )*100 ).floor
+
+        @config['helper'].completion_rate? progress_value, __method__
+
+        all_nodes << true_obj
+
+        next if !get_all_nodes && true_obj.chef_environment != @options['env'] && true_obj.chef_environment != '_default'
+
+        if get_all_nodes
+          h[n.name] = true_obj
+          names << n.name
+
+          next
+        end
+
+        if @options['role'] == 'all'
+          next if true_obj.chef_environment == '_default'
+
+          h[n.name] = true_obj
+          names << n.name
+
+          next
+        end
+
+        if @options['node_name'] && true_obj.name == @options['node_name']
+          h[n.name] = true_obj
+          names << n.name
+
+          next
+        end
+
+        if @options['address'] && true_obj.public_ipaddress == @options['address']
+          h[n.name] = true_obj
+          names << n.name
+
+          next
+        end
+
+        unless ( @options['address'] || @options['node_name'] )
+          if true_obj.run_list.include?("role[#{ @options['role'] }]")
+            h[n.name] = true_obj
+            names << n.name
+
+            next #not needed here but good to keep in mind
+          end
+        end
+      end
+
+      names.sort.each { |name| nodes << h[name] }
+
+      @config['helper'].write_nodes_file_cache(all_nodes) unless @config['helper'].compare_file_node_cache_against_chef_nodes('equal')
+
+      puts("") unless @options['quiet']
+      
+      nodes
+    end
+
+    def get_current_stack 
+      get_current_repo_config['stack']
+    end
+
+    def get_current_database
+      get_current_repo_config['database']
+    end
+
+    def get_current_repo_config
+      if @config['cheftacular']['repositories'].has_key?(@options['role'])
+        @config['cheftacular']['repositories'][@options['role']]
+      else
+        @options['role']
+      end
+    end
+
+    def get_current_role_map ret=""
+      @config['cheftacular']['role_maps'].each_pair do |main_role, role_hash|
+        ret = role_hash if role_hash['role_name'] == @options['role']
+      end
+
+      ret
+    end
+
+    def get_addresses_hash env='staging', ret_hash={}
+      @config[env]['addresses_bag_hash']['addresses'].each do |serv_hash|
+        ret_hash[serv_hash['public']] = { "dn" => serv_hash['dn'], "priv" => serv_hash['address'], "pub" => serv_hash['public'] }
+        
+      end if @config[env].has_key?('addresses_bag_hash')
+
+      ret_hash
+    end
+
+    def get_split_branch_hash ret={}
+      @config['cheftacular']['repositories'].each_pair do |name, repo_hash|
+        ret[repo_hash['name']] = repo_hash if repo_hash.has_key?('has_split_branches') && repo_hash['has_split_branches'] == 'true'
+      end
+
+      ret
+    end
+
+    def get_address_hash node_name, ret={}
+      @config['chef_environments'].each do |env|
+        next unless @config.has_key?(env) #in case the env hashes are not loaded
+
+        @config[env]['addresses_bag_hash']['addresses'].each do |serv_hash|
+          ret[serv_hash['name']] = { "dn" => serv_hash['dn'], "priv" => serv_hash['address'], "pub" => serv_hash['public'] } if serv_hash['name'] == node_name
+        end
+      end
+
+      ret
+    end
+
+    def get_repo_names_for_repositories ret={}
+      @config['cheftacular']['repositories'].each_pair do |name, repo_hash|
+        ret[repo_hash['repo_name']]         = repo_hash
+        
+        ret[repo_hash['repo_name']]['role'] = name
+      end
+
+      ret
+    end
+  end
+end

data/lib/cheftacular/helpers.rb

@@ -0,0 +1,296 @@
+
+class Cheftacular
+  class Helper
+    def initialize options, config
+      @options, @config  = options, config
+    end
+
+    def declassify
+      #(self.class::TRUENAME.constantize).to_s.underscore.dasherize
+      Cheftacular.to_s.underscore.dasherize
+    end
+
+    #[TODO] Refactor to more accurate solution
+    def running_in_gem?
+      File.expand_path('.', __FILE__).split('/').include?('.rvm') || 
+        (File.exist?(File.expand_path("#{ Dir.getwd }/.ruby-gemset")) &&
+          File.read(File.expand_path("#{ Dir.getwd }/.ruby-gemset")) != 'hiplogiq-deploy')
+    end
+
+    #TODO add command check
+    def is_command? command
+      @config['action'].public_methods(false).include?(command.to_sym)
+    end
+
+    def is_stateless_command? command
+      @config['stateless_action'].public_methods(false).include?(command.to_sym)
+    end
+
+    def is_not_command_or_stateless_command? command
+      !@config['action'].public_methods(false).include?(command.to_sym) && !@config['stateless_action'].public_methods(false).include?(command.to_sym)
+    end
+
+    #[TODO] Refactor to running_on_chef_node?
+    def running_on_chef_node?
+      Dir.entries('/etc').include?('chef')
+    rescue StandardError => e
+      exception_output "An error occurred while trying to see if this system is a chef node. Assuming the system is not a chef node.", e, false
+    end
+
+    def running_in_mode? mode
+      @config['cheftacular']['mode'] == mode
+    end
+
+    def fetch_remote_version
+      puts "Checking remote #{ declassify } version..."
+
+      `gem list #{ declassify } --remote`[/(\d+\.\d+\.\d+)/]
+    end
+
+    def is_junk_filename? filename
+      filename =~ /.DS_Store|.com.apple.timemachine.supported|README.*/ || filename == '.' || filename == '..' && File.directory?(filename)
+    end
+
+    def completion_rate? percent, mode
+      case mode.to_s
+      when 'initializer'           then print("Fetching initialization chef data for #{ @options['env'] }....0%") if !@options['quiet'] && percent == 0
+      when 'get_true_node_objects' then print("Retrieving node data from chef server for #{ @config['chef_nodes'].count } nodes....0%") if !@options['quiet'] && percent == 0
+      end
+
+      case percent
+      when 1..9   then print("\b\b#{ percent.to_i }%")       unless @options['quiet']
+      when 10..99 then print("\b\b\b#{ percent.to_i }%")     unless @options['quiet']
+      when 100    then print("\b\b\b\b#{ percent.to_i }%\n") unless @options['quiet']
+      end
+    end
+
+    def display_readme option="", out=""
+      puts File.read(File.expand_path('../README.md', __FILE__))
+    end
+
+    def gen_pass length=20, mode="truepass"
+      lowercase = 'a'..'z'
+      uppercase = 'A'..'Z'
+      numbers   = 0..9
+
+      length = @config['cheftacular']['server_pass_length'] if length.to_i <= @config['cheftacular']['server_pass_length']
+
+      sets = case mode
+             when "truepass"  then [lowercase, uppercase, numbers]
+             when "numsonly"  then [numbers]
+             when "lowernum"  then [lowercase, numbers]
+             when "uppernum"  then [uppercase, numbers]
+             when "lowercase" then [lowercase]
+             when "uppercase" then [uppercase]
+             end
+
+      o = sets.flatten.map { |i| i.to_a }.flatten
+
+      (0...length.to_i).map { o[rand(o.length)] }.join
+    end
+
+    def set_location_if_app ret=""
+      if get_codebase_from_role_name(Dir.getwd.split('/').last, "has_key?")
+        ret = Dir.getwd.split('/').last
+      end
+
+      ret
+    end
+
+    def sudo ip_address
+      "echo #{ @config['server_passwords'][ip_address] } | sudo -S"
+    end
+
+    def output_run_stats
+      puts("\nDone in #{ Time.now - @config['start_time'] } seconds at #{ Time.now.strftime('%Y-%m-%d %l:%M:%S %P') }.") unless @options['quiet']
+    end
+
+    def write_version_file version
+      File.open( current_version_file_path, "w") { |f| f.write(version) }
+    end
+
+    def set_local_instance_vars
+      [ 
+        @options, 
+        @config['locs'],
+        @config['ridley'],
+        @config[@options['env']]['logs_bag_hash'],
+        @config[@options['env']]['chef_passwords_bag_hash'],
+        @config['bundle_command'],
+        @config['cheftacular'],
+        @config['server_passwords']
+      ]
+    end
+
+    def exception_output message, exception='', exit_on_call=true, suppress_error_output=false
+      puts "#{ message }\n"
+
+      puts("Error message: #{ exception }\n#{ exception.backtrace.join("\n") }") unless suppress_error_output
+
+      exit if exit_on_call
+    end
+
+    def write_nodes_file_cache nodes
+      nodes.each do |node|
+        File.open( File.join( current_nodes_file_cache_path, "#{ node.name }.json"), "w") { |f| f.write(node.to_json) }
+      end
+    end
+
+    def check_nodes_file_cache nodes=[]
+      Dir.entries(current_nodes_file_cache_path).each do |location|
+        next if is_junk_filename?(location)
+
+        nodes << @config['ridley'].node.from_file("#{ current_nodes_file_cache_path }/#{ location }" )
+      end
+
+      nodes
+    end
+
+    def current_version_file_path
+      current_file_path 'version-check.txt'
+    end
+
+    def current_audit_file_path
+      current_file_path 'audit-check.txt'
+    end
+
+    def compare_file_node_cache_against_chef_nodes mode='include?'
+      chef_server_names, nodes_file_cache_names = [],[]
+      included = true 
+
+      @config['chef_nodes'].each { |node| chef_server_names << node.name }
+
+      check_nodes_file_cache.each { |node| nodes_file_cache_names << node.name }
+
+      nodes_file_cache_names.each do |node_name|
+        unless chef_server_names.include?(node_name)
+          included = false
+
+          break
+        end
+      end
+
+      case mode
+      when 'include?'  then return included
+      when 'not_equal' then return check_nodes_file_cache.count != names.count
+      when 'equal'     then return chef_server_names.sort == nodes_file_cache_names.sort
+      end
+    end
+
+    def is_higher_version? vstr1, vstr2
+      Gem::Version.new(vstr1) > Gem::Version.new(vstr2)
+    end
+
+    def set_log_loc_and_timestamp
+      @config['dummy_sshkit'].set_log_loc_and_timestamp @config['locs']
+    end
+
+    def knife_bootstrap_command
+      address  = @options['address']
+      user     = @config['cheftacular']['deploy_user']
+      password = @config['server_passwords'][@options['address']]
+      nodename = @options['node_name']
+      chef_ver = @config['cheftacular']['chef_client_version']
+
+      "knife bootstrap #{ address } -x #{ user } -P #{ password } -N #{ nodename } --sudo --use-sudo-password --bootstrap-version #{ chef_ver }"
+    end
+
+    #the documentation hashes must be populated *before* this method runs for it to return anything!
+    def compile_documentation_lines mode, out=[]
+      doc_arr = case mode
+                when 'action'           then @config['documentation']['action']
+                when 'application'      then @config['documentation']['action'] + @config['documentation']['application']
+                when 'stateless_action' then @config['documentation']['stateless_action']
+                when 'devops'           then @config['documentation']['action'] + @config['documentation']['stateless_action']
+                end
+
+      count = 1
+
+      doc_arr.sort {|a, b| a[0] <=> b[0]}.flatten(1).each do |line|
+
+        out << "#{ count }. #{ line }" if line.class.to_s == 'String'
+
+        out << line if line.class.to_s == 'Array'
+
+        count += 1 if line.class.to_s == 'String'
+
+        #puts("#{ out[out.index("#{ count }. #{ line }")] }::#{ line.class }::#{ count }\n") unless line.class.to_s == 'Array'
+      end
+
+      out
+    end
+
+    #compares how close str1 is to str2
+    def compare_strings str1, str2
+      str1_chars = str1.split('').uniq
+      str2_chars = str2.split('').uniq
+
+      ((str1_chars + str2_chars).uniq.length * 1.0) / (str1_chars.length + str2_chars.length)
+    end
+
+    def set_cloud_options
+      @options['preferred_cloud']        = @options['preferred_cloud'].nil? ?        @config['cheftacular']['preferred_cloud'] :        @options['preferred_cloud']
+      @options['preferred_cloud_image']  = @options['preferred_cloud_image'].nil? ?  @config['cheftacular']['preferred_cloud_image'] :  @options['preferred_cloud_image']
+      @options['preferred_cloud_region'] = @options['preferred_cloud_region'].nil? ? @config['cheftacular']['preferred_cloud_region'] : @options['preferred_cloud_region']
+      @options['virtualization_mode']    = @options['virtualization_mode'].nil? ?    @config['cheftacular']['virtualization_mode'] :    @options['virtualization_mode']
+    end
+
+    def current_nodes_file_cache_path
+      current_file_path 'node_cache'
+    end
+
+    def cleanup_file_caches mode='old'
+      base_dir = File.join( @config['locs']['app-root'], 'tmp', declassify )
+
+      Dir.entries(base_dir).each do |entry|
+        next if is_junk_filename?(entry)
+
+        case mode
+        when 'old'
+          FileUtils.rm("#{ base_dir }/#{ entry }") if File.file?("#{ base_dir }/#{ entry }") && !entry.include?(Time.now.strftime("%Y%m%d"))
+
+          check_current_day_entry = false
+        when 'current'
+          check_current_day_entry = true
+        end
+
+
+        if File.exists?("#{ base_dir }/#{ entry }") && File.directory?("#{ base_dir }/#{ entry }")
+          FileUtils.rm_rf("#{ base_dir }/#{ entry }") if !check_current_day_entry && !entry.include?(Time.now.strftime("%Y%m%d"))
+          
+          FileUtils.rm_rf("#{ base_dir }/#{ entry }") if check_current_day_entry && entry.include?(Time.now.strftime("%Y%m%d"))
+
+          FileUtils.mkdir_p @config['helper'].current_nodes_file_cache_path
+        end
+      end
+    end
+
+    def remove_current_file_node_cache
+      base_dir = File.join( @config['locs']['app-root'], 'tmp', declassify )
+
+      Dir.entries(base_dir).each do |entry|
+        next if is_junk_filename?(entry)
+
+        FileUtils.rm_rf("#{ base_dir }/#{ entry }") if File.directory?("#{ base_dir }/#{ entry }") && entry.include?(Time.now.strftime("%Y%m%d"))
+      end      
+    end
+
+    private
+    def current_file_path file_name
+      File.join( @config['locs']['app-root'], 'tmp', declassify, "#{ Time.now.strftime("%Y%m%d") }-#{ file_name }")
+    end
+  end
+end
+
+class String
+  def scrub_pretty_text
+    self.gsub("",'').gsub(/\[0m|\[1m|\[32m|\[35m|\[36m/,'')
+  end
+end
+
+class Fixnum
+  def digits(base = 10)
+    quotient, remainder = divmod(base)
+    (quotient > 0 ? quotient.digits : []) + [remainder]
+  end
+end