chef-zero 2.2.1 → 3.0.0.rc.1

data/lib/chef_zero/data_store/default_facade.rb

@@ -0,0 +1,149 @@
+require 'chef_zero/data_store/interface_v2'
+require 'chef_zero/chef_data/default_creator'
+
+module ChefZero
+  module DataStore
+    #
+    # The DefaultFacade exists to layer defaults on top of an existing data
+    # store.  When you create an org, you just create the directory itself:
+    # the rest of the org (such as environments/_default) will not actually
+    # exist anywhere, but when you get(/organizations/org/environments/_default),
+    # the DefaultFacade will create one for you on the fly.
+    #
+    # acls in particular are instantiated on the fly using this method.
+    #
+    class DefaultFacade < ChefZero::DataStore::InterfaceV2
+      def initialize(real_store, single_org, osc_compat, superusers = nil)
+        @real_store = real_store
+        @default_creator = ChefData::DefaultCreator.new(self, single_org, osc_compat, superusers)
+        clear
+      end
+
+      attr_reader :real_store
+      attr_reader :default_creator
+
+      def clear
+        real_store.clear if real_store.respond_to?(:clear)
+        default_creator.clear
+      end
+
+      def create_dir(path, name, *options)
+        if default_creator.exists?(path + [ name ]) && !options.include?(:recursive)
+          raise DataAlreadyExistsError.new(path + [name])
+        end
+
+        begin
+          real_store.create_dir(path, name, *options)
+        rescue DataNotFoundError
+          if default_creator.exists?(path)
+            real_store.create_dir(path, name, :recursive, *options)
+          else
+            raise
+          end
+        end
+
+        options_hash = options.last.is_a?(Hash) ? options.last : {}
+        default_creator.created(path + [ name ], options_hash[:requestor], options.include?(:recursive))
+      end
+
+      def create(path, name, data, *options)
+        if default_creator.exists?(path + [ name ]) && !options.include?(:create_dir)
+          raise DataAlreadyExistsError.new(path + [name])
+        end
+
+        begin
+          real_store.create(path, name, data, *options)
+        rescue DataNotFoundError
+          if default_creator.exists?(path)
+            real_store.create(path, name, data, :create_dir, *options)
+          else
+            raise
+          end
+        end
+
+        options_hash = options.last.is_a?(Hash) ? options.last : {}
+        default_creator.created(path + [ name ], options_hash[:requestor], options.include?(:recursive))
+      end
+
+      def get(path, request=nil)
+        begin
+          real_store.get(path, request)
+        rescue DataNotFoundError
+          result = default_creator.get(path)
+          if result
+            JSON.pretty_generate(result)
+          else
+            raise
+          end
+        end
+      end
+
+      def set(path, data, *options)
+        begin
+          real_store.set(path, data, *options)
+        rescue DataNotFoundError
+          if options.include?(:create_dir) ||
+             options.include?(:create) && default_creator.exists?(path[0..-2]) ||
+             default_creator.exists?(path)
+            real_store.set(path, data, :create, :create_dir, *options)
+          else
+            raise
+          end
+        end
+
+        if options.include?(:create)
+          options_hash = options.last.is_a?(Hash) ? options.last : {}
+          default_creator.created(path, options_hash[:requestor], options.include?(:create_dir))
+        end
+      end
+
+      def delete(path, *options)
+        deleted = default_creator.deleted(path)
+        begin
+          real_store.delete(path)
+        rescue DataNotFoundError
+          if !deleted
+            raise
+          end
+        end
+      end
+
+      def delete_dir(path, *options)
+        deleted = default_creator.deleted(path)
+        begin
+          real_store.delete_dir(path, *options)
+        rescue DataNotFoundError
+          if !deleted
+            raise
+          end
+        end
+      end
+
+      def list(path)
+        default_results = default_creator.list(path)
+        begin
+          real_results = real_store.list(path)
+          if default_results
+            (real_results + default_results).uniq
+          else
+            real_results
+          end
+        rescue DataNotFoundError
+          if default_results
+            default_results
+          else
+            raise
+          end
+        end
+      end
+
+      def exists?(path)
+        real_store.exists?(path) || default_creator.exists?(path)
+      end
+
+      def exists_dir?(path)
+        real_store.exists_dir?(path) || default_creator.exists?(path)
+      end
+    end
+  end
+end

data/lib/chef_zero/data_store/interface_v1.rb

@@ -9,38 +9,56 @@ module ChefZero
         raise "clear not implemented by class #{self.class}"
       end
 
+      # Create a directory.
+      # options is a list of symbols, including:
+      #   :recursive - create any parents needed
       def create_dir(path, name, *options)
         raise "create_dir not implemented by class #{self.class}"
       end
 
+      # Create a file.
+      # options is a list of symbols, including:
+      #   :create_dir - create any parents needed
       def create(path, name, data, *options)
         raise "create not implemented by class #{self.class}"
       end
 
+      # Get a file.
       def get(path, request=nil)
         raise "get not implemented by class #{self.class}"
       end
 
+      # Set a file's value.
+      # options is a list of symbols, including:
+      #    :create - create the file if it does not exist
+      #    :create_dir - create the directory if it does not exist
       def set(path, data, *options)
         raise "set not implemented by class #{self.class}"
       end
 
+      # Delete a file.
       def delete(path)
         raise "delete not implemented by class #{self.class}"
       end
 
+      # Delete a directory.
+      # options is a list of symbols, including:
+      #   :recursive - delete even if empty
       def delete_dir(path, *options)
         raise "delete_dir not implemented by class #{self.class}"
       end
 
+      # List a directory.
       def list(path)
         raise "list not implemented by class #{self.class}"
       end
 
+      # Check a file's existence.
       def exists?(path)
         raise "exists? not implemented by class #{self.class}"
       end
 
+      # Check a directory's existence.
       def exists_dir?(path)
         raise "exists_dir? not implemented by class #{self.class}"
       end

data/lib/chef_zero/data_store/memory_store.rb

@@ -18,13 +18,14 @@
 
 require 'chef_zero/data_store/v2_to_v1_adapter'
 require 'chef_zero/data_store/memory_store_v2'
+require 'chef_zero/data_store/default_facade'
 
 module ChefZero
   module DataStore
     class MemoryStore < ChefZero::DataStore::V2ToV1Adapter
       def initialize
         super
-        @real_store = ChefZero::DataStore::MemoryStoreV2.new
+        @real_store = ChefZero::DataStore::DefaultFacade.new(ChefZero::DataStore::MemoryStoreV2.new, 'chef', true)
         clear
       end
     end

data/lib/chef_zero/data_store/memory_store_v2.rb

@@ -31,31 +31,6 @@ module ChefZero
 
       def clear
         @data = {}
-
-        create_dir([], 'organizations')
-      end
-
-      def create_org
-        org = {
-          'clients' => {
-            'chef-validator' => '{ "validator": true }',
-            'chef-webui' => '{ "admin": true }'
-          },
-          'cookbooks' => {},
-          'data' => {},
-          'environments' => {
-            '_default' => '{ "description": "The default Chef environment" }'
-          },
-          'file_store' => {
-            'checksums' => {}
-          },
-          'nodes' => {},
-          'roles' => {},
-          'sandboxes' => {},
-          'users' => {
-            'admin' => '{ "admin": "true" }'
-          }
-        }
       end
 
       def create_dir(path, name, *options)
@@ -66,7 +41,7 @@ module ChefZero
             raise DataAlreadyExistsError.new(path + [name])
           end
         else
-          _create_dir(path, parent, name)
+          parent[name] = {}
         end
       end
 
@@ -139,7 +114,7 @@ module ChefZero
         begin
           value = _get(path)
           if value.is_a?(Hash) && !options[:allow_dirs]
-            raise "exists? does not work with directories (#{path} = #{dir.class})"
+            raise "exists? does not work with directories (#{path} = #{value.class})"
           end
           return true
         rescue DataNotFoundError
@@ -166,7 +141,7 @@ module ChefZero
         path.each_with_index do |path_part, index|
           if !value.has_key?(path_part)
             if create_dir
-              _create_dir(path[0,index], value, path_part)
+              value[path_part] = {}
             else
               raise DataNotFoundError.new(path[0,index+1])
             end
@@ -175,14 +150,6 @@ module ChefZero
         end
         value
       end
-
-      def _create_dir(parent_path, parent, name)
-        if parent_path == [ 'organizations' ]
-          parent[name] = create_org
-        else
-          parent[name] = {}
-        end
-      end
     end
   end
 end

data/lib/chef_zero/data_store/raw_file_store.rb

@@ -0,0 +1,147 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef_zero/data_store/data_already_exists_error'
+require 'chef_zero/data_store/data_not_found_error'
+require 'chef_zero/data_store/interface_v2'
+require 'fileutils'
+
+module ChefZero
+  module DataStore
+    class RawFileStore < ChefZero::DataStore::InterfaceV2
+      def initialize(root, destructible = false)
+        @root = root
+        @destructible = destructible
+      end
+
+      attr_reader :root
+      attr_reader :destructible
+
+      def path_to(path, name=nil)
+        if name
+          File.join(root, *path, name)
+        else
+          File.join(root, *path)
+        end
+      end
+
+      def clear
+        if destructible
+          Dir.entries(root).each do |entry|
+            next if entry == '.' || entry == '..'
+            FileUtils.rm_rf(Path.join(root, entry))
+          end
+        end
+      end
+
+      def create_dir(path, name, *options)
+        real_path = path_to(path, name)
+        if options.include?(:recursive)
+          FileUtils.mkdir_p(real_path)
+        else
+          begin
+            Dir.mkdir(File.join(path, name))
+          rescue Errno::ENOENT
+            raise DataNotFoundError.new(path)
+          rescue Errno::EEXIST
+            raise DataAlreadyExistsError.new(path + [name])
+          end
+        end
+      end
+
+      def create(path, name, data, *options)
+        if options.include?(:create_dir)
+          FileUtils.mkdir_p(path_to(path))
+        end
+        begin
+          File.open(path_to(path, name), File::WRONLY|File::CREAT|File::EXCL|File::BINARY, :internal_encoding => nil) do |file|
+            file.write data
+          end
+        rescue Errno::ENOENT
+          raise DataNotFoundError.new(path)
+        rescue Errno::EEXIST
+          raise DataAlreadyExistsError.new(path + [name])
+        end
+      end
+
+      def get(path, request=nil)
+        begin
+          return IO.read(path_to(path))
+        rescue Errno::ENOENT
+          raise DataNotFoundError.new(path)
+        end
+      end
+
+      def set(path, data, *options)
+        if options.include?(:create_dir)
+          FileUtils.mkdir_p(path_to(path[0..-2]))
+        end
+        begin
+          mode = File::WRONLY|File::TRUNC|File::BINARY
+          if options.include?(:create)
+            mode |= File::CREAT
+          end
+          File.open(path_to(path), mode, :internal_encoding => nil) do |file|
+            file.write data
+          end
+        rescue Errno::ENOENT
+          raise DataNotFoundError.new(path)
+        end
+      end
+
+      def delete(path)
+        begin
+          File.delete(path_to(path))
+        rescue Errno::ENOENT
+          raise DataNotFoundError.new(path)
+        end
+      end
+
+      def delete_dir(path, *options)
+        if options.include?(:recursive)
+          if !File.exist?(path_to(path))
+            raise DataNotFoundError.new(path)
+          end
+          FileUtils.rm_rf(path_to(path))
+        else
+          begin
+            Dir.rmdir(path_to(path))
+          rescue Errno::ENOENT
+            raise DataNotFoundError.new(path)
+          end
+        end
+      end
+
+      def list(path)
+        begin
+          Dir.entries(path_to(path)).select { |entry| entry != '.' && entry != '..' }.to_a
+        rescue Errno::ENOENT
+          raise DataNotFoundError.new(path)
+        end
+      end
+
+      def exists?(path, options = {})
+        File.exists?(path_to(path))
+      end
+
+      def exists_dir?(path)
+        File.exists?(path_to(path))
+      end
+    end
+  end
+end

data/lib/chef_zero/data_store/v1_to_v2_adapter.rb

@@ -10,117 +10,87 @@ module ChefZero
         clear
       end
 
-      ORG_DEFAULTS = {
-        'clients' => {
-          'chef-validator' => '{ "validator": true }',
-          'chef-webui' => '{ "admin": true }'
-        },
-        'environments' => {
-          '_default' => '{ "description": "The default Chef environment" }'
-        },
-        'users' => {
-          'admin' => '{ "admin": "true" }'
-        }
-      }
-
       attr_reader :real_store
       attr_reader :single_org
 
       def clear
-        if @options[:org_defaults]
-          @defaults = { 'organizations' => { @single_org => @options[:org_defaults] }}
-        else
-          @defaults = {}
-        end
         real_store.clear if real_store.respond_to?(:clear)
       end
 
       def create_dir(path, name, *options)
-        return nil if skip_organizations?(path, name)
-        if using_default?(path, name)
-          raise DataAlreadyExistsError.new(path + [name])
-        end
+        raise DataNotFoundError.new(path) if skip_organizations?(path)
+        raise "Cannot create #{name} at #{path} with V1ToV2Adapter: only handles a single org named #{single_org}." if skip_organizations?(path, name)
+        raise DataAlreadyExistsError.new(path + [ name ]) if path.size < 2
         fix_exceptions do
           real_store.create_dir(path[2..-1], name, *options)
         end
       end
 
       def create(path, name, data, *options)
-        return nil if skip_organizations?(path, name)
-        if using_default?(path, name)
-          raise DataAlreadyExistsError.new(path + [name])
-        end
-        remove_default(path, name)
-
+        raise DataNotFoundError.new(path) if skip_organizations?(path)
+        raise "Cannot create #{name} at #{path} with V1ToV2Adapter: only handles a single org named #{single_org}." if skip_organizations?(path, name)
+        raise DataAlreadyExistsError.new(path + [ name ]) if path.size < 2
         fix_exceptions do
           real_store.create(path[2..-1], name, data, *options)
         end
       end
 
       def get(path, request=nil)
-        return nil if skip_organizations?(path)
-        if using_default?(path)
-          get_default(path)
-        else
-          fix_exceptions do
-            real_store.get(path[2..-1], request)
-          end
+        raise DataNotFoundError.new(path) if skip_organizations?(path)
+        fix_exceptions do
+          real_store.get(path[2..-1], request)
         end
       end
 
       def set(path, data, *options)
-        return nil if skip_organizations?(path)
-        remove_default(path)
+        raise DataNotFoundError.new(path) if skip_organizations?(path)
         fix_exceptions do
           real_store.set(path[2..-1], data, *options)
         end
       end
 
-      def delete(path)
-        return nil if skip_organizations?(path)
-        remove_default(path)
+      def delete(path, *options)
+        raise DataNotFoundError.new(path) if skip_organizations?(path) && !options.include?(:recursive)
         fix_exceptions do
           real_store.delete(path[2..-1])
         end
       end
 
       def delete_dir(path, *options)
-        return nil if skip_organizations?(path)
+        raise DataNotFoundError.new(path) if skip_organizations?(path) && !options.include?(:recursive)
         fix_exceptions do
           real_store.delete_dir(path[2..-1], *options)
         end
       end
 
       def list(path)
-        return nil if skip_organizations?(path)
-        fix_exceptions do
-          result = real_store.list(path[2..-1])
-          if using_default?(path)
-            result ||= []
-            get_default(path).keys.each do |value|
-              result << value if !result.include?(value)
-            end
+        raise DataNotFoundError.new(path) if skip_organizations?(path)
+        if path == []
+          [ 'organizations' ]
+        elsif path == [ 'organizations' ]
+          [ single_org ]
+        else
+          fix_exceptions do
+            real_store.list(path[2..-1])
           end
-          result
         end
       end
 
       def exists?(path)
-        return nil if skip_organizations?(path)
-        if using_default?(path)
-          true
-        else
-          fix_exceptions do
-            real_store.exists?(path[2..-1])
-          end
+        return false if skip_organizations?(path)
+        fix_exceptions do
+          real_store.exists?(path[2..-1])
         end
       end
 
       def exists_dir?(path)
-        return nil if skip_organizations?(path)
-        if using_default?(path)
+        return false if skip_organizations?(path)
+        if path == []
+          true
+        elsif path == [ 'organizations' ] || path == [ 'users' ]
           true
         else
+          return false if skip_organizations?(path)
           fix_exceptions do
             real_store.exists_dir?(path[2..-1])
           end
@@ -129,40 +99,6 @@ module ChefZero
 
       private
 
-      def using_default?(path, name = nil)
-        path = path + [name] if name
-        result = @defaults
-        path.each do |part|
-          return false if !result.has_key?(part)
-          result = result[part]
-        end
-        !result.nil?
-      end
-
-      def get_default(path, name = nil)
-        path = path + [name] if name
-        result = @defaults
-        path.each do |part|
-          return nil if !result.has_key?(part)
-          result = result[part]
-        end
-        result
-      end
-
-      def remove_default(path, name = nil)
-        dir = name ? path[0..-2] : path
-        default = @defaults
-        dir.each do |part|
-          return if !default.has_key?(part)
-          default = default[part]
-        end
-
-        name = name || path.last
-        if name
-          default.delete(name)
-        end
-      end
-
       def fix_exceptions
         begin
           yield
@@ -175,17 +111,17 @@ module ChefZero
 
       def skip_organizations?(path, name = nil)
         if path == []
-          raise "" if name == nil || name != 'organizations'
-          true
-        elsif path == ['organizations']
-          raise "" if name == nil || name != single_org
-          true
-        else
-          raise "Path #{path} must start with /organizations/#{single_org}" if path[0..1] != [ 'organizations', single_org ]
-          if !name
-            raise "Path #{path} must start with /organizations/#{single_org}/<something>" if path.size <= 2
-          end
           false
+        elsif path[0] == 'organizations'
+          if path.size == 1
+            false
+          elsif path.size >= 2 && path[1] != single_org
+            true
+          else
+            false
+          end
+        else
+          true
         end
       end
     end