ruby-jss 1.6.4 → 2.0.0b1

data/lib/{jss/api_object → jamf/api/classic/base_classes}/patch_source.rb

@@ -1,4 +1,4 @@
-### Copyright 2020 Pixar
+### Copyright 2022 Pixar
 
 ###
 ###    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -24,16 +24,16 @@
 ###
 ###
 
-module JSS
+module Jamf
 
-  # A patch source. The abstract parent class of {JSS::PatchInternalSource} and
-  # {JSS::PatchExternalSource}
+  # A patch source. The abstract parent class of {Jamf::PatchInternalSource} and
+  # {Jamf::PatchExternalSource}
   #
-  # @see JSS::APIObject
+  # @see Jamf::APIObject
   #
-  class PatchSource < JSS::APIObject
+  class PatchSource < Jamf::APIObject
 
-    include JSS::Updatable
+    include Jamf::Updatable
 
     HTTP = 'http'.freeze
     HTTPS = 'https'.freeze
@@ -47,16 +47,16 @@ module JSS
 
     # TODO: remove this and adjust parsing when jamf fixes the JSON
     # Data map for PatchReport XML data parsing cuz Borked JSON
-    # @see {JSS::XMLWorkaround} for details
+    # @see {Jamf::XMLWorkaround} for details
     AVAILABLE_TITLES_DATA_MAP = {
       patch_available_titles: {
         available_titles: [
           {
-            name_id: JSS::BLANK,
-            current_version: JSS::BLANK,
-            publisher: JSS::BLANK,
-            last_modified: JSS::BLANK,
-            app_name: JSS::BLANK
+            name_id: Jamf::BLANK,
+            current_version: Jamf::BLANK,
+            publisher: Jamf::BLANK,
+            last_modified: Jamf::BLANK,
+            app_name: Jamf::BLANK
           }
         ]
       }
@@ -73,15 +73,17 @@ module JSS
     #
     # @param refresh[Boolean] should the data be re-queried from the API?
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Array<Hash{:name=>String, :id=> Integer, :type => Symbol}>]
     #
-    def self.all(refresh = false, api: JSS.api)
-      if self == JSS::PatchSource
-        int = JSS::PatchInternalSource.all(refresh, api: api).each { |s| s[:type] = :internal }
-        ext = JSS::PatchExternalSource.all(refresh, api: api).each { |s| s[:type] = :external }
+    def self.all(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      if self == Jamf::PatchSource
+        int = Jamf::PatchInternalSource.all(refresh, cnx: cnx).each { |s| s[:type] = :internal }
+        ext = Jamf::PatchExternalSource.all(refresh, cnx: cnx).each { |s| s[:type] = :external }
         return (int + ext).sort! { |s1, s2| s1[:id] <=> s2[:id] }
       end
       super
@@ -89,30 +91,36 @@ module JSS
 
     # Get names, ids  for all patch internal sources
     #
-    # the same as JSS::PatchInternalSource.all refresh, api: api
+    # the same as Jamf::PatchInternalSource.all refresh, cnx: cnx
     #
-    # @see  JSS::PatchInternalSource.all
+    # @see  Jamf::PatchInternalSource.all
     #
-    def self.all_internal(refresh = false, api: JSS.api)
-      JSS::PatchInternalSource.all refresh, api: api
+    def self.all_internal(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      Jamf::PatchInternalSource.all refresh, cnx: cnx
     end
 
     # Get names, ids  for all patch internal sources
     #
-    # the same as JSS::PatchExternalSource.all refresh, api: api
+    # the same as Jamf::PatchExternalSource.all refresh, cnx: cnx
     #
-    #  @see  JSS::PatchExternalSource.all
+    #  @see  Jamf::PatchExternalSource.all
     #
-    def self.all_external(refresh = false, api: JSS.api)
-      JSS::PatchExternalSource.all refresh, api: api
+    def self.all_external(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      Jamf::PatchExternalSource.all refresh, cnx: cnx
     end
 
-    # @see JSS::APIObject.all_objects
+    # @see Jamf::APIObject.all_objects
     #
-    def self.all_objects(refresh = false, api: JSS.api)
-      if self == JSS::PatchSource
-        int = JSS::PatchInternalSource.all_objects refresh, api: api
-        ext = JSS::PatchExternalSource.all_objects refresh, api: api
+    def self.all_objects(refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      if self == Jamf::PatchSource
+        int = Jamf::PatchInternalSource.all_objects refresh, cnx: cnx
+        ext = Jamf::PatchExternalSource.all_objects refresh, cnx: cnx
         return (int + ext).sort! { |s1, s2| s1.id <=> s2.id }
       end
       super
@@ -126,56 +134,63 @@ module JSS
     # @see APIObject.fetch
     #
     def self.fetch(searchterm = nil, **args)
-      if self == JSS::PatchSource
+      if self == Jamf::PatchSource
         begin
-          fetched = JSS::PatchInternalSource.fetch searchterm, **args
+          fetched = Jamf::PatchInternalSource.fetch searchterm, **args
         rescue
           fetched = nil
         end
         unless fetched
           begin
-            fetched = JSS::PatchExternalSource.fetch searchterm, **args
+            fetched = Jamf::PatchExternalSource.fetch searchterm, **args
           rescue
-            raise JSS::NoSuchItemError, 'No matching PatchSource found'
+            raise Jamf::NoSuchItemError, 'No matching PatchSource found'
           end
         end
         return fetched
-      end # if self == JSS::PatchSource
+      end # if self == Jamf::PatchSource
 
       begin
         super searchterm, **args
-      rescue JSS::NoSuchItemError
-        raise JSS::NoSuchItemError, "No matching #{self::RSRC_OBJECT_KEY} found"
+      rescue Jamf::NoSuchItemError
+        raise Jamf::NoSuchItemError, "No matching #{self::RSRC_OBJECT_KEY} found"
       end
     end
 
-    # Only JSS::PatchExternalSources can be created
+    # Only Jamf::PatchExternalSources can be created
     #
     # @see APIObject.make
     #
-    def self.make(**args)
+    def self.create(**args)
       case self.name
-      when 'JSS::PatchSource'
-        JSS::PatchExternalSource.make args
-      when 'JSS::PatchExternalSource'
+      when 'Jamf::PatchSource'
+        Jamf::PatchExternalSource.make args
+      when 'Jamf::PatchExternalSource'
         super
-      when 'JSS::PatchInternalSource'
-        raise JSS::UnsupportedError, 'PatchInteralSources cannot be created.'
+      when 'Jamf::PatchInternalSource'
+        raise Jamf::UnsupportedError, 'PatchInteralSources cannot be created.'
       end
     end
 
-    # Only JSS::PatchExternalSources can be deleted
+    # bacward compatibility
+    def self.make(**args)
+      create(**args)
+    end
+
+    # Only Jamf::PatchExternalSources can be deleted
     #
     # @see APIObject.delete
     #
-    def self.delete(victims, api: JSS.api)
+    def self.delete(victims, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
       case self.name
-      when 'JSS::PatchSource'
-        JSS::PatchExternalSource victims, api: api
-      when 'JSS::PatchExternalSource'
+      when 'Jamf::PatchSource'
+        Jamf::PatchExternalSource victims, cnx: cnx
+      when 'Jamf::PatchExternalSource'
         super
-      when 'JSS::PatchInternalSource'
-        raise JSS::UnsupportedError, 'PatchInteralSources cannot be deleted.'
+      when 'Jamf::PatchInternalSource'
+        raise Jamf::UnsupportedError, 'PatchInteralSources cannot be deleted.'
       end
     end
 
@@ -185,7 +200,7 @@ module JSS
     # @param source[String,Integer] name or id of the Patch Source for which to
     # get the available titles
     #
-    # @param api[JSS::APIConnection] The api connection to use for the query
+    # @param cnx [Jamf::Connection] The api connection to use for the query
     #   Defaults to the currently active connection
     #
     # @return [Array<Hash{Symbol:String}>] One hash for each available title, with
@@ -196,28 +211,30 @@ module JSS
     #     :last_modified Time
     #     :app_name  String
     #
-    def self.available_titles(source, api: JSS.api)
-      src_id = valid_patch_source_id source, api: api
-      raise JSS::NoSuchItemError, "No Patch Source found matching: #{source}" unless src_id
+    def self.available_titles(source, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      src_id = valid_patch_source_id source, cnx: cnx
+      raise Jamf::NoSuchItemError, "No Patch Source found matching: #{source}" unless src_id
 
       rsrc_base =
-        if valid_patch_source_type(src_id, api: api) == :internal
-          JSS::PatchInternalSource::AVAILABLE_TITLES_RSRC
+        if valid_patch_source_type(src_id, cnx: cnx) == :internal
+          Jamf::PatchInternalSource::AVAILABLE_TITLES_RSRC
         else
-          JSS::PatchExternalSource::AVAILABLE_TITLES_RSRC
+          Jamf::PatchExternalSource::AVAILABLE_TITLES_RSRC
         end
 
       rsrc = "#{rsrc_base}#{src_id}"
 
       begin
         # TODO: remove this and adjust parsing when jamf fixes the JSON
-        raw = JSS::XMLWorkaround.data_via_xml(rsrc, AVAILABLE_TITLES_DATA_MAP, api)
-      rescue JSS::NoSuchItemError
+        raw = Jamf::XMLWorkaround.data_via_xml(rsrc, AVAILABLE_TITLES_DATA_MAP, cnx)
+      rescue Jamf::NoSuchItemError
         return []
       end
 
       titles = raw[:patch_available_titles][:available_titles]
-      titles.each { |t| t[:last_modified] = Time.parse t[:last_modified] }
+      titles.each { |t| t[:last_modified] = Jamf.parse_time t[:last_modified] }
       titles
     end
 
@@ -228,8 +245,10 @@ module JSS
     #
     # @return [Array<String>] the name_ids available on the source
     #
-    def self.available_name_ids(source, api: JSS.api)
-      available_titles(source, api: api).map { |t| t[:name_id] }
+    def self.available_name_ids(source, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      available_titles(source, cnx: cnx).map { |t| t[:name_id] }
     end
 
     # Given a name or id for a Patch Source (internal or external)
@@ -243,14 +262,16 @@ module JSS
     #
     # @param refresh [Boolean] Should the data be re-read from the server
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Integer, nil] the valid id or nil if it doesn't exist.
     #
-    def self.valid_patch_source_id(ident, refresh = false, api: JSS.api)
-      id = JSS::PatchInternalSource.valid_id ident, refresh, api: api
-      id ||= JSS::PatchExternalSource.valid_id ident, refresh, api: api
+    def self.valid_patch_source_id(ident, refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      id = Jamf::PatchInternalSource.valid_id ident, refresh, cnx: cnx
+      id ||= Jamf::PatchExternalSource.valid_id ident, refresh, cnx: cnx
       id
     end
 
@@ -261,14 +282,16 @@ module JSS
     #
     # @param refresh [Boolean] Should the data be re-read from the server
     #
-    # @param api[JSS::APIConnection] an API connection to use for the query.
-    #   Defaults to the corrently active API. See {JSS::APIConnection}
+    # @param cnx [Jamf::Connection] an API connection to use for the query.
+    #   Defaults to the corrently active API. See {Jamf::Connection}
     #
     # @return [Symbol, nil] :internal, :external, or nil if it doesn't exist.
     #
-    def self.valid_patch_source_type(ident, refresh = false, api: JSS.api)
-      return :internel if JSS::PatchInternalSource.valid_id ident, refresh, api: api
-      return :external if JSS::PatchExternalSource.valid_id ident, refresh, api: api
+    def self.valid_patch_source_type(ident, refresh = false, api: nil, cnx: Jamf.cnx)
+      cnx = api if api
+
+      return :internel if Jamf::PatchInternalSource.valid_id ident, refresh, cnx: cnx
+      return :external if Jamf::PatchExternalSource.valid_id ident, refresh, cnx: cnx
       nil
     end
 
@@ -301,7 +324,7 @@ module JSS
 
     # Init
     def initialize(**args)
-      raise JSS::UnsupportedError, 'PatchSource is an abstract metaclass. Please use PatchInternalSource or PatchExternalSource' if self.class == JSS::PatchSource
+      raise Jamf::UnsupportedError, 'PatchSource is an abstract metaclass. Please use PatchInternalSource or PatchExternalSource' if self.class == Jamf::PatchSource
 
       super
 
@@ -326,33 +349,30 @@ module JSS
     end # init
 
     # Get a list of patch titles available from this Patch Source
-    # @see JSS::PatchSource.available_titles
+    # @see Jamf::PatchSource.available_titles
     #
     def available_titles
-      self.class.available_titles id, api: api
+      self.class.available_titles id, cnx: cnx
     end
 
     # Get a list of available name_id's for this patch source
-    # @see JSS::PatchSource.available_name_ids
+    # @see Jamf::PatchSource.available_name_ids
     #
     def available_name_ids
-      self.class.available_name_ids id, api: api
+      self.class.available_name_ids id, cnx: cnx
     end
 
     # Delete this instance
     # This method is needed to override APIObject#delete
     def delete
       case self.class.name
-      when 'JSS::PatchExternalSource'
+      when 'Jamf::PatchExternalSource'
         super
-      when 'JSS::PatchInternalSource'
-        raise JSS::UnsupportedError, 'PatchInteralSources cannot be deleted.'
+      when 'Jamf::PatchInternalSource'
+        raise Jamf::UnsupportedError, 'PatchInteralSources cannot be deleted.'
       end
     end
 
   end # class PatchSource
 
-end # module JSS
-
-require 'jss/api_object/patch_source/patch_internal_source'
-require 'jss/api_object/patch_source/patch_external_source'
+end # module Jamf

data/lib/{jss → jamf/api/classic}/xml_workaround.rb

@@ -1,4 +1,4 @@
-### Copyright 2020 Pixar
+### Copyright 2022 Pixar
 
 ###
 ###    Licensed under the Apache License, Version 2.0 (the "Apache License")
@@ -24,7 +24,7 @@
 ###
 
 ###
-module JSS
+module Jamf
 
   # Since a non-trivial amounts of the JSON data from the API are borked, the
   # methods here can be used to parse the XML data into usable JSON, which we
@@ -33,13 +33,13 @@ module JSS
   # For classes with borked JSON, set the constant USE_XML_WORKAROUND to a Hash
   # with a single key that maps the structure of the XML and resultant Ruby data.
   #
-  # As an example, here's the data map from JSS::PatchTitle
+  # As an example, here's the data map from Jamf::PatchTitle
   #
   # USE_XML_WORKAROUND = {
   #   patch_software_title: {
   #     id: -1,
-  #     name: JSS::BLANK,
-  #     name_id: JSS::BLANK,
+  #     name: Jamf::BLANK,
+  #     name_id: Jamf::BLANK,
   #     source_id: -1,
   #     notifications: {
   #       email_notification: nil,
@@ -47,13 +47,13 @@ module JSS
   #     },
   #     category: {
   #       id: -1,
-  #       name: JSS::BLANK
+  #       name: Jamf::BLANK
   #     },
   #     versions: [
   #       {
-  #         software_version: JSS::BLANK,
+  #         software_version: Jamf::BLANK,
   #         package: -1,
-  #           name: JSS::BLANK
+  #           name: Jamf::BLANK
   #         }
   #       }
   #     ]
@@ -68,7 +68,7 @@ module JSS
   # The class of the map example is the class of the desired data, and the value
   # of the map example is the value to use when the XML data is nil or empty.
   #
-  # So a map example of '' (an empty string, a.k.a. JSS::BLANK) indicates
+  # So a map example of '' (an empty string, a.k.a. Jamf::BLANK) indicates
   # that the value should be a String and if the XML element is nil or empty,
   # use '' in the Ruby data. If its -1, that means the value should be an
   # Integer, and if its empty or nil, use -1 in Ruby.
@@ -78,7 +78,7 @@ module JSS
   # neither true nor false.
   #
   # Allowed single value classes and common default examples are:
-  #   String, common default: '' or JSS::BLANK
+  #   String, common default: '' or Jamf::BLANK
   #   Integer, common default: -1
   #   Float, common default: -1.0
   #   Boolean, required default: nil
@@ -122,8 +122,8 @@ module JSS
     # to the APIObject#lookup_object_data method, which then
     # treats it normally.
     #
-    def self.data_via_xml(rsrc, map, api)
-      raw_xml = api.get_rsrc(rsrc, :xml)
+    def self.data_via_xml(rsrc, map, cnx)
+      raw_xml = cnx.c_get(rsrc, :xml)
       xmlroot = REXML::Document.new(raw_xml).root
       hash_from_xml = {}
       map.each do |key, model|

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

@@ -0,0 +1,224 @@
+### Copyright 2022 Pixar
+###
+###    Licensed under the Apache License, Version 2.0 (the "Apache License")
+###    with the following modification; you may not use this file except in
+###    compliance with the Apache License and the following modification to it:
+###    Section 6. Trademarks. is deleted and replaced with:
+###
+###    6. Trademarks. This License does not grant permission to use the trade
+###       names, trademarks, service marks, or product names of the Licensor
+###       and its affiliates, except as required to comply with Section 4(c) of
+###       the License and to reproduce the content of the NOTICE file.
+###
+###    You may obtain a copy of the Apache License at
+###
+###        http://www.apache.org/licenses/LICENSE-2.0
+###
+###    Unless required by applicable law or agreed to in writing, software
+###    distributed under the Apache License with the above modification is
+###    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+###    KIND, either express or implied. See the Apache License for the specific
+###    language governing permissions and limitations under the Apache License.
+###
+###
+
+module Jamf
+
+  class Connection
+
+    # This module defines general attributes of a connection object
+    #
+    # These attributes actually come from the token:
+    #   base_url, host, port, user, keep_alive?, ssl_version, verify_cert?,
+    #   ssl_options, pw_fallback?, jamf_version, jamf_build
+    # There are convience getters defined for them below
+    #############################################################
+
+    module Attributes
+
+      # @return [String,Symbol] an arbitrary name that can be given to this
+      #   connection during initialization, using the name: parameter.
+      #   defaults to user@hostname:port
+      attr_reader :name
+
+      # @return [Boolean] are we connected right now?
+      attr_reader :connected
+      alias connected? connected
+
+      # @return [Integer] Seconds before an http request times out
+      attr_reader :timeout
+
+      # @return [Integer] Seconds before an http connection open times out
+      attr_reader :open_timeout
+
+      # @return [Faraday::Connection] the underlying C-API connection object
+      attr_reader :c_cnx
+
+      # @return [Faraday::Connection] the underlying JPAPI connection object
+      attr_reader :jp_cnx
+
+      # @return [Jamf::Connection::Token] the token used for connecting
+      attr_reader :token
+
+      # @return [String] any path in the URL below the hostname. See {#connect}
+      attr_reader :server_path
+
+      # @return [Faraday::Response] The response from the most recent API call
+      attr_reader :last_http_response
+
+      # @return [Time] when this connection was connected
+      attr_reader :connect_time
+      alias login_time connect_time
+
+      # @return [Boolean] are we using a sticky session?
+      attr_reader :sticky_session
+      alias sticky_session? sticky_session
+      alias sticky? sticky_session
+      
+      # @return [String, nil] The current sticky_session cookie. nil unless
+      #   sticky_session is set to true, either as a param to 'connect' or via
+      #   #sticky_session=
+      #
+      #   When set via .connect, the cookie is gleaned from the token creation 
+      #   reponse. When set via #sticky_session=, a HEAD request is made, and the
+      #   cookie will be in the response.
+      #   
+      #    Only valid when the connection is to a Jamf Cloud server.
+      attr_reader :sticky_session_cookie
+
+      ##########################################
+
+      # Turn sticky-sessions on or off. If turning on, host must be a Jamf Cloud
+      # server, with a hostname ending with Jamf::Connection::JAMFCLOUD_DOMAIN
+      #
+      # @param value [Boolean] should we use a sticky session?
+      #
+      # @return [void]
+      #
+      def sticky_session=(value)
+        @sticky_session ||= false
+
+        # convert boolean-y to boolean
+        value = value ? true : false
+        
+        return if @sticky_session == value
+
+        if value
+          raise Jamf::UnsupportedError, 'Sticky Sessions may only be used with Jamf Cloud servers.' unless host.end_with? Jamf::Connection::JAMFCLOUD_DOMAIN
+
+          @sticky_session = true
+          enable_sticky_session Jamf.cnx.jp_cnx.head.headers
+
+        else
+          @sticky_session = false
+          @sticky_session_cookie = nil
+          @c_cnx&.headers&.delete Jamf::Connection::COOKIE_HEADER
+          @jp_cnx&.headers&.delete Jamf::Connection::COOKIE_HEADER
+        end
+      end
+
+      # Reset the response timeout for the rest connection
+      #
+      # @param timeout[Integer] the new timeout in seconds
+      #
+      # @return [void]
+      #
+      def timeout=(new_timeout)
+        @timeout = new_timeout.to_i
+        @c_cnx&.options[:timeout] = @timeout 
+        @jp_cnx&.options[:timeout] = @timeout 
+      end
+
+      # Reset the open-connection timeout for the rest connection
+      #
+      # @param timeout[Integer] the new timeout in seconds
+      #
+      # @return [void]
+      #
+      def open_timeout=(new_timeout)
+        @open_timeout = new_timeout.to_i
+        @c_cnx&.options[:open_timeout] = @open_timeout
+        @jp_cnx&.options[:open_timeout] = @open_timeout 
+      end
+
+      # @return [URI::HTTPS] the base URL to the server
+      def base_url
+        validate_token
+        @token.base_url
+      end
+
+      # @return [String] the hostname of the Jamf Pro server API connection
+      def host
+        validate_token
+        @token.host
+      end
+      alias server host
+      alias hostname host
+
+      # @return [Integer] The port of the Jamf Pro server API connection
+      def port
+        validate_token
+        @token.port
+      end
+
+      # @return [String] the username who's connected to the JSS API
+      def user
+        validate_token
+        @token.user
+      end
+
+      # @return [Boolean] Is the connection token being automatically refreshed?
+      def keep_alive?
+        validate_token
+        @token.keep_alive?
+      end
+
+      # @return [Boolean] If keep_alive is true, is the password Cached in memory
+      #   to use if the refresh fails?
+      def pw_fallback?
+        validate_token
+        @token.pw_fallback?
+      end
+
+      # @return [String] SSL version used for the connection
+      def ssl_version
+        validate_token
+        @token.ssl_version
+      end
+
+      # @return [Boolean] Should the SSL certifcate from the server be verified?
+      def verify_cert?
+        validate_token
+        @token.verify_cert?
+      end
+      alias verify_cert verify_cert?
+
+      # @return [Hash] the ssl version and verify cert, to pass into faraday connections
+      def ssl_options
+        validate_token
+        @token.ssl_options
+      end
+
+      # @return [Gem::Version] the version of the Jamf Pro server
+      def jamf_version
+        validate_token
+        @token.jamf_version
+      end
+
+      # @return [String] the build of the Jamf Pro server
+      def jamf_build
+        validate_token
+        @token.jamf_build
+      end
+
+      # raise an error if no token yet
+      # @return [void]
+      def validate_token
+        raise Jamf::InvalidConnectionError, 'No token available, use #connect first' unless @token
+      end
+
+    end # module
+
+  end # class Connection
+
+end # module