chef 14.5.27-universal-mingw32 → 14.5.33-universal-mingw32

data/lib/chef/api_client/registration.rb

@@ -1,200 +1,200 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2016, Chef Software 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/config"
-require "chef/server_api"
-require "chef/exceptions"
-require "fileutils"
-
-class Chef
-  class ApiClient
-
-    # ==Chef::ApiClient::Registration
-    # Manages the process of creating or updating a Chef::ApiClient on the
-    # server and writing the resulting private key to disk. Registration uses
-    # the validator credentials for its API calls. This allows it to bootstrap
-    # a new client/node identity by borrowing the validator client identity
-    # when creating a new client.
-    class Registration
-      attr_reader :destination
-      attr_reader :name
-
-      def initialize(name, destination, http_api: nil)
-        @name                         = name
-        @destination                  = destination
-        @http_api                     = http_api
-        @server_generated_private_key = nil
-      end
-
-      # Runs the client registration process, including creating the client on
-      # the chef-server and writing its private key to disk.
-      #--
-      # If client creation fails with a 5xx, it is retried up to 5 times. These
-      # retries are on top of the retries with randomized exponential backoff
-      # built in to Chef::ServerAPI. The retries here are a workaround for failures
-      # caused by resource contention in Hosted Chef when creating a very large
-      # number of clients simultaneously, (e.g., spinning up 100s of ec2 nodes
-      # at once). Future improvements to the affected component should make
-      # these retries unnecessary.
-      def run
-        assert_destination_writable!
-        retries = Config[:client_registration_retries] || 5
-        client = nil
-        begin
-          client = api_client(create_or_update)
-        rescue Net::HTTPFatalError => e
-          # HTTPFatalError implies 5xx.
-          raise if retries <= 0
-          retries -= 1
-          Chef::Log.warn("Failed to register new client, #{retries} tries remaining")
-          Chef::Log.warn("Response: HTTP #{e.response.code} - #{e}")
-          retry
-        end
-        write_key
-        client
-      end
-
-      def assert_destination_writable!
-        abs_path = File.expand_path(destination)
-        if !File.exists?(File.dirname(abs_path))
-          begin
-            FileUtils.mkdir_p(File.dirname(abs_path))
-          rescue Errno::EACCES
-            raise Chef::Exceptions::CannotWritePrivateKey, "I can't create the configuration directory at #{File.dirname(abs_path)} - check permissions?"
-          end
-        end
-        if (File.exists?(abs_path) && !File.writable?(abs_path)) || !File.writable?(File.dirname(abs_path))
-          raise Chef::Exceptions::CannotWritePrivateKey, "I can't write your private key to #{abs_path} - check permissions?"
-        end
-      end
-
-      def write_key
-        ::File.open(destination, file_flags, 0600) do |f|
-          f.print(private_key)
-        end
-      rescue IOError => e
-        raise Chef::Exceptions::CannotWritePrivateKey, "Error writing private key to #{destination}: #{e}"
-      end
-
-      def create_or_update
-        create
-      rescue Net::HTTPServerException => e
-        # If create fails because the client exists, attempt to update. This
-        # requires admin privileges.
-        raise unless e.response.code == "409"
-        update
-      end
-
-      def create
-        response = http_api.post("clients", post_data)
-        @server_generated_private_key = response["private_key"]
-        response
-      end
-
-      def update
-        response = http_api.put("clients/#{name}", put_data)
-        if response.respond_to?(:private_key) # Chef 11
-          @server_generated_private_key = response.private_key
-        else # Chef 10
-          @server_generated_private_key = response["private_key"]
-        end
-        response
-      end
-
-      def api_client(response)
-        return response if response.is_a?(Chef::ApiClient)
-
-        client = Chef::ApiClient.new
-        client.name(name)
-        client.public_key(api_client_key(response, "public_key"))
-        client.private_key(api_client_key(response, "private_key"))
-        client
-      end
-
-      def api_client_key(response, key_name)
-        if response[key_name]
-          if response[key_name].respond_to?(:to_pem)
-            response[key_name].to_pem
-          else
-            response[key_name]
-          end
-        elsif response["chef_key"]
-          response["chef_key"][key_name]
-        end
-      end
-
-      def put_data
-        base_put_data = { name: name, admin: false }
-        if self_generate_keys?
-          base_put_data[:public_key] = generated_public_key
-        else
-          base_put_data[:private_key] = true
-        end
-        base_put_data
-      end
-
-      def post_data
-        post_data = { name: name, admin: false }
-        post_data[:public_key] = generated_public_key if self_generate_keys?
-        post_data
-      end
-
-      def http_api
-        @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url],
-                                          {
-                                            api_version: "0",
-                                            client_name: Chef::Config[:validation_client_name],
-                                            signing_key_filename: Chef::Config[:validation_key],
-                                          }
-                                         )
-      end
-
-      # Whether or not to generate keys locally and post the public key to the
-      # server. Delegates to `Chef::Config.local_key_generation`. Servers
-      # before 11.0 do not support this feature.
-      def self_generate_keys?
-        Chef::Config.local_key_generation
-      end
-
-      def private_key
-        if self_generate_keys?
-          generated_private_key.to_pem
-        else
-          @server_generated_private_key
-        end
-      end
-
-      def generated_private_key
-        @generated_key ||= OpenSSL::PKey::RSA.generate(2048)
-      end
-
-      def generated_public_key
-        generated_private_key.public_key.to_pem
-      end
-
-      def file_flags
-        base_flags = File::CREAT | File::TRUNC | File::RDWR
-        # Windows doesn't have symlinks, so it doesn't have NOFOLLOW
-        if defined?(File::NOFOLLOW) && !Chef::Config[:follow_client_key_symlink]
-          base_flags |= File::NOFOLLOW
-        end
-        base_flags
-      end
-    end
-  end
-end
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2012-2016, Chef Software 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/config"
+require "chef/server_api"
+require "chef/exceptions"
+require "fileutils"
+
+class Chef
+  class ApiClient
+
+    # ==Chef::ApiClient::Registration
+    # Manages the process of creating or updating a Chef::ApiClient on the
+    # server and writing the resulting private key to disk. Registration uses
+    # the validator credentials for its API calls. This allows it to bootstrap
+    # a new client/node identity by borrowing the validator client identity
+    # when creating a new client.
+    class Registration
+      attr_reader :destination
+      attr_reader :name
+
+      def initialize(name, destination, http_api: nil)
+        @name                         = name
+        @destination                  = destination
+        @http_api                     = http_api
+        @server_generated_private_key = nil
+      end
+
+      # Runs the client registration process, including creating the client on
+      # the chef-server and writing its private key to disk.
+      #--
+      # If client creation fails with a 5xx, it is retried up to 5 times. These
+      # retries are on top of the retries with randomized exponential backoff
+      # built in to Chef::ServerAPI. The retries here are a workaround for failures
+      # caused by resource contention in Hosted Chef when creating a very large
+      # number of clients simultaneously, (e.g., spinning up 100s of ec2 nodes
+      # at once). Future improvements to the affected component should make
+      # these retries unnecessary.
+      def run
+        assert_destination_writable!
+        retries = Config[:client_registration_retries] || 5
+        client = nil
+        begin
+          client = api_client(create_or_update)
+        rescue Net::HTTPFatalError => e
+          # HTTPFatalError implies 5xx.
+          raise if retries <= 0
+          retries -= 1
+          Chef::Log.warn("Failed to register new client, #{retries} tries remaining")
+          Chef::Log.warn("Response: HTTP #{e.response.code} - #{e}")
+          retry
+        end
+        write_key
+        client
+      end
+
+      def assert_destination_writable!
+        abs_path = File.expand_path(destination)
+        if !File.exists?(File.dirname(abs_path))
+          begin
+            FileUtils.mkdir_p(File.dirname(abs_path))
+          rescue Errno::EACCES
+            raise Chef::Exceptions::CannotWritePrivateKey, "I can't create the configuration directory at #{File.dirname(abs_path)} - check permissions?"
+          end
+        end
+        if (File.exists?(abs_path) && !File.writable?(abs_path)) || !File.writable?(File.dirname(abs_path))
+          raise Chef::Exceptions::CannotWritePrivateKey, "I can't write your private key to #{abs_path} - check permissions?"
+        end
+      end
+
+      def write_key
+        ::File.open(destination, file_flags, 0600) do |f|
+          f.print(private_key)
+        end
+      rescue IOError => e
+        raise Chef::Exceptions::CannotWritePrivateKey, "Error writing private key to #{destination}: #{e}"
+      end
+
+      def create_or_update
+        create
+      rescue Net::HTTPServerException => e
+        # If create fails because the client exists, attempt to update. This
+        # requires admin privileges.
+        raise unless e.response.code == "409"
+        update
+      end
+
+      def create
+        response = http_api.post("clients", post_data)
+        @server_generated_private_key = response["private_key"]
+        response
+      end
+
+      def update
+        response = http_api.put("clients/#{name}", put_data)
+        if response.respond_to?(:private_key) # Chef 11
+          @server_generated_private_key = response.private_key
+        else # Chef 10
+          @server_generated_private_key = response["private_key"]
+        end
+        response
+      end
+
+      def api_client(response)
+        return response if response.is_a?(Chef::ApiClient)
+
+        client = Chef::ApiClient.new
+        client.name(name)
+        client.public_key(api_client_key(response, "public_key"))
+        client.private_key(api_client_key(response, "private_key"))
+        client
+      end
+
+      def api_client_key(response, key_name)
+        if response[key_name]
+          if response[key_name].respond_to?(:to_pem)
+            response[key_name].to_pem
+          else
+            response[key_name]
+          end
+        elsif response["chef_key"]
+          response["chef_key"][key_name]
+        end
+      end
+
+      def put_data
+        base_put_data = { name: name, admin: false }
+        if self_generate_keys?
+          base_put_data[:public_key] = generated_public_key
+        else
+          base_put_data[:private_key] = true
+        end
+        base_put_data
+      end
+
+      def post_data
+        post_data = { name: name, admin: false }
+        post_data[:public_key] = generated_public_key if self_generate_keys?
+        post_data
+      end
+
+      def http_api
+        @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url],
+                                          {
+                                            api_version: "0",
+                                            client_name: Chef::Config[:validation_client_name],
+                                            signing_key_filename: Chef::Config[:validation_key],
+                                          }
+                                         )
+      end
+
+      # Whether or not to generate keys locally and post the public key to the
+      # server. Delegates to `Chef::Config.local_key_generation`. Servers
+      # before 11.0 do not support this feature.
+      def self_generate_keys?
+        Chef::Config.local_key_generation
+      end
+
+      def private_key
+        if self_generate_keys?
+          generated_private_key.to_pem
+        else
+          @server_generated_private_key
+        end
+      end
+
+      def generated_private_key
+        @generated_key ||= OpenSSL::PKey::RSA.generate(2048)
+      end
+
+      def generated_public_key
+        generated_private_key.public_key.to_pem
+      end
+
+      def file_flags
+        base_flags = File::CREAT | File::TRUNC | File::RDWR
+        # Windows doesn't have symlinks, so it doesn't have NOFOLLOW
+        if defined?(File::NOFOLLOW) && !Chef::Config[:follow_client_key_symlink]
+          base_flags |= File::NOFOLLOW
+        end
+        base_flags
+      end
+    end
+  end
+end

data/lib/chef/api_client_v1.rb

@@ -1,324 +1,324 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Nuo Yan (<nuo@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software, 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/config"
-require "chef/mixin/params_validate"
-require "chef/mixin/from_file"
-require "chef/mash"
-require "chef/json_compat"
-require "chef/search/query"
-require "chef/exceptions"
-require "chef/mixin/api_version_request_handling"
-require "chef/server_api"
-require "chef/api_client"
-
-# COMPATIBILITY NOTE
-#
-# This ApiClientV1 code attempts to make API V1 requests and falls back to
-# API V0 requests when it fails. New development should occur here instead
-# of Chef::ApiClient as this will replace that namespace when Chef 13 is released.
-#
-# If you need to default to API V0 behavior (i.e. you need GET client to return
-# a public key, etc), please use Chef::ApiClient and update your code to support
-# API V1 before you pull in Chef 13.
-class Chef
-  class ApiClientV1
-
-    include Chef::Mixin::FromFile
-    include Chef::Mixin::ParamsValidate
-    include Chef::Mixin::ApiVersionRequestHandling
-
-    SUPPORTED_API_VERSIONS = [0, 1].freeze
-
-    # Create a new Chef::ApiClientV1 object.
-    def initialize
-      @name = ""
-      @public_key = nil
-      @private_key = nil
-      @admin = false
-      @validator = false
-      @create_key = nil
-    end
-
-    def chef_rest_v0
-      @chef_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "0", inflate_json_class: false })
-    end
-
-    def chef_rest_v1
-      @chef_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "1", inflate_json_class: false })
-    end
-
-    def self.http_api
-      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "1", inflate_json_class: false })
-    end
-
-    # Gets or sets the client name.
-    #
-    # @param arg [Optional String] The name must be alpha-numeric plus - and _.
-    # @return [String] The current value of the name.
-    def name(arg = nil)
-      set_or_return(
-        :name,
-        arg,
-        regex: /^[\-[:alnum:]_\.]+$/
-      )
-    end
-
-    # Gets or sets whether this client is an admin.
-    #
-    # @param arg [Optional True/False] Should be true or false - default is false.
-    # @return [True/False] The current value
-    def admin(arg = nil)
-      set_or_return(
-        :admin,
-        arg,
-        kind_of: [ TrueClass, FalseClass ]
-      )
-    end
-
-    # Gets or sets the public key.
-    #
-    # @param arg [Optional String] The string representation of the public key.
-    # @return [String] The current value.
-    def public_key(arg = nil)
-      set_or_return(
-        :public_key,
-        arg,
-        kind_of: String
-      )
-    end
-
-    # Gets or sets whether this client is a validator.
-    #
-    # @param arg [Boolean] whether or not the client is a validator.  If
-    #   `nil`, retrieves the already-set value.
-    # @return [Boolean] The current value
-    def validator(arg = nil)
-      set_or_return(
-        :validator,
-        arg,
-        kind_of: [TrueClass, FalseClass]
-      )
-    end
-
-    # Private key. The server will return it as a string.
-    # Set to true under API V0 to have the server regenerate the default key.
-    #
-    # @param arg [Optional String] The string representation of the private key.
-    # @return [String] The current value.
-    def private_key(arg = nil)
-      set_or_return(
-        :private_key,
-        arg,
-        kind_of: [String, TrueClass, FalseClass]
-      )
-    end
-
-    # Used to ask server to generate key pair under api V1
-    #
-    # @param arg [Optional True/False] Should be true or false - default is false.
-    # @return [True/False] The current value
-    def create_key(arg = nil)
-      set_or_return(
-        :create_key,
-        arg,
-        kind_of: [ TrueClass, FalseClass ]
-      )
-    end
-
-    # The hash representation of the object. Includes the name and public_key.
-    # Private key is included if available.
-    #
-    # @return [Hash]
-    def to_hash
-      result = {
-        "name" => @name,
-        "validator" => @validator,
-        "admin" => @admin,
-        "chef_type" => "client",
-      }
-      result["private_key"] = @private_key unless @private_key.nil?
-      result["public_key"] = @public_key unless @public_key.nil?
-      result["create_key"] = @create_key unless @create_key.nil?
-      result
-    end
-
-    # The JSON representation of the object.
-    #
-    # @return [String] the JSON string.
-    def to_json(*a)
-      Chef::JSONCompat.to_json(to_hash, *a)
-    end
-
-    def self.from_hash(o)
-      client = Chef::ApiClientV1.new
-      client.name(o["name"] || o["clientname"])
-      client.admin(o["admin"])
-      client.validator(o["validator"])
-      client.private_key(o["private_key"]) if o.key?("private_key")
-      client.public_key(o["public_key"]) if o.key?("public_key")
-      client.create_key(o["create_key"]) if o.key?("create_key")
-      client
-    end
-
-    def self.from_json(j)
-      Chef::ApiClientV1.from_hash(Chef::JSONCompat.from_json(j))
-    end
-
-    def self.reregister(name)
-      api_client = Chef::ApiClientV1.load(name)
-      api_client.reregister
-    end
-
-    def self.list(inflate = false)
-      if inflate
-        response = Hash.new
-        Chef::Search::Query.new.search(:client) do |n|
-          n = from_hash(n) if n.instance_of?(Hash)
-          response[n.name] = n
-        end
-        response
-      else
-        http_api.get("clients")
-      end
-    end
-
-    # Load a client by name via the API
-    # @param name [String] the client name
-    def self.load(name)
-      response = http_api.get("clients/#{name}")
-      Chef::ApiClientV1.from_hash(response)
-    end
-
-    # Remove this client via the REST API
-    def destroy
-      chef_rest_v1.delete("clients/#{@name}")
-    end
-
-    # Save this client via the REST API, returns a hash including the private key
-    def save
-      update
-    rescue Net::HTTPServerException => e
-      # If that fails, go ahead and try and update it
-      if e.response.code == "404"
-        create
-      else
-        raise e
-      end
-    end
-
-    def reregister
-      # Try API V0 and if it fails due to V0 not being supported, raise the proper error message.
-      # reregister only supported in API V0 or lesser.
-      reregistered_self = chef_rest_v0.put("clients/#{name}", { name: name, admin: admin, validator: validator, private_key: true })
-      if reregistered_self.respond_to?(:[])
-        private_key(reregistered_self["private_key"])
-      else
-        private_key(reregistered_self.private_key)
-      end
-      self
-    rescue Net::HTTPServerException => e
-      # if there was a 406 related to versioning, give error explaining that
-      # only API version 0 is supported for reregister command
-      if e.response.code == "406" && e.response["x-ops-server-api-version"]
-        version_header = Chef::JSONCompat.from_json(e.response["x-ops-server-api-version"])
-        min_version = version_header["min_version"]
-        max_version = version_header["max_version"]
-        error_msg = reregister_only_v0_supported_error_msg(max_version, min_version)
-        raise Chef::Exceptions::OnlyApiVersion0SupportedForAction.new(error_msg)
-      else
-        raise e
-      end
-    end
-
-    # Updates the client via the REST API
-    def update
-      # NOTE: API V1 dropped support for updating client keys via update (aka PUT),
-      # but this code never supported key updating in the first place. Since
-      # it was never implemented, we will simply ignore that functionality
-      # as it is being deprecated.
-      # Delete this comment after V0 support is dropped.
-      payload = { name: name }
-      payload[:validator] = validator unless validator.nil?
-
-      # DEPRECATION
-      # This field is ignored in API V1, but left for backwards-compat,
-      # can remove after API V0 is no longer supported.
-      payload[:admin] = admin unless admin.nil?
-
-      begin
-        new_client = chef_rest_v1.put("clients/#{name}", payload)
-      rescue Net::HTTPServerException => e
-        # rescue API V0 if 406 and the server supports V0
-        supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
-        raise e unless supported_versions && supported_versions.include?(0)
-        new_client = chef_rest_v0.put("clients/#{name}", payload)
-      end
-
-      Chef::ApiClientV1.from_hash(new_client)
-    end
-
-    # Create the client via the REST API
-    def create
-      payload = {
-        name: name,
-        validator: validator,
-        # this field is ignored in API V1, but left for backwards-compat,
-        # can remove after OSC 11 support is finished?
-        admin: admin,
-      }
-      begin
-        # try API V1
-        raise Chef::Exceptions::InvalidClientAttribute, "You cannot set both public_key and create_key for create." if !create_key.nil? && !public_key.nil?
-
-        payload[:public_key] = public_key unless public_key.nil?
-        payload[:create_key] = create_key unless create_key.nil?
-
-        new_client = chef_rest_v1.post("clients", payload)
-
-        # get the private_key out of the chef_key hash if it exists
-        if new_client["chef_key"]
-          if new_client["chef_key"]["private_key"]
-            new_client["private_key"] = new_client["chef_key"]["private_key"]
-          end
-          new_client["public_key"] = new_client["chef_key"]["public_key"]
-          new_client.delete("chef_key")
-        end
-
-      rescue Net::HTTPServerException => e
-        # rescue API V0 if 406 and the server supports V0
-        supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
-        raise e unless supported_versions && supported_versions.include?(0)
-
-        # under API V0, a key pair will always be created unless public_key is
-        # passed on initial POST
-        payload[:public_key] = public_key unless public_key.nil?
-
-        new_client = chef_rest_v0.post("clients", payload)
-      end
-      Chef::ApiClientV1.from_hash(to_hash.merge(new_client))
-    end
-
-    # As a string
-    def to_s
-      "client[#{@name}]"
-    end
-
-  end
-end
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Nuo Yan (<nuo@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software, 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/config"
+require "chef/mixin/params_validate"
+require "chef/mixin/from_file"
+require "chef/mash"
+require "chef/json_compat"
+require "chef/search/query"
+require "chef/exceptions"
+require "chef/mixin/api_version_request_handling"
+require "chef/server_api"
+require "chef/api_client"
+
+# COMPATIBILITY NOTE
+#
+# This ApiClientV1 code attempts to make API V1 requests and falls back to
+# API V0 requests when it fails. New development should occur here instead
+# of Chef::ApiClient as this will replace that namespace when Chef 13 is released.
+#
+# If you need to default to API V0 behavior (i.e. you need GET client to return
+# a public key, etc), please use Chef::ApiClient and update your code to support
+# API V1 before you pull in Chef 13.
+class Chef
+  class ApiClientV1
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    include Chef::Mixin::ApiVersionRequestHandling
+
+    SUPPORTED_API_VERSIONS = [0, 1].freeze
+
+    # Create a new Chef::ApiClientV1 object.
+    def initialize
+      @name = ""
+      @public_key = nil
+      @private_key = nil
+      @admin = false
+      @validator = false
+      @create_key = nil
+    end
+
+    def chef_rest_v0
+      @chef_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "0", inflate_json_class: false })
+    end
+
+    def chef_rest_v1
+      @chef_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "1", inflate_json_class: false })
+    end
+
+    def self.http_api
+      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "1", inflate_json_class: false })
+    end
+
+    # Gets or sets the client name.
+    #
+    # @param arg [Optional String] The name must be alpha-numeric plus - and _.
+    # @return [String] The current value of the name.
+    def name(arg = nil)
+      set_or_return(
+        :name,
+        arg,
+        regex: /^[\-[:alnum:]_\.]+$/
+      )
+    end
+
+    # Gets or sets whether this client is an admin.
+    #
+    # @param arg [Optional True/False] Should be true or false - default is false.
+    # @return [True/False] The current value
+    def admin(arg = nil)
+      set_or_return(
+        :admin,
+        arg,
+        kind_of: [ TrueClass, FalseClass ]
+      )
+    end
+
+    # Gets or sets the public key.
+    #
+    # @param arg [Optional String] The string representation of the public key.
+    # @return [String] The current value.
+    def public_key(arg = nil)
+      set_or_return(
+        :public_key,
+        arg,
+        kind_of: String
+      )
+    end
+
+    # Gets or sets whether this client is a validator.
+    #
+    # @param arg [Boolean] whether or not the client is a validator.  If
+    #   `nil`, retrieves the already-set value.
+    # @return [Boolean] The current value
+    def validator(arg = nil)
+      set_or_return(
+        :validator,
+        arg,
+        kind_of: [TrueClass, FalseClass]
+      )
+    end
+
+    # Private key. The server will return it as a string.
+    # Set to true under API V0 to have the server regenerate the default key.
+    #
+    # @param arg [Optional String] The string representation of the private key.
+    # @return [String] The current value.
+    def private_key(arg = nil)
+      set_or_return(
+        :private_key,
+        arg,
+        kind_of: [String, TrueClass, FalseClass]
+      )
+    end
+
+    # Used to ask server to generate key pair under api V1
+    #
+    # @param arg [Optional True/False] Should be true or false - default is false.
+    # @return [True/False] The current value
+    def create_key(arg = nil)
+      set_or_return(
+        :create_key,
+        arg,
+        kind_of: [ TrueClass, FalseClass ]
+      )
+    end
+
+    # The hash representation of the object. Includes the name and public_key.
+    # Private key is included if available.
+    #
+    # @return [Hash]
+    def to_hash
+      result = {
+        "name" => @name,
+        "validator" => @validator,
+        "admin" => @admin,
+        "chef_type" => "client",
+      }
+      result["private_key"] = @private_key unless @private_key.nil?
+      result["public_key"] = @public_key unless @public_key.nil?
+      result["create_key"] = @create_key unless @create_key.nil?
+      result
+    end
+
+    # The JSON representation of the object.
+    #
+    # @return [String] the JSON string.
+    def to_json(*a)
+      Chef::JSONCompat.to_json(to_hash, *a)
+    end
+
+    def self.from_hash(o)
+      client = Chef::ApiClientV1.new
+      client.name(o["name"] || o["clientname"])
+      client.admin(o["admin"])
+      client.validator(o["validator"])
+      client.private_key(o["private_key"]) if o.key?("private_key")
+      client.public_key(o["public_key"]) if o.key?("public_key")
+      client.create_key(o["create_key"]) if o.key?("create_key")
+      client
+    end
+
+    def self.from_json(j)
+      Chef::ApiClientV1.from_hash(Chef::JSONCompat.from_json(j))
+    end
+
+    def self.reregister(name)
+      api_client = Chef::ApiClientV1.load(name)
+      api_client.reregister
+    end
+
+    def self.list(inflate = false)
+      if inflate
+        response = Hash.new
+        Chef::Search::Query.new.search(:client) do |n|
+          n = from_hash(n) if n.instance_of?(Hash)
+          response[n.name] = n
+        end
+        response
+      else
+        http_api.get("clients")
+      end
+    end
+
+    # Load a client by name via the API
+    # @param name [String] the client name
+    def self.load(name)
+      response = http_api.get("clients/#{name}")
+      Chef::ApiClientV1.from_hash(response)
+    end
+
+    # Remove this client via the REST API
+    def destroy
+      chef_rest_v1.delete("clients/#{@name}")
+    end
+
+    # Save this client via the REST API, returns a hash including the private key
+    def save
+      update
+    rescue Net::HTTPServerException => e
+      # If that fails, go ahead and try and update it
+      if e.response.code == "404"
+        create
+      else
+        raise e
+      end
+    end
+
+    def reregister
+      # Try API V0 and if it fails due to V0 not being supported, raise the proper error message.
+      # reregister only supported in API V0 or lesser.
+      reregistered_self = chef_rest_v0.put("clients/#{name}", { name: name, admin: admin, validator: validator, private_key: true })
+      if reregistered_self.respond_to?(:[])
+        private_key(reregistered_self["private_key"])
+      else
+        private_key(reregistered_self.private_key)
+      end
+      self
+    rescue Net::HTTPServerException => e
+      # if there was a 406 related to versioning, give error explaining that
+      # only API version 0 is supported for reregister command
+      if e.response.code == "406" && e.response["x-ops-server-api-version"]
+        version_header = Chef::JSONCompat.from_json(e.response["x-ops-server-api-version"])
+        min_version = version_header["min_version"]
+        max_version = version_header["max_version"]
+        error_msg = reregister_only_v0_supported_error_msg(max_version, min_version)
+        raise Chef::Exceptions::OnlyApiVersion0SupportedForAction.new(error_msg)
+      else
+        raise e
+      end
+    end
+
+    # Updates the client via the REST API
+    def update
+      # NOTE: API V1 dropped support for updating client keys via update (aka PUT),
+      # but this code never supported key updating in the first place. Since
+      # it was never implemented, we will simply ignore that functionality
+      # as it is being deprecated.
+      # Delete this comment after V0 support is dropped.
+      payload = { name: name }
+      payload[:validator] = validator unless validator.nil?
+
+      # DEPRECATION
+      # This field is ignored in API V1, but left for backwards-compat,
+      # can remove after API V0 is no longer supported.
+      payload[:admin] = admin unless admin.nil?
+
+      begin
+        new_client = chef_rest_v1.put("clients/#{name}", payload)
+      rescue Net::HTTPServerException => e
+        # rescue API V0 if 406 and the server supports V0
+        supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
+        raise e unless supported_versions && supported_versions.include?(0)
+        new_client = chef_rest_v0.put("clients/#{name}", payload)
+      end
+
+      Chef::ApiClientV1.from_hash(new_client)
+    end
+
+    # Create the client via the REST API
+    def create
+      payload = {
+        name: name,
+        validator: validator,
+        # this field is ignored in API V1, but left for backwards-compat,
+        # can remove after OSC 11 support is finished?
+        admin: admin,
+      }
+      begin
+        # try API V1
+        raise Chef::Exceptions::InvalidClientAttribute, "You cannot set both public_key and create_key for create." if !create_key.nil? && !public_key.nil?
+
+        payload[:public_key] = public_key unless public_key.nil?
+        payload[:create_key] = create_key unless create_key.nil?
+
+        new_client = chef_rest_v1.post("clients", payload)
+
+        # get the private_key out of the chef_key hash if it exists
+        if new_client["chef_key"]
+          if new_client["chef_key"]["private_key"]
+            new_client["private_key"] = new_client["chef_key"]["private_key"]
+          end
+          new_client["public_key"] = new_client["chef_key"]["public_key"]
+          new_client.delete("chef_key")
+        end
+
+      rescue Net::HTTPServerException => e
+        # rescue API V0 if 406 and the server supports V0
+        supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
+        raise e unless supported_versions && supported_versions.include?(0)
+
+        # under API V0, a key pair will always be created unless public_key is
+        # passed on initial POST
+        payload[:public_key] = public_key unless public_key.nil?
+
+        new_client = chef_rest_v0.post("clients", payload)
+      end
+      Chef::ApiClientV1.from_hash(to_hash.merge(new_client))
+    end
+
+    # As a string
+    def to_s
+      "client[#{@name}]"
+    end
+
+  end
+end