cheffish 1.6.0 → 2.0.0

data/lib/chef/resource/chef_group.rb

@@ -1,53 +1,90 @@
 require 'cheffish'
-require 'chef/resource/lwrp_base'
+require 'cheffish/base_resource'
 require 'chef/run_list/run_list_item'
+require 'chef/chef_fs/data_handler/group_data_handler'
 
 class Chef
   class Resource
-    class ChefGroup < Chef::Resource::LWRPBase
-      self.resource_name = 'chef_group'
-
-      actions :create, :delete, :nothing
-      default_action :create
-
-      # Grab environment from with_environment
-      def initialize(*args)
-        super
-        chef_server run_context.cheffish.current_chef_server
-        @users = []
-        @clients = []
-        @groups = []
-        @remove_users = []
-        @remove_clients = []
-        @remove_groups = []
-      end
+    class ChefGroup < Cheffish::BaseResource
+      resource_name :chef_group
 
-      attribute :name, :kind_of => String, :regex => Cheffish::NAME_REGEX, :name_attribute => true
-      def users(*users)
-        users.size == 0 ? @users : (@users |= users.flatten)
-      end
-      def clients(*clients)
-        clients.size == 0 ? @clients : (@clients |= clients.flatten)
-      end
-      def groups(*groups)
-        groups.size == 0 ? @groups : (@groups |= groups.flatten)
-      end
-      def remove_users(*remove_users)
-        remove_users.size == 0 ? @remove_users : (@remove_users |= remove_users.flatten)
-      end
-      def remove_clients(*remove_clients)
-        remove_clients.size == 0 ? @remove_clients : (@remove_clients |= remove_clients.flatten)
+      property :name, Cheffish::NAME_REGEX, name_property: true
+      property :users, ArrayType
+      property :clients, ArrayType
+      property :groups, ArrayType
+      property :remove_users, ArrayType
+      property :remove_clients, ArrayType
+      property :remove_groups, ArrayType
+
+      action :create do
+        differences = json_differences(current_json, new_json)
+
+        if current_resource_exists?
+          if differences.size > 0
+            description = [ "update group #{new_resource.name} at #{rest.url}" ] + differences
+            converge_by description do
+              rest.put("groups/#{new_resource.name}", normalize_for_put(new_json))
+            end
+          end
+        else
+          description = [ "create group #{new_resource.name} at #{rest.url}" ] + differences
+          converge_by description do
+            rest.post("groups", normalize_for_post(new_json))
+          end
+        end
       end
-      def remove_groups(*remove_groups)
-        remove_groups.size == 0 ? @remove_groups : (@remove_groups |= remove_groups.flatten)
+
+      action :delete do
+        if current_resource_exists?
+          converge_by "delete group #{new_resource.name} at #{rest.url}" do
+            rest.delete("groups/#{new_resource.name}")
+          end
+        end
       end
 
-      # Specifies that this is a complete specification for the environment (i.e. attributes you don't specify will be
-      # reset to their defaults)
-      attribute :complete, :kind_of => [TrueClass, FalseClass]
+      action_class.class_eval do
+        def load_current_resource
+          begin
+            @current_resource = json_to_resource(rest.get("groups/#{new_resource.name}"))
+          rescue Net::HTTPServerException => e
+            if e.response.code == "404"
+              @current_resource = not_found_resource
+            else
+              raise
+            end
+          end
+        end
+
+        def augment_new_json(json)
+          # Apply modifiers
+          json['users']   |= new_resource.users
+          json['clients'] |= new_resource.clients
+          json['groups']  |= new_resource.groups
+          json['users']   -= new_resource.remove_users
+          json['clients'] -= new_resource.remove_clients
+          json['groups']  -= new_resource.remove_groups
+          json
+        end
+
+        #
+        # Helpers
+        #
 
-      attribute :raw_json, :kind_of => Hash
-      attribute :chef_server, :kind_of => Hash
+        def resource_class
+          Chef::Resource::ChefGroup
+        end
+
+        def data_handler
+          Chef::ChefFS::DataHandler::GroupDataHandler.new
+        end
+
+        def keys
+          {
+            'name' => :name,
+            'groupname' => :name
+          }
+        end
+      end
     end
   end
 end

data/lib/chef/resource/chef_mirror.rb

@@ -1,52 +1,201 @@
 require 'cheffish'
-require 'chef/resource/lwrp_base'
+require 'cheffish/base_resource'
+require 'chef/chef_fs/file_pattern'
+require 'chef/chef_fs/file_system'
+require 'chef/chef_fs/parallelizer'
+require 'chef/chef_fs/file_system/chef_server_root_dir'
+require 'chef/chef_fs/file_system/chef_repository_file_system_root_dir'
 
 class Chef
   class Resource
-    class ChefMirror < Chef::Resource::LWRPBase
-      self.resource_name = 'chef_mirror'
-
-      actions :upload, :download, :nothing
-      default_action :nothing
-
-      def initialize(*args)
-        super
-        chef_server run_context.cheffish.current_chef_server
-      end
+    class ChefMirror < Cheffish::BaseResource
+      resource_name :chef_mirror
 
       # Path of the data to mirror, e.g. nodes, nodes/*, nodes/mynode,
       # */*, **, roles/base, data/secrets, cookbooks/apache2, etc.
-      attribute :path, :kind_of => String, :name_attribute => true
+      property :path, String, name_property: true
 
       # Local path.  Can be a string (top level of repository) or hash
       # (:chef_repo_path, :node_path, etc.)
       # If neither chef_repo_path nor versioned_cookbooks are set, they default to their
       # Chef::Config values.  If chef_repo_path is set but versioned_cookbooks is not,
       # versioned_cookbooks defaults to true.
-      attribute :chef_repo_path, :kind_of => [ String, Hash ]
+      property :chef_repo_path, [ String, Hash ]
 
       # Whether the repo path should contain cookbooks with versioned names,
       # i.e. cookbooks/mysql-1.0.0, cookbooks/mysql-1.2.0, etc.
       # Defaults to true if chef_repo_path is specified, or to Chef::Config.versioned_cookbooks otherwise.
-      attribute :versioned_cookbooks, :kind_of => [ TrueClass, FalseClass ]
-
-      # Chef server
-      attribute :chef_server, :kind_of => Hash
+      property :versioned_cookbooks, Boolean
 
       # Whether to purge deleted things: if we do not have cookbooks/x locally and we
       # *do* have cookbooks/x remotely, then :upload with purge will delete it.
       # Defaults to false.
-      attribute :purge, :kind_of => [ TrueClass, FalseClass ]
+      property :purge, Boolean
 
       # Whether to freeze cookbooks on upload
-      attribute :freeze, :kind_of => [ TrueClass, FalseClass ]
+      property :freeze, Boolean
 
       # If this is true, only new files will be copied.  File contents will not be
       # diffed, so changed files will never be uploaded.
-      attribute :no_diff, :kind_of => [ TrueClass, FalseClass ]
+      property :no_diff, Boolean
 
       # Number of parallel threads to list/upload/download with.  Defaults to 10.
-      attribute :concurrency, :kind_of => Integer
+      property :concurrency, Integer, default: 10, desired_state: false
+
+
+      action :upload do
+        with_modified_config do
+          copy_to(local_fs, remote_fs)
+        end
+      end
+
+      action :download do
+        with_modified_config do
+          copy_to(remote_fs, local_fs)
+        end
+      end
+
+      action_class.class_eval do
+
+        def with_modified_config
+          # pre-Chef-12 ChefFS reads versioned_cookbooks out of Chef::Config instead of
+          # taking it as an input, so we need to modify it for the duration of copy_to
+          @old_versioned_cookbooks = Chef::Config.versioned_cookbooks
+          # If versioned_cookbooks is explicitly set, set it.
+          if !new_resource.versioned_cookbooks.nil?
+            Chef::Config.versioned_cookbooks = new_resource.versioned_cookbooks
+
+          # If new_resource.chef_repo_path is set, versioned_cookbooks defaults to true.
+          # Otherwise, it stays at its current Chef::Config value.
+          elsif new_resource.chef_repo_path
+            Chef::Config.versioned_cookbooks = true
+          end
+
+          begin
+            yield
+          ensure
+            Chef::Config.versioned_cookbooks = @old_versioned_cookbooks
+          end
+        end
+
+        def copy_to(src_root, dest_root)
+          if new_resource.concurrency <= 0
+            raise "chef_mirror.concurrency must be above 0!  Was set to #{new_resource.concurrency}"
+          end
+          # Honor concurrency
+          Chef::ChefFS::Parallelizer.threads = new_resource.concurrency - 1
+
+          # We don't let the user pass absolute paths; we want to reserve those for
+          # multi-org support (/organizations/foo).
+          if new_resource.path[0] == '/'
+            raise "Absolute paths in chef_mirror not yet supported."
+          end
+          # Copy!
+          path = Chef::ChefFS::FilePattern.new("/#{new_resource.path}")
+          ui = CopyListener.new(self)
+          error = Chef::ChefFS::FileSystem.copy_to(path, src_root, dest_root, nil, options, ui, proc { |p| p.path })
+
+          if error
+            raise "Errors while copying:#{ui.errors.map { |e| "#{e}\n" }.join('')}"
+          end
+        end
+
+        def local_fs
+          # If chef_repo_path is set to a string, put it in the form it usually is in
+          # chef config (:chef_repo_path, :node_path, etc.)
+          path_config = new_resource.chef_repo_path
+          if path_config.is_a?(Hash)
+            chef_repo_path = path_config.delete(:chef_repo_path)
+          elsif path_config
+            chef_repo_path = path_config
+            path_config = {}
+          else
+            chef_repo_path = Chef::Config.chef_repo_path
+            path_config = Chef::Config
+          end
+          chef_repo_path = Array(chef_repo_path).flatten
+
+          # Go through the expected object paths and figure out the local paths for each.
+          case repo_mode
+          when 'hosted_everything'
+            object_names = %w(acls clients cookbooks containers data_bags environments groups nodes roles)
+          else
+            object_names = %w(clients cookbooks data_bags environments nodes roles users)
+          end
+
+          object_paths = {}
+          object_names.each do |object_name|
+            variable_name = "#{object_name[0..-2]}_path" # cookbooks -> cookbook_path
+            if path_config[variable_name.to_sym]
+              paths = Array(path_config[variable_name.to_sym]).flatten
+            else
+              paths = chef_repo_path.map { |path| ::File.join(path, object_name) }
+            end
+            object_paths[object_name] = paths.map { |path| ::File.expand_path(path) }
+          end
+
+          # Set up the root dir
+          Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir.new(object_paths)
+        end
+
+        def remote_fs
+          config = {
+            :chef_server_url => new_resource.chef_server[:chef_server_url],
+            :node_name => new_resource.chef_server[:options][:client_name],
+            :client_key => new_resource.chef_server[:options][:signing_key_filename],
+            :repo_mode => repo_mode,
+            :versioned_cookbooks => Chef::Config.versioned_cookbooks
+          }
+          Chef::ChefFS::FileSystem::ChefServerRootDir.new("remote", config)
+        end
+
+        def repo_mode
+          new_resource.chef_server[:chef_server_url] =~ /\/organizations\// ? 'hosted_everything' : 'everything'
+        end
+
+        def options
+          result = {
+            :purge => new_resource.purge,
+            :freeze => new_resource.freeze,
+            :diff => new_resource.no_diff,
+            :dry_run => whyrun_mode?
+          }
+          result[:diff] = !result[:diff]
+          result[:repo_mode] = repo_mode
+          result[:concurrency] = new_resource.concurrency if new_resource.concurrency
+          result
+        end
+
+        def load_current_resource
+        end
+
+        class CopyListener
+          def initialize(mirror)
+            @mirror = mirror
+            @errors = []
+          end
+
+          attr_reader :mirror
+          attr_reader :errors
+
+          # TODO output is not *always* indicative of a change.  We may want to give
+          # ChefFS the ability to tell us that info.  For now though, assuming any output
+          # means change is pretty damn close to the truth.
+          def output(str)
+            mirror.converge_by str do
+            end
+          end
+          def warn(str)
+            mirror.converge_by "WARNING: #{str}" do
+            end
+          end
+          def error(str)
+            mirror.converge_by "ERROR: #{str}" do
+            end
+            @errors << str
+          end
+        end
+      end
     end
   end
 end

data/lib/chef/resource/chef_node.rb

@@ -1,22 +1,88 @@
 require 'cheffish'
-require 'chef/resource/lwrp_base'
+require 'cheffish/base_resource'
+require 'chef/chef_fs/data_handler/node_data_handler'
+require 'cheffish/node_properties'
 
 class Chef
   class Resource
-    class ChefNode < Chef::Resource::LWRPBase
-      self.resource_name = 'chef_node'
+    class ChefNode < Cheffish::BaseResource
+      resource_name :chef_node
 
-      actions :create, :delete, :nothing
-      default_action :create
+      include Cheffish::NodeProperties
 
-      # Grab environment from with_environment
-      def initialize(*args)
-        super
-        chef_environment run_context.cheffish.current_environment
-        chef_server run_context.cheffish.current_chef_server
+      action :create do
+        differences = json_differences(current_json, new_json)
+
+        if current_resource_exists?
+          if differences.size > 0
+            description = [ "update node #{new_resource.name} at #{rest.url}" ] + differences
+            converge_by description do
+              rest.put("nodes/#{new_resource.name}", normalize_for_put(new_json))
+            end
+          end
+        else
+          description = [ "create node #{new_resource.name} at #{rest.url}" ] + differences
+          converge_by description do
+            rest.post("nodes", normalize_for_post(new_json))
+          end
+        end
+      end
+
+      action :delete do
+        if current_resource_exists?
+          converge_by "delete node #{new_resource.name} at #{rest.url}" do
+            rest.delete("nodes/#{new_resource.name}")
+          end
+        end
       end
 
-      Cheffish.node_attributes(self)
+      action_class.class_eval do
+        def load_current_resource
+          begin
+            @current_resource = json_to_resource(rest.get("nodes/#{new_resource.name}"))
+          rescue Net::HTTPServerException => e
+            if e.response.code == "404"
+              @current_resource = not_found_resource
+            else
+              raise
+            end
+          end
+        end
+
+        def augment_new_json(json)
+          # Preserve tags even if "attributes" was overwritten directly
+          json['normal']['tags'] = current_json['normal']['tags'] unless json['normal']['tags']
+          # Apply modifiers
+          json['run_list'] = apply_run_list_modifiers(new_resource.run_list_modifiers, new_resource.run_list_removers, json['run_list'])
+          json['normal'] = apply_modifiers(new_resource.attribute_modifiers, json['normal'])
+          # Preserve default/override/automatic even when "complete true"
+          json['default'] = current_json['default']
+          json['override'] = current_json['override']
+          json['automatic'] = current_json['automatic']
+          json
+        end
+
+        #
+        # Helpers
+        #
+
+        def resource_class
+          Chef::Resource::ChefNode
+        end
+
+        def data_handler
+          Chef::ChefFS::DataHandler::NodeDataHandler.new
+        end
+
+        def keys
+          {
+            'name' => :name,
+            'chef_environment' => :chef_environment,
+            'run_list' => :run_list,
+            'normal' => :attributes
+          }
+        end
+      end
     end
   end
 end

data/lib/chef/resource/chef_organization.rb

@@ -1,69 +1,179 @@
 require 'cheffish'
-require 'chef/resource/lwrp_base'
+require 'cheffish/base_resource'
 require 'chef/run_list/run_list_item'
+require 'chef/chef_fs/data_handler/data_handler_base'
 
 class Chef
   class Resource
-    class ChefOrganization < Chef::Resource::LWRPBase
-      self.resource_name = 'chef_organization'
-
-      actions :create, :delete, :nothing
-      default_action :create
-
-      # Grab environment from with_environment
-      def initialize(*args)
-        super
-        chef_server run_context.cheffish.current_chef_server
-        @invites = nil
-        @members = nil
-        @remove_members = []
-      end
+    class ChefOrganization < Cheffish::BaseResource
+      resource_name :chef_organization
 
-      attribute :name, :kind_of => String, :regex => Cheffish::NAME_REGEX, :name_attribute => true
-      attribute :full_name, :kind_of => String
+      property :name, Cheffish::NAME_REGEX, name_property: true
+      property :full_name, String
 
       # A list of users who must at least be invited to the org (but may already be
       # members).  Invites will be sent to users who are not already invited/in the org.
-      def invites(*users)
-        if users.size == 0
-          @invites || []
-        else
-          @invites ||= []
-          @invites |= users.flatten
-        end
-      end
-
-      def invites_specified?
-        !!@invites
-      end
+      property :invites, ArrayType
 
       # A list of users who must be members of the org.  This will use the
       # new Chef 12 POST /organizations/ORG/users endpoint to add them
       # directly to the org.  If you do not have permission to perform
       # this operation, and the users are not a part of the org, the
       # resource update will fail.
-      def members(*users)
-        if users.size == 0
-          @members || []
+      property :members, ArrayType
+
+      # A list of users who must not be members of the org.  These users will be removed
+      # from the org and invites will be revoked (if any).
+      property :remove_members, ArrayType
+
+
+      action :create do
+        differences = json_differences(current_json, new_json)
+
+        if current_resource_exists?
+          if differences.size > 0
+            description = [ "update organization #{new_resource.name} at #{rest.url}" ] + differences
+            converge_by description do
+              rest.put("#{rest.root_url}/organizations/#{new_resource.name}", normalize_for_put(new_json))
+            end
+          end
         else
-          @members ||= []
-          @members |= users.flatten
+          description = [ "create organization #{new_resource.name} at #{rest.url}" ] + differences
+          converge_by description do
+            rest.post("#{rest.root_url}/organizations", normalize_for_post(new_json))
+          end
+        end
+
+        # Revoke invites and memberships when asked
+        invites_to_remove.each do |user|
+          if outstanding_invites.has_key?(user)
+            converge_by "revoke #{user}'s invitation to organization #{new_resource.name}" do
+              rest.delete("#{rest.root_url}/organizations/#{new_resource.name}/association_requests/#{outstanding_invites[user]}")
+            end
+          end
+        end
+        members_to_remove.each do |user|
+          if existing_members.include?(user)
+            converge_by "remove #{user} from organization #{new_resource.name}" do
+              rest.delete("#{rest.root_url}/organizations/#{new_resource.name}/users/#{user}")
+            end
+          end
+        end
+
+        # Invite and add members when asked
+        new_resource.invites.each do |user|
+          if !existing_members.include?(user) && !outstanding_invites.has_key?(user)
+            converge_by "invite #{user} to organization #{new_resource.name}" do
+              rest.post("#{rest.root_url}/organizations/#{new_resource.name}/association_requests", { 'user' => user })
+            end
+          end
+        end
+        new_resource.members.each do |user|
+          if !existing_members.include?(user)
+            converge_by "Add #{user} to organization #{new_resource.name}" do
+              rest.post("#{rest.root_url}/organizations/#{new_resource.name}/users/", { 'username' => user })
+            end
+          end
+        end
+      end
+
+      action_class.class_eval do
+        def existing_members
+          @existing_members ||= rest.get("#{rest.root_url}/organizations/#{new_resource.name}/users").map { |u| u['user']['username'] }
+        end
+
+        def outstanding_invites
+          @outstanding_invites ||= begin
+            invites = {}
+            rest.get("#{rest.root_url}/organizations/#{new_resource.name}/association_requests").each do |r|
+              invites[r['username']] = r['id']
+            end
+            invites
+          end
+        end
+
+        def invites_to_remove
+          if new_resource.complete
+            if new_resource.property_is_set?(:invites) || new_resource.property_is_set?(:members)
+              result = outstanding_invites.keys
+              result -= new_resource.invites if new_resource.property_is_set?(:invites)
+              result -= new_resource.members if new_resource.property_is_set?(:members)
+              result
+            else
+              []
+            end
+          else
+            new_resource.remove_members
+          end
+        end
+
+        def members_to_remove
+          if new_resource.complete
+            if new_resource.property_is_set?(:members)
+              existing_members - (new_resource.invites | new_resource.members)
+            else
+              []
+            end
+          else
+            new_resource.remove_members
+          end
         end
       end
 
-      def members_specified?
-        !!@members
+      action :delete do
+        if current_resource_exists?
+          converge_by "delete organization #{new_resource.name} at #{rest.url}" do
+            rest.delete("#{rest.root_url}/organizations/#{new_resource.name}")
+          end
+        end
       end
 
-      # A list of users who must not be members of the org.  These users will be removed
-      # from the org and invites will be revoked (if any).
-      def remove_members(*users)
-        users.size == 0 ? @remove_members : (@remove_members |= users.flatten)
+      action_class.class_eval do
+        def load_current_resource
+          begin
+            @current_resource = json_to_resource(rest.get("#{rest.root_url}/organizations/#{new_resource.name}"))
+          rescue Net::HTTPServerException => e
+            if e.response.code == "404"
+              @current_resource = not_found_resource
+            else
+              raise
+            end
+          end
+        end
+
+        #
+        # Helpers
+        #
+
+        def resource_class
+          Chef::Resource::ChefOrganization
+        end
+
+        def data_handler
+          OrganizationDataHandler.new
+        end
+
+        def keys
+          {
+            'name' => :name,
+            'full_name' => :full_name
+          }
+        end
+
+        class OrganizationDataHandler < Chef::ChefFS::DataHandler::DataHandlerBase
+          def normalize(organization, entry)
+            # Normalize the order of the keys for easier reading
+            normalize_hash(organization, {
+              'name' => remove_dot_json(entry.name),
+              'full_name' => remove_dot_json(entry.name),
+              'org_type' => 'Business',
+              'clientname' => "#{remove_dot_json(entry.name)}-validator",
+              'billing_plan' => 'platform-free'
+            })
+          end
+        end
       end
 
-      attribute :complete, :kind_of => [ TrueClass, FalseClass ]
-      attribute :raw_json, :kind_of => Hash
-      attribute :chef_server, :kind_of => Hash
     end
   end
 end