chef-zero 2.2.1 → 3.0.0.rc.1

data/lib/chef_zero/cookbook_data.rb

@@ -1,236 +0,0 @@
-require 'digest/md5'
-require 'hashie/mash'
-
-module ChefZero
-  module CookbookData
-    def self.to_hash(cookbook, name, version=nil)
-      frozen = false
-      if cookbook.has_key?(:frozen)
-        frozen = cookbook[:frozen]
-        cookbook = cookbook.dup
-        cookbook.delete(:frozen)
-      end
-
-      result = files_from(cookbook)
-      recipe_names = result[:recipes].map do |recipe|
-        recipe_name = recipe[:name][0..-2]
-        recipe_name == 'default' ? name : "#{name}::#{recipe_name}"
-      end
-      result[:metadata] = metadata_from(cookbook, name, version, recipe_names)
-      result[:name] = "#{name}-#{result[:metadata][:version]}"
-      result[:json_class] = 'Chef::CookbookVersion'
-      result[:cookbook_name] = name
-      result[:version] = result[:metadata][:version]
-      result[:chef_type] = 'cookbook_version'
-      result[:frozen?] = true if frozen
-      result
-    end
-
-    def self.metadata_from(directory, name, version, recipe_names)
-      metadata = PretendCookbookMetadata.new(PretendCookbook.new(name, recipe_names))
-      # If both .rb and .json exist, read .rb
-      # TODO if recipes has 3 recipes in it, and the Ruby/JSON has only one, should
-      # the resulting recipe list have 1, or 3-4 recipes in it?
-      if has_child(directory, 'metadata.rb')
-        begin
-          file = filename(directory, 'metadata.rb') || "(#{name}/metadata.rb)"
-          metadata.instance_eval(read_file(directory, 'metadata.rb'), file)
-        rescue
-          ChefZero::Log.error("Error loading cookbook #{name}: #{$!}\n  #{$!.backtrace.join("\n  ")}")
-        end
-      elsif has_child(directory, 'metadata.json')
-        metadata.from_json(read_file(directory, 'metadata.json'))
-      end
-      result = {}
-      metadata.to_hash.each_pair do |key,value|
-        result[key.to_sym] = value
-      end
-      result[:version] = version if version
-      result
-    end
-
-    private
-
-    # Just enough cookbook to make a Metadata object
-    class PretendCookbook
-      def initialize(name, fully_qualified_recipe_names)
-        @name = name
-        @fully_qualified_recipe_names = fully_qualified_recipe_names
-      end
-      attr_reader :name, :fully_qualified_recipe_names
-    end
-
-    # Handles loading configuration values from a Chef config file
-    #
-    # @author Justin Campbell <justin.campbell@riotgames.com>
-    class PretendCookbookMetadata < Hash
-      # @param [String] path
-      def initialize(cookbook)
-        self.name(cookbook.name)
-        self.recipes(cookbook.fully_qualified_recipe_names)
-        %w(attributes grouping dependencies supports recommendations suggestions conflicting providing replacing recipes).each do |hash_arg|
-          self[hash_arg.to_sym] = Hashie::Mash.new
-        end
-      end
-
-      def from_json(json)
-        self.merge!(FFI_Yajl::Parser.parse(json))
-      end
-
-      private
-
-      def depends(cookbook, *version_constraints)
-        cookbook_arg(:dependencies, cookbook, version_constraints)
-      end
-
-      def supports(cookbook, *version_constraints)
-        cookbook_arg(:supports, cookbook, version_constraints)
-      end
-
-      def recommends(cookbook, *version_constraints)
-        cookbook_arg(:recommendations, cookbook, version_constraints)
-      end
-
-      def suggests(cookbook, *version_constraints)
-        cookbook_arg(:suggestions, cookbook, version_constraints)
-      end
-
-      def conflicts(cookbook, *version_constraints)
-        cookbook_arg(:conflicting, cookbook, version_constraints)
-      end
-
-      def provides(cookbook, *version_constraints)
-        cookbook_arg(:providing, cookbook, version_constraints)
-      end
-
-      def replaces(cookbook, *version_constraints)
-        cookbook_arg(:replacing, cookbook, version_constraints)
-      end
-
-      def recipe(recipe, description)
-        self[:recipes][recipe] = description
-      end
-
-      def attribute(name, options)
-        self[:attributes][name] = options
-      end
-
-      def grouping(name, options)
-        self[:grouping][name] = options
-      end
-
-      def cookbook_arg(key, cookbook, version_constraints)
-        self[key][cookbook] = version_constraints.first || ">= 0.0.0"
-      end
-
-      def method_missing(key, value = nil)
-        if value.nil?
-          self[key.to_sym]
-        else
-          store key.to_sym, value
-        end
-      end
-    end
-
-    def self.files_from(directory)
-      # TODO some support .rb only
-      result = {
-        :attributes => load_child_files(directory, 'attributes', false),
-        :definitions => load_child_files(directory, 'definitions', false),
-        :recipes => load_child_files(directory, 'recipes', false),
-        :libraries => load_child_files(directory, 'libraries', false),
-        :templates => load_child_files(directory, 'templates', true),
-        :files => load_child_files(directory, 'files', true),
-        :resources => load_child_files(directory, 'resources', true),
-        :providers => load_child_files(directory, 'providers', true),
-        :root_files => load_files(directory, false)
-      }
-      set_specificity(result[:templates])
-      set_specificity(result[:files])
-      result
-    end
-
-    def self.has_child(directory, name)
-      if directory.is_a?(Hash)
-        directory.has_key?(name)
-      else
-        directory.child(name).exists?
-      end
-    end
-
-    def self.read_file(directory, name)
-      if directory.is_a?(Hash)
-        directory[name]
-      else
-        directory.child(name).read
-      end
-    end
-
-    def self.filename(directory, name)
-      if directory.respond_to?(:file_path)
-        File.join(directory.file_path, name)
-      else
-        nil
-      end
-    end
-
-    def self.get_directory(directory, name)
-      if directory.is_a?(Hash)
-        directory[name].is_a?(Hash) ? directory[name] : nil
-      else
-        result = directory.child(name)
-        result.dir? ? result : nil
-      end
-    end
-
-    def self.list(directory)
-      if directory.is_a?(Hash)
-        directory.keys
-      else
-        directory.children.map { |c| c.name }
-      end
-    end
-
-    def self.load_child_files(parent, key, recursive)
-      result = load_files(get_directory(parent, key), recursive)
-      result.each do |file|
-        file[:path] = "#{key}/#{file[:path]}"
-      end
-      result
-    end
-
-    def self.load_files(directory, recursive)
-      result = []
-      if directory
-        list(directory).each do |child_name|
-          dir = get_directory(directory, child_name)
-          if dir
-            if recursive
-              result += load_child_files(directory, child_name, recursive)
-            end
-          else
-            result += load_file(read_file(directory, child_name), child_name)
-          end
-        end
-      end
-      result
-    end
-
-    def self.load_file(value, name)
-      [{
-        :name => name,
-        :path => name,
-        :checksum => Digest::MD5.hexdigest(value),
-        :specificity => 'default'
-      }]
-    end
-
-    def self.set_specificity(files)
-      files.each do |file|
-        parts = file[:path].split('/')
-        raise "Only directories are allowed directly under templates or files: #{file[:path]}" if parts.size == 2
-        file[:specificity] = parts[1]
-      end
-    end
-  end
-end

data/lib/chef_zero/data_normalizer.rb

@@ -1,146 +0,0 @@
-require 'chef_zero'
-require 'chef_zero/rest_base'
-
-module ChefZero
-  class DataNormalizer
-    def self.normalize_client(client, name)
-      client['name'] ||= name
-      client['admin'] ||= false
-      client['admin'] = !!client['admin']
-      client['public_key'] ||= PUBLIC_KEY
-      client['validator'] ||= false
-      client['validator'] = !!client['validator']
-      client['json_class'] ||= "Chef::ApiClient"
-      client['chef_type'] ||= "client"
-      client
-    end
-
-    def self.normalize_user(user, name)
-      user['name'] ||= name
-      user['admin'] ||= false
-      user['admin'] = !!user['admin']
-      user['openid'] ||= nil
-      user['public_key'] ||= PUBLIC_KEY
-      user
-    end
-
-    def self.normalize_data_bag_item(data_bag_item, data_bag_name, id, method)
-      if method == 'DELETE'
-        # TODO SERIOUSLY, WHO DOES THIS MANY EXCEPTIONS IN THEIR INTERFACE
-        if !(data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data'])
-          data_bag_item['id'] ||= id
-          data_bag_item = { 'raw_data' => data_bag_item }
-          data_bag_item['chef_type'] ||= 'data_bag_item'
-          data_bag_item['json_class'] ||= 'Chef::DataBagItem'
-          data_bag_item['data_bag'] ||= data_bag_name
-          data_bag_item['name'] ||= "data_bag_item_#{data_bag_name}_#{id}"
-        end
-      else
-        # If it's not already wrapped with raw_data, wrap it.
-        if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
-          data_bag_item = data_bag_item['raw_data']
-        end
-        # Argh.  We don't do this on GET, but we do on PUT and POST????
-        if %w(PUT POST).include?(method)
-          data_bag_item['chef_type'] ||= 'data_bag_item'
-          data_bag_item['data_bag'] ||= data_bag_name
-        end
-        data_bag_item['id'] ||= id
-      end
-      data_bag_item
-    end
-
-    def self.normalize_environment(environment, name)
-      environment['name'] ||= name
-      environment['description'] ||= ''
-      environment['cookbook_versions'] ||= {}
-      environment['json_class'] ||= "Chef::Environment"
-      environment['chef_type'] ||= "environment"
-      environment['default_attributes'] ||= {}
-      environment['override_attributes'] ||= {}
-      environment
-    end
-
-    def self.normalize_cookbook(endpoint, org_prefix, cookbook, name, version, base_uri, method)
-      # TODO I feel dirty
-      if method != 'PUT'
-        cookbook.each_pair do |key, value|
-          if value.is_a?(Array)
-            value.each do |file|
-              if file.is_a?(Hash) && file.has_key?('checksum')
-                file['url'] ||= endpoint.build_uri(base_uri, org_prefix + ['file_store', 'checksums', file['checksum']])
-              end
-            end
-          end
-        end
-        cookbook['name'] ||= "#{name}-#{version}"
-        # TODO this feels wrong, but the real chef server doesn't expand this default
-  #      cookbook['version'] ||= version
-        cookbook['cookbook_name'] ||= name
-        cookbook['frozen?'] ||= false
-        cookbook['metadata'] ||= {}
-        cookbook['metadata']['version'] ||= version
-        # Sad to not be expanding defaults just because Chef doesn't :(
-#        cookbook['metadata']['name'] ||= name
-#        cookbook['metadata']['description'] ||= "A fabulous new cookbook"
-        cookbook['metadata']['long_description'] ||= ""
-#        cookbook['metadata']['maintainer'] ||= "YOUR_COMPANY_NAME"
-#        cookbook['metadata']['maintainer_email'] ||= "YOUR_EMAIL"
-#        cookbook['metadata']['license'] ||= "none"
-        cookbook['metadata']['dependencies'] ||= {}
-        cookbook['metadata']['attributes'] ||= {}
-        cookbook['metadata']['recipes'] ||= {}
-      end
-      cookbook['json_class'] ||= 'Chef::CookbookVersion'
-      cookbook['chef_type'] ||= 'cookbook_version'
-      if method == 'MIN'
-        cookbook['metadata'].delete('attributes')
-        cookbook['metadata'].delete('long_description')
-      end
-      cookbook
-    end
-
-    def self.normalize_node(node, name)
-      node['name'] ||= name
-      node['json_class'] ||= 'Chef::Node'
-      node['chef_type'] ||= 'node'
-      node['chef_environment'] ||= '_default'
-      node['override'] ||= {}
-      node['normal'] ||= {}
-      node['default'] ||= {}
-      node['automatic'] ||= {}
-      node['run_list'] ||= []
-      node['run_list'] = normalize_run_list(node['run_list'])
-      node
-    end
-
-    def self.normalize_role(role, name)
-      role['name'] ||= name
-      role['description'] ||= ''
-      role['json_class'] ||= 'Chef::Role'
-      role['chef_type'] ||= 'role'
-      role['default_attributes'] ||= {}
-      role['override_attributes'] ||= {}
-      role['run_list'] ||= []
-      role['run_list'] = normalize_run_list(role['run_list'])
-      role['env_run_lists'] ||= {}
-      role['env_run_lists'].each_pair do |env, run_list|
-        role['env_run_lists'][env] = normalize_run_list(run_list)
-      end
-      role
-    end
-
-    def self.normalize_run_list(run_list)
-      run_list.map{|item|
-        case item
-        when /^recipe\[.*\]$/
-          item # explicit recipe
-        when /^role\[.*\]$/
-          item # explicit role
-        else
-          "recipe[#{item}]"
-        end
-      }.uniq
-    end
-  end
-end