xolo-server 1.0.0

data/lib/xolo/server/routes/versions.rb

@@ -0,0 +1,261 @@
+# Copyright 2025 Pixar
+#
+#    Licensed under the terms set forth in the LICENSE.txt file available at
+#    at the root of this project.
+#
+
+# frozen_string_literal: true
+
+# main module
+module Xolo
+
+  # Server Module
+  module Server
+
+    module Routes
+
+      module Versions
+
+        # This is how we 'mix in' modules to Sinatra servers
+        # for route definitions and similar things
+        #
+        # (things to be 'included' for use in route and view processing
+        # are mixed in by delcaring them to be helpers)
+        #
+        # We make them extentions here with
+        #    extend Sinatra::Extension (from sinatra-contrib)
+        # and then 'register' them in the server with
+        #    register Xolo::Server::<Module>
+        # Doing it this way allows us to split the code into a logical
+        # file structure, without re-opening the Sinatra::Base server app,
+        # and let xeitwork do the requiring of those files
+        extend Sinatra::Extension
+
+        # when this module is included
+        def self.included(includer)
+          Xolo.verbose_include includer, self
+        end
+
+        # @return [String] The default min_os for versions
+        #################################
+        get '/default_min_os' do
+          resp = { min_os: default_min_os.to_s }
+          body resp
+        end
+
+        # Create a new version from the body content of the request
+        #
+        # @return [Hash] A response hash
+        #################################
+        post '/titles/:title/versions' do
+          request.body.rewind
+          data = parse_json request.body.read
+
+          unless data[:title] == params[:title]
+            halt 400,
+                 "Path/Data Mismatch! params[:title] => '#{params[:title]}' / data[:title] => '#{data[:title]}'"
+          end
+          data[:min_os] = default_min_os if data[:min_os].pix_empty?
+
+          log_debug "Incoming new version data: #{data}"
+          log_debug "Incoming new version data: #{data.class}"
+
+          vers = instantiate_version(data)
+          halt_on_existing_version vers.title, vers.version
+
+          if vers.title_object.jamf_patch_ea_awaiting_acceptance? && !Xolo::Server.config.jamf_auto_accept_xolo_eas
+
+            log_info "Jamf: Patch Title '#{params[:title]}' version_script must be manually accepted as a Patch EA before version can be activated. Admin has been notified."
+
+            raise Xolo::ActionRequiredError,
+                  "This title has a version-script, which must be accepted manually in Jamf Pro at #{vers.title_object.jamf_patch_ea_url} under the 'Extension Attribute' tab (click 'Edit'). Please do that and try again"
+          end
+
+          log_info "Admin #{session[:admin]} is creating version #{data[:version]} of title '#{params[:title]}'"
+
+          Xolo::Server.rw_lock(data[:title], data[:version]).with_write_lock do
+            with_streaming do
+              vers.create
+              update_client_data
+            end
+          end
+        end
+
+        # get a list of versions for a title
+        # @return [Array<Hash>] the names of existing versions for the title
+        #################################
+        get '/titles/:title/versions' do
+          halt_on_missing_title params[:title]
+
+          log_debug "Admin #{session[:admin]} is listing all versions for title '#{params[:title]}'"
+          # body all_versions(params[:title])
+          vers_ins = all_version_instances(params[:title])
+          # log_debug "vers_ins: #{vers_ins}"
+          body vers_ins.map(&:to_h)
+        end
+
+        # get all the data for a single version
+        # @return [Hash] The data for this version
+        #################################
+        get '/titles/:title/versions/:version' do
+          Xolo::Server.rw_lock(params[:title], params[:version]).with_read_lock do
+            log_debug "Admin #{session[:admin]} is fetching version '#{params[:version]}' of title '#{params[:title]}'"
+            halt_on_missing_version params[:title], params[:version]
+
+            vers = instantiate_version title: params[:title], version: params[:version]
+            body vers.to_h
+          end
+        end
+
+        # Update a version,
+        # Replace the data for an existing version with the content of the request
+        # @return [Hash] A response hash
+        #################################
+        put '/titles/:title/versions/:version' do
+          request.body.rewind
+          new_data = parse_json(request.body.read)
+          new_data[:min_os] = default_min_os if new_data[:min_os].pix_empty?
+          log_debug "Incoming update version data: #{new_data}"
+
+          halt_on_missing_title params[:title]
+          halt_on_missing_version params[:title], params[:version]
+          halt_on_locked_version params[:title], params[:version]
+
+          vers = instantiate_version title: params[:title], version: params[:version]
+
+          with_streaming do
+            vers.update new_data
+            update_client_data
+          end
+        end
+
+        # Delete an existing version
+        #
+        # This route sends a streamed response indicating progress
+        # in realtime, not a JSON object.
+        #
+        # @return [Hash] A response hash
+        #################################
+        delete '/titles/:title/versions/:version' do
+          halt_on_missing_version params[:title], params[:version]
+          halt_on_locked_version params[:title], params[:version]
+
+          log_info "Admin #{session[:admin]} is deleting version '#{params[:version]}' of title '#{params[:title]}'"
+
+          # for some reason, instantiating in the with_streaming block
+          # causes a throw error
+          vers = instantiate_version title: params[:title], version: params[:version]
+
+          with_streaming do
+            vers.delete
+            update_client_data
+          end
+        end
+
+        # upload a pkg for a version
+        # param with the uploaded file must be :file
+        ######################
+        post '/titles/:title/versions/:version/pkg' do
+          process_incoming_pkg
+          body({ result: :uploaded })
+        end
+
+        # Install a version on computers and/or a group, via
+        # the Jamf API's deploy_package endpoint and the
+        # InstallEnterpriseApplication MDM command.
+        #
+        # Request body is a JSON object with the following keys
+        #  computers: [Array<String, Integer>] The computer identifiers to install on.
+        #     Identifiers are either serial numbers, names, or Jamf IDs.
+        #  groups: [Array<String, Integer>] Identifiers of the groups to install on.
+        #
+        # Response body is a JSON object with the following keys
+        #   removals: [Array<Hash>] { device: <Integer>, group: <Integer>, reason: <String> }
+        #   queuedCommands: [Array<Hash>] { device: <Integer>, commandUuid: <String> }
+        #   errors: [Array<Hash>] { device: <Integer>, group: <Integer>, reason: <String> }
+        ######################
+        post '/titles/:title/versions/:version/deploy' do
+          request.body.rewind
+          targets = parse_json(request.body.read)
+
+          log_info "Incoming MDM deployment from admin #{session[:admin]} for title '#{params[:title]}',  version '#{params[:version]}'."
+          log_info "MDM deployment targets: #{targets}"
+
+          halt_on_missing_version params[:title], params[:version]
+
+          vers = instantiate_version title: params[:title], version: params[:version]
+
+          result = vers.deploy_via_mdm targets
+
+          body result
+        rescue => e
+          msg = "#{e.class}: #{e}"
+          log_error msg
+          halt 400, { status: 400, error: msg }
+        end
+
+        # run 'repair' on a version
+        ######################
+        post '/titles/:title/versions/:version/repair' do
+          log_debug "Admin #{session[:admin]} is repairing version '#{params[:version]}' of title '#{params[:title]}'"
+          halt_on_missing_version params[:title], params[:version]
+          halt_on_locked_version params[:title], params[:version]
+
+          vers = instantiate_version title: params[:title], version: params[:version]
+
+          with_streaming do
+            vers.repair
+            update_client_data
+          end
+        end
+
+        # Return info about all the computers with a given version of a title installed
+        #
+        # @return [Array<Hash>] The data for all computers with the given version of the title
+        #################################
+        get '/titles/:title/versions/:version/patch_report' do
+          log_debug "Admin #{session[:admin]} is fetching patch report for version #{params[:version]} title '#{params[:title]}'"
+
+          if params[:version] == Xolo::UNKNOWN
+            halt_on_missing_title params[:title]
+            title = instantiate_title params[:title]
+            data = title.patch_report vers: Xolo::UNKNOWN
+
+          else
+            halt_on_missing_version params[:title], params[:version]
+            version = instantiate_version title: params[:title], version: params[:version]
+            data = version.patch_report
+          end
+
+          body data
+        end
+
+        # Return URLs for all the UI pages for a version
+        #
+        # @return [Hash] The URLs for all the UI pages for a version
+        #################################
+        get '/titles/:title/versions/:version/urls' do
+          log_debug "Admin #{session[:admin]} is fetching GUI URLS for version #{params[:version]} of title '#{params[:title]}'"
+
+          halt_on_missing_version params[:title], params[:version]
+          vers = instantiate_version title: params[:title], version: params[:version]
+          data = {
+            ted_patch_url: vers.ted_patch_url,
+            jamf_auto_install_policy_url: vers.jamf_auto_install_policy_url,
+            jamf_manual_install_policy_url: vers.jamf_manual_install_policy_url,
+            jamf_patch_policy_url: vers.jamf_patch_policy_url,
+            jamf_package_url: vers.jamf_package_url
+          }
+          data[:jamf_version_installed_group] = vers.jamf_installed_group_url if vers.jamf_installed_group_exist?
+          data[:jamf_auto_reinstall_policy_url] = vers.jamf_auto_reinstall_policy_url if vers.jamf_auto_reinstall_policy_exist?
+
+          body data
+        end
+
+      end # Versions
+
+    end #  Routes
+
+  end #  Server
+
+end # module Xolo

data/lib/xolo/server/routes.rb

@@ -0,0 +1,168 @@
+# Copyright 2025 Pixar
+#
+#    Licensed under the terms set forth in the LICENSE.txt file available at
+#    at the root of this project.
+#
+
+# frozen_string_literal: true
+
+# main module
+module Xolo
+
+  # Server Module
+  module Server
+
+    # Some "global" routes are defined here.
+    # most are defined in other modules.
+    ##################################
+    module Routes
+
+      # This is how we extend modules to Sinatra servers:
+      # We make them extentions here with
+      #    extend Sinatra::Extension (from sinatra-contrib)
+      # and then 'register' them in the server with
+      #    register Xolo::Server::<Module>
+      # Doing it this way allows us to split the code into a logical
+      # file structure, without re-opening the Sinatra::Base server app,
+      # and let xeitwork do the requiring of those files.
+      #
+      # To 'include' modules in Sinatra servers, you declare them as helpers.
+      #
+      extend Sinatra::Extension
+
+      # pre-process
+      ##############
+      before do
+        halt 503, { status: 503, error: 'Server is shutting down' } if Xolo::Server.shutting_down? && !request.path.start_with?('/streamed_progress/')
+
+        adm = session[:admin] ? ", admin '#{session[:admin]}'" : Xolo::BLANK
+        log_info "Processing #{request.request_method} #{request.path} from #{request.ip}#{adm}"
+
+        log_debug "Session in before-filter: #{session.inspect}"
+
+        # these routes don't need an auth'd session
+        log_debug "Checking if request path '#{request.path}' is in NO_AUTH_ROUTES or NO_AUTH_PREFIXES"
+        break if Xolo::Server::Helpers::Auth::NO_AUTH_ROUTES.include? request.path
+        break if Xolo::Server::Helpers::Auth::NO_AUTH_PREFIXES.any? { |pfx| request.path.start_with? pfx }
+
+        # these routes are expected to be called by the xolo server itself
+        log_debug "Checking if request path '#{request.path}' is in INTERNAL_ROUTES"
+        break if Xolo::Server::Helpers::Auth::INTERNAL_ROUTES.include?(request.path) && valid_internal_auth_token?
+
+        # these routes are for server admins only, and require an authenticated session
+        log_debug "Checking if request path '#{request.path}' is in SERVER_ADMIN_ROUTES"
+        break if Xolo::Server::Helpers::Auth::SERVER_ADMIN_ROUTES.include?(request.path) && valid_server_admin?
+
+        # If here, we must have a session cookie marked as 'authenticated'
+        halt 401, { status: 401, error: 'You must log in to the Xolo server' } unless session[:authenticated]
+      end
+
+      # error process
+      ##############
+      error do
+        log_debug 'Running error filter'
+
+        resp_body = { status: response.status, error: env['sinatra.error'].message }
+        body resp_body
+      end
+
+      # post-process
+      # Convert the body to JSON unless @no_json is set
+      ##############
+      after do
+        # log a stack trace if the response status is 4xx or 5xx, or if there's a sinatra.error
+        if response.status >= 400
+          log_error "Response status #{response.status} for #{request.request_method} #{request.path}"
+          if env['sinatra.error']
+            log_error "Sinatra Error message: #{env['sinatra.error'].message}"
+            env['sinatra.error'].backtrace.each { |line| log_error "..#{line}" }
+          else
+            log_error 'Xolo Stack trace:'
+            caller.each { |line| log_error "..#{line}" }
+          end
+        end
+
+        if @no_json
+          log_debug 'NOT converting body to JSON in after filter'
+        else
+          log_debug 'Converting body to JSON in after filter'
+          content_type :json
+          # IMPORTANT, this only works if you remember to explicitly use
+          # `body body_content` in every route.
+          # You can't just define the body
+          # by the last evaluated statement of the route.
+          #
+          response.body = JSON.dump(response.body)
+        end
+
+        # TODO: See if there's any appropate place to disconnect
+        # from ruby-jss and windoo api connections?
+        # perhaps a callback to when a Sinatra server instance
+        # 'finishes'?
+        # can't
+      end
+
+      # Ping
+      ##########
+      get '/ping' do
+        @no_json = true
+        body 'pong'
+      end
+
+      # The streamed progress updates
+      # The stream_file param should be in the URL query, i.e.
+      # "/streamed_progress/?stream_file=<url-escaped path to file>"
+      #
+      ################
+      get '/streamed_progress/' do
+        log_debug "Starting progress stream from file: #{params[:stream_file]}"
+        # make note that this Server instance is just streaming from a file
+        # not acuatlly processing anything.
+        @streaming_from_file = true
+
+        @no_json = true
+        stream_file = Pathname.new params[:stream_file]
+
+        stream do |stream_out|
+          stream_progress(stream_file: stream_file, stream: stream_out)
+        rescue => e
+          stream_out << "ERROR DURING PROGRESS STREAM: #{e.class}: #{e}"
+        ensure
+          stream_out.close
+        end
+      end
+
+      # test
+      ##########
+      get '/test' do
+        # Xolo::Server::Helpers::Maintenance.post_to_start_cleanup force: true
+        # result = { result: 'posted to start cleanup' }
+
+        # send_email(
+        #   to: 'xolo@pixar.com',
+        #   subject: 'Test Email from Xolo Server',
+        #   msg: 'This is a test email from the Xolo Server'
+        # )
+        # result = { result: 'message sent' }
+
+        # client_data_testing
+        # update_client_data
+
+        result = { result: 'test' }
+
+        body result
+      end
+
+    end #  Routes
+
+  end #  Server
+
+end # module Xolo
+
+require 'xolo/server/routes/auth'
+require 'xolo/server/routes/jamf_pro'
+require 'xolo/server/routes/maint'
+require 'xolo/server/routes/title_editor'
+require 'xolo/server/routes/titles'
+require 'xolo/server/routes/uploads'
+require 'xolo/server/routes/versions'