ruby-jss 1.2.4a1 → 1.2.4a2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25d16b4c34d2790bdf6175543f81a2125e80ddf0c2c49cbb76d340b76dd562df
-  data.tar.gz: a09cfceaaecd6c3109cafbd0d7912a1c66326c6c5ddaae479a4260816c50ede9
+  metadata.gz: f394d84e5b001b374b534b114addc50cf5ea911804926912c84b0a57bb1cf658
+  data.tar.gz: 5bdaecdfc2e51632b0defe59d7c91f69b9da3b72605461793251a97a0364167f
 SHA512:
-  metadata.gz: fb2e1e6fb575db16ade4b819bbea3cfb73ce6956c1012569f2be10d757ed05f31c4671605065a6c619667afa3a2540119af0afee5cf506d1ae8455d4aa42d4c0
-  data.tar.gz: 4af7406b1457c0c70d4873578920938b942ed7b6ea15702898f74450453720f30b24803addf8762426f617b7e223ef34ae2d51453df5cf283da35c32d27a8854
+  metadata.gz: c72272007ed1015d0647cb49ffba9701be8b19293cdad46eb04eff7a3c47d505441faf4ed95fb25de0774b4899a92c6659e4079b7c74d9893d83154f65aa619b
+  data.tar.gz: 84d17e840a8e7872222dd1ed4b0ea026a04d6a44dfeeed1f07181f8569919049120838d6aa4c2d6736a9cfbee8ccc42bc42fb8437223cbb655e1670801ac734f

data/lib/jamf/api/abstract_classes/collection_resource.rb

@@ -239,10 +239,10 @@ module Jamf
       raise Jamf::UnsupportedError, "#{self}'s are not currently creatable via the API" unless self.creatable?
 
       validate_not_abstract
+      params.delete :id # no such animal when .creating
 
-      validate_required_attributes params
+      validate_create_params(params, cnx)
 
-      params.delete :id # no such animal when .creating
       params[:creating_from_create] = true
       new params, cnx: cnx
     end
@@ -356,15 +356,16 @@ module Jamf
     end # create_list_methods
     private_class_method :create_list_methods
 
-    # validate that our .create data has the required attribute values.
-    # They can't be nil or empty.
+    # validate that our .create data is OK
     #
-    def self.validate_required_attributes(data)
-      required_attributes.each do |atr|
-        raise Jamf::MissingDataError, "Required attribute '#{atr}:' may not be nil or empty" if data[atr].to_s.empty?
+    def self.validate_create_params(params, cnx)
+      params.keys.each do |param|
+        raise ArgumentError, "Unknown parameter: #{param}" unless self::OBJECT_MODEL.key? param
+
+        params[param] = validate_attr param, params[param], cnx: cnx
       end
     end
-    private_class_method :validate_required_attributes
+    private_class_method :validate_create_params
 
     # Given an indentier attr. key, and a value,
     # return the id where that ident has that value, or nil
@@ -385,7 +386,6 @@ module Jamf
     end
     private_class_method :id_from_other_ident
 
-
     # Instance Methods
     #####################################
 

data/lib/jamf/api/abstract_classes/json_object.rb

@@ -749,6 +749,11 @@ module Jamf
     # If the attribute is defined as a :string, :integer, :float or :bool
     # without an enum or validator, it is confirmed to be the correct type
     #
+    # If the attribute is required, it can't be nil or empty
+    #
+    # If the attribute is an identifier, and the class is a subclass of
+    # CollectionResource, it must be unique among the collection
+    #
     # Otherwise, the value is returned unchanged.
     #
     # If the attribute is defined as an identifier, it must be unique among
@@ -767,9 +772,11 @@ module Jamf
     def self.validate_attr(attr_name, value, cnx: Jamf.cnx)
       attr_def = self::OBJECT_MODEL[attr_name]
 
+      raise ArgumentError, "Unknown attribute: #{attr_name} for #{self} objects" unless attr_def
+
       # validate our value, which will raise an error or
       # convert the value to the required type.
-      good_value =
+      value =
 
         # by enum, must be a value of the enum
         if attr_def[:enum]
@@ -778,16 +785,15 @@ module Jamf
 
         # by class, the class validates the value passed with .new
         elsif attr_def[:class].is_a? Class
-
           klass = attr_def[:class]
           # validation happens in klass.new
           value.is_a?(klass) ? value : klass.new(value, cnx: cnx)
 
-        # by Validate method - pass to the method
+        # by specified Validate method - pass to the method
         elsif attr_def[:validator]
           Jamf::Validate.send(attr_def[:validator], value)
 
-        # By json type - pass to the matching validate method
+        # By json primative type - pass to the matching validate method
         elsif JSON_TYPE_CLASSES.include? attr_def[:class]
           Jamf::Validate.send(attr_def[:class], value)
 
@@ -796,10 +802,15 @@ module Jamf
           value
         end # if
 
+      # if this is required, it can't be nil or empty
+      if attr_def[:required]
+        raise Jamf::MissingDataError, "Required attribute '#{attr_name}:' may not be nil or empty" if value.to_s.empty?
+      end
+
       # if this is an identifier, it must be unique
-      Jamf::Validate.send(:unique_identifier, good_value, self.class, attr_name, cnx: @cnx) if attr_def[:identfier]
+      Jamf::Validate.doesnt_exist(value, self, attr_name, cnx: cnx) if attr_def[:identifier] && superclass == Jamf::CollectionResource
 
-      good_value
+      value
     end # validate_attr(attr_name, value)
     private_class_method :validate_attr
 

data/lib/jamf/api/connection.rb

@@ -263,30 +263,50 @@ module Jamf
       # This sets all the instance vars to nil, and flushes/creates the caches
       disconnect
 
-      # parse the url if one was given
-      params[:url] = url
-      parse_url params if params[:url]
+      # This sets @token, and adds host, port, user to params from a Token object
+      parse_token params
+
+      # Get host, port, user and pw from a URL, add to params if needed
+      parse_url url, params
 
       # apply defaults from config, client, and then this class.
       apply_connection_defaults params
 
-      # confirm we know a host, port, user and pw
+      # make sure we have the minimum needed params for a connection
       verify_basic_params params
+
+      # turn the params into instance vars
       parse_connect_params params
 
-      @token = acquire_token params
+      # if no @token already, get one from from
+      # either a token string or a pw
+      @token ||=
+        if params[:token].is_a? String
+          tk = token_from :token_string, params[:token]
+          # get the user from the token
+          @user = tk.user
+          tk
+        else
+          token_from :pw, acquire_password(params[:pw])
+        end
+
+      # Now get some values from our token
+      @base_url = @token.base_url
       @login_time = @token.login_time
-      @user ||= @token.user
 
-      # if we're here we have a valid token
+      # and make our actual connection
       @rest_cnx = create_connection
 
+      # make sure versions are good
       validate_api_version
 
       @connected = true
 
+      # start keepalive if needed
       @keep_alive = params[:keep_alive].nil? ? false : params[:keep_alive]
-      @keep_alive && start_keep_alive
+      start_keep_alive if @keep_alive
+
+      # return our string output
       to_s
     end # connect
 
@@ -300,7 +320,8 @@ module Jamf
       @token = nil
       @base_url = nil
       @rest_cnx = nil
-      @ssl_version = nil
+      @ssl_options = {}
+      @keep_alive = nil
       flushcache
     end
 
@@ -432,25 +453,6 @@ module Jamf
     ####################################
     private
 
-    # given a token string or a password, get a valid token
-    # Token.new will raise an exception if the token string or
-    # credentials are invalid
-    def token_from(type, data)
-      token_params = {
-        user: @user,
-        base_url: @base_url,
-        timeout: @timeout,
-        ssl_options: @ssl_options
-      }
-
-      case type
-      when :token_string
-        token_params[:token_string] = data
-      when :pw
-        token_params[:pw] = data
-      end
-      self.class::Token.new token_params
-    end
 
     # raise exception if not connected
     def validate_connected
@@ -465,14 +467,47 @@ module Jamf
       raise Jamf::InvalidConnectionError, "API version '#{vers}' too low, must be >= '#{MIN_API_VERSION}'"
     end
 
-    def parse_url(params)
-      url = URI.parse params[:url].to_s
+    #####  Parse Params
+    ###################################
+
+    # Get host, port, & user from a Token object
+    # or just the user from a token string.
+    def parse_token(params)
+      return unless params[:token].is_a? self.class::Token
+
+      verify_token params[:token]
+      @token = params[:token]
+      params[:host] = @token.host
+      params[:port] = @token.port
+      params[:user] = @token.user
+    end
+
+    # Raise execeptions if we were given an unusable token object
+    #
+    # @param params[Hash] The params for #connect
+    #
+    # @return [void]
+    #
+    def verify_token(token)
+      raise 'Cannot use token: it has expired' if token.expired?
+      raise 'Cannot use token: it is invalid' unless token.valid?
+      raise "Cannot use token: it expires in less than #{TOKEN_REUSE_MIN_LIFE} seconds" if token.secs_remaining < TOKEN_REUSE_MIN_LIFE
+    end
+
+    # Get host, port, user and pw from a URL, unless they are already in the params
+    #
+    # @return [String, nil] the pw if present
+    #
+    def parse_url(url, params)
+      return unless url
+
+      url = URI.parse url.to_s
       raise ArgumentError, 'Invalid url, scheme must be https' unless url.scheme == HTTPS_SCHEME
 
-      params[:user] = url.user
-      params[:pw] = url.password
-      params[:host] = url.host
-      params[:port] = url.port
+      params[:host] ||= url.host
+      params[:port] ||= url.port
+      params[:user] ||= url.user if url.user
+      params[:pw] ||= url.password if url.password
     end
 
     # Apply defaults from the Jamf.config,
@@ -486,12 +521,11 @@ module Jamf
     #
     def apply_connection_defaults(params)
       apply_defaults_from_config(params)
+
       # TODO: when clients are moved over
       # apply_defaults_from_client(params)
-      apply_module_defaults(params)
 
-      # if we have a TTY, pw defaults to :prompt
-      params[:pw] ||= :prompt if STDIN.tty?
+      apply_module_defaults(params)
     end
 
     # Apply defaults from the Jamf.config
@@ -542,44 +576,27 @@ module Jamf
       params[:timeout] ||= DFT_TIMEOUT
       params[:open_timeout] ||= DFT_OPEN_TIMEOUT
       params[:ssl_version] ||= DFT_SSL_VERSION
-    end
-
-    # From whatever was given in params[:pw], figure out the real password
-    #
-    # @param params[Hash] The params for #connect
-    #
-    # @return [String] The password for the connection
-    #
-    def acquire_password(params)
-      if params[:pw] == :prompt
-        Jamf.prompt_for_password "Enter the password for Jamf user #{params[:user]}@#{params[:host]}:"
-      elsif params[:pw].is_a?(Symbol) && params[:pw].to_s.start_with?('stdin')
-        params[:pw].to_s =~ /^stdin(\d+)$/
-        line = Regexp.last_match(1)
-        line ||= 1
-        Jamf.stdin line
-      else
-        params[:pw]
-      end
+      # if we have a TTY, pw defaults to :prompt
+      params[:pw] ||= :prompt if STDIN.tty?
     end
 
     # Raise execeptions if we don't have essential data for a new connection
-    #
+    # namely a host, user, and pw
     # @param params[Hash] The params for #connect
     #
     # @return [void]
     #
     def verify_basic_params(params)
       # if given a Token object, it has host, port, user, and base_url
-      # and will be verified and parsed
-      return if params[:token].is_a? self.class::Token
+      # and is already parsed
+      return if @token
 
-      # must have a host, accept :server as well as :host
+      # must have a host, but accept legacy :server as well as :host
       params[:host] ||= params[:server]
       raise Jamf::MissingDataError, 'No Jamf :host specified, or in configuration.' unless params[:host]
 
       # no need for user or pass if using a token string
-      return if params[:token]
+      return if params[:token].is_a? String
 
       raise Jamf::MissingDataError, 'No Jamf :user specified, or in configuration.' unless params[:user]
       raise Jamf::MissingDataError, "No :pw specified for user '#{params[:user]}'" unless params[:pw]
@@ -603,39 +620,44 @@ module Jamf
       @name = "#{@user}@#{@host}:#{@port}" if @name == NOT_CONNECTED
     end
 
-    # Get our token either from a passwd or another token or token string
-    def acquire_token(params)
-      if params[:token]
-        if params[:token].is_a? self.class::Token
-          verify_token params[:token]
-          parse_token params[:token]
-          params[:token]
-        else
-          token_from :token_string, params[:token].to_s
-        end
-      else
-        token_from :pw, acquire_password(params)
+    # given a token string or a password, get a valid token
+    # Token.new will raise an exception if the token string or
+    # credentials are invalid
+    def token_from(type, data)
+      token_params = {
+        user: @user,
+        base_url: @base_url,
+        timeout: @timeout,
+        ssl_options: @ssl_options
+      }
+
+      case type
+      when :token_string
+        token_params[:token_string] = data
+      when :pw
+        token_params[:pw] = data
       end
+      self.class::Token.new token_params
     end
 
-    # Raise execeptions if we were given an unusable token
+    # From whatever was given in params[:pw], figure out the password to use
     #
     # @param params[Hash] The params for #connect
     #
-    # @return [void]
+    # @return [String] The password for the connection
     #
-    def verify_token(token)
-      raise 'Cannot use token: it has expired' if token.expired?
-      raise 'Cannot use token: it is invalid' unless token.valid?
-      raise "Cannot use token: it expires in less than #{TOKEN_REUSE_MIN_LIFE} seconds" if token.secs_remaining < TOKEN_REUSE_MIN_LIFE
-    end
-
-    def parse_token(token)
-      @host = token.host
-      @port = token.port
-      @user = token.user
-      @base_url = token.base_url
-    end
+    def acquire_password(param_pw)
+      if param_pw == :prompt
+        Jamf.prompt_for_password "Enter the password for Jamf user #{@user}@#{@host}:"
+      elsif param_pw.is_a?(Symbol) && param_pw.to_s.start_with?('stdin')
+        param_pw.to_s =~ /^stdin(\d+)$/
+        line = Regexp.last_match(1)
+        line ||= 1
+        Jamf.stdin line
+      else
+        param_pw
+      end # if
+    end # acquire pw
 
     # create the faraday connection object
     def create_connection(parse_json = true)

data/lib/jamf/api/connection/token.rb

@@ -73,7 +73,6 @@ module Jamf
         else
           raise ArgumentError, 'Must provide either pw: or token_string:'
         end
-
       end # init
 
       # Initialize from password
@@ -103,8 +102,9 @@ module Jamf
 
         @auth_token = str
         @user = resp.body.dig :account, :username
+
         # use this token to get a fresh one with a known expiration
-        keep_alive
+        refresh
       end # init_from_token_string
 
       # @return [String]
@@ -162,7 +162,7 @@ module Jamf
       end
 
       # Use this token to get a fresh one
-      def keep_alive
+      def refresh
         raise 'Token has expired' if expired?
 
         keep_alive_token_resp = token_connection(KEEP_ALIVE_RSRC, token: @auth_token).post
@@ -173,7 +173,7 @@ module Jamf
         # parse_token_from_response keep_alive_rsrc.post('')
         expires
       end
-      alias refresh keep_alive
+      alias keep_alive refresh
 
       # Make this token invalid
       def invalidate

data/lib/jamf/validate.rb

@@ -106,12 +106,12 @@ module Jamf
     #
     # @return [Object] the validated unique value
     #
-    def self.unique_identifier(val, klass, identifier, msg = nil, cnx: Jamf.cnx)
+    def self.doesnt_exist(val, klass, identifier, msg = nil, cnx: Jamf.cnx)
       msg ||= "A #{klass} already exists with #{identifier} '#{val}'"
 
-      raise Jamf::InvalidDataError, "No identifier '#{identfier}' for #{klass}" unless klass.identifiers.include? identifier
+      raise Jamf::InvalidDataError, "No identifier '#{identifier}' for #{klass}" unless klass.identifiers.include? identifier
 
-      return val unless klass.send("all_#{identfier}s", refresh: true, cnx: cnx).include? val
+      return val unless klass.send("all_#{identifier}s", :refresh, cnx: cnx).include? val
 
       raise Jamf::AlreadyExistsError, msg
     end

data/lib/jamf/version.rb

@@ -27,6 +27,6 @@
 module Jamf
 
   ### The version of the Jamf module
-  VERSION = '0.0.0a1'.freeze
+  VERSION = '0.0.0a2'.freeze
 
 end # module

data/lib/jss/version.rb

@@ -27,6 +27,6 @@
 module JSS
 
   ### The version of ruby-jss
-  VERSION = '1.2.4a1'.freeze
+  VERSION = '1.2.4a2'.freeze
 
 end # module

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-jss
 version: !ruby/object:Gem::Version
-  version: 1.2.4a1
+  version: 1.2.4a2
 platform: ruby
 authors:
 - Chris Lasell
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-19 00:00:00.000000000 Z
+date: 2019-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: plist