globus_client 0.3.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5209cc407cc6ecd58dde455757a44ec9ceefb0a1301688c4af7d9b5b21f6952f
-  data.tar.gz: 76439856106a60b60f0ed6aa4e9072c5b85084581d589ceb407267b5b1e97d21
+  metadata.gz: 23d56c1a01cd643aafec353ff36adf2ad15b4792ebbd3091745415d5fcce68eb
+  data.tar.gz: 0d6acdff1f5a627b6a9030bf1e5154c4efef845bab052c27d4d84206ee04c822
 SHA512:
-  metadata.gz: 57bbeaf0041224ff2c451dd85cf663ef59ef281bdf707976c4c1ddad0bff1b8b55630cb5890ee82fb275de5a7896f3e44606046e8122136783faa1b839116e3e
-  data.tar.gz: 302a49a520934b6d68eee8e3a909834b8ec43468d263d241ccb5aaf8137ca994f5ceb86d036f747ccd699f8d250231c951ee1b2457f7652cd755cb498cc5dfa9
+  metadata.gz: 6c6ea6b0df9c20fddb7157cd5c7a0dc3270308ce11805f1fbaebb35f704647e7bc4d097ab5a89edc68c1c87274d3adaa52abd6928d9c5d89a214eb99cf7193ac
+  data.tar.gz: e25b26ab750b5b176279e26de6887bafc9fc25cce8b406d2aabec931978858580d26f816e9c2c6e92e3b7cca81afaf1cee6aa84490f88c152a65c2d35ee8c3ec

data/.autoupdate/postupdate

@@ -2,7 +2,7 @@
 
 # This script is called by our weekly dependency update job in Jenkins after updating Ruby and other deps
 
-# Switch to Ruby 3.1 for Globus::Client (3.0 is default in Jenkinsfile)
+# Switch to Ruby 3.1 for GlobusClient (3.0 is default in Jenkinsfile)
 rvm use 3.1.2@globus_client --create &&
     gem install bundler &&
     bundle install --gemfile Gemfile

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    globus_client (0.3.2)
+    globus_client (0.5.0)
       activesupport (>= 4.2, < 8)
       faraday
       zeitwerk

data/README.md

@@ -3,9 +3,9 @@
 [![Code Climate](https://codeclimate.com/github/sul-dlss/globus_client/badges/gpa.svg)](https://codeclimate.com/github/sul-dlss/globus_client)
 [![Code Climate Test Coverage](https://api.codeclimate.com/v1/badges/8e6bf1a5d3fc86a6fbd0/test_coverage)](https://codeclimate.com/github/sul-dlss/globus_client/test_coverage)
 
-# Globus::Client
+# GlobusClient
 
-Globus::Client is a Ruby gem that acts as a client to the RESTful HTTP APIs provided by the [Globus service](https://docs.globus.org/api/).
+GlobusClient is a Ruby gem that acts as a client to the RESTful HTTP APIs provided by the [Globus service](https://docs.globus.org/api/).
 
 ## Installation
 
@@ -25,15 +25,15 @@ For one-off requests:
 require 'globus_client'
 
 # NOTE: The settings below live in the consumer, not in the gem.
-client = Globus::Client.configure(
+client = GlobusClient.configure(
   client_id: Settings.globus.client_id,
   client_secret: Settings.globus.client_secret,
   uploads_directory: Settings.globus.uploads_directory,
   transfer_endpoint_id: Settings.globus.transfer_endpoint_id
 )
-client.mkdir(user_id: 'mjgiarlo', work_id: 1234, work_version: 1)
+client.mkdir(user_id: 'mjgiarlo@stanford.edu', path: 'mjgiarlo/work1234/version1')
 
-result = client.user_exists?('mjgiarlo')
+result = client.user_exists?('mjgiarlo@stanford.edu')
 ```
 
 You can also invoke methods directly on the client class, which is useful in a
@@ -43,7 +43,7 @@ to be sure configuration has already occurred, e.g.:
 
 ```ruby
 # config/initializers/globus_client.rb
-Globus::Client.configure(
+GlobusClient.configure(
   client_id: Settings.globus.client_id,
   client_secret: Settings.globus.client_secret,
   uploads_directory: Settings.globus.uploads_directory,
@@ -53,7 +53,7 @@ Globus::Client.configure(
 # app/services/my_globus_service.rb
 # ...
 def create_user_directory
-  Globus::Client.mkdir(user_id: 'mjgiarlo', work_id: 1234, work_version: 1)
+  GlobusClient.mkdir(user_id: 'mjgiarlo@stanford.edu', path: 'mjgiarlo/work1234/version1')
 end
 # ...
 ```

data/api_test.rb

@@ -4,31 +4,31 @@
 require "bundler/setup"
 require "globus_client"
 
-Globus::Client.configure(
+GlobusClient.configure(
   client_id: ENV["GLOBUS_CLIENT_ID"],
   client_secret: ENV["GLOBUS_CLIENT_SECRET"],
   uploads_directory: ENV["GLOBUS_UPLOADS_DIRECTORY"],
   transfer_endpoint_id: ENV["GLOBUS_ENDPOINT"]
 )
 
-user_id, work_id, work_version = *ARGV
+user_id, path = *ARGV
 
 # Test public API methods here.
-Globus::Client.mkdir(user_id:, work_id:, work_version:)
+GlobusClient.mkdir(user_id:, path:)
 
-user_exists = Globus::Client.user_exists?(user_id)
+user_exists = GlobusClient.user_exists?(user_id)
 
 # Not part of the public API but this allows us to test access changes
-before_permissions = Globus::Client::Endpoint.new(Globus::Client.config, user_id: user_id, work_id: work_id, work_version: work_version).send(:access_rule)["permissions"]
+before_permissions = GlobusClient::Endpoint.new(GlobusClient.config, user_id:, path:).send(:access_rule)["permissions"]
 
-files_count = Globus::Client.file_count(user_id:, work_id:, work_version:)
+files_count = GlobusClient.file_count(user_id:, path:)
 
-total_size = Globus::Client.total_size(user_id:, work_id:, work_version:)
+total_size = GlobusClient.total_size(user_id:, path:)
 
-Globus::Client.disallow_writes(user_id:, work_id:, work_version:)
+GlobusClient.disallow_writes(user_id:, path:)
 
 # Not part of the public API but this allows us to test access changes
-after_permissions = Globus::Client::Endpoint.new(Globus::Client.config, user_id: user_id, work_id: work_id, work_version: work_version).send(:access_rule)["permissions"]
+after_permissions = GlobusClient::Endpoint.new(GlobusClient.config, user_id:, path:).send(:access_rule)["permissions"]
 
 puts "User #{user_id} exists: #{user_exists}"
 puts "Initial directory permissions: #{before_permissions}"

data/globus_client.gemspec

@@ -2,11 +2,11 @@
 
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "globus/client/version"
+require "globus_client/version"
 
 Gem::Specification.new do |spec|
   spec.name = "globus_client"
-  spec.version = Globus::Client::VERSION
+  spec.version = GlobusClient::VERSION
   spec.authors = ["Aaron Collier", "Laura Wrubel", "Mike Giarlo"]
   spec.email = ["aaron.collier@stanford.edu", "lwrubel@stanford.edu", "mjgiarlo@stanford.edu"]
 

data/lib/globus_client/authenticator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class GlobusClient
+  # The namespace for the "login" command
+  class Authenticator
+    def self.token(client_id, client_secret, auth_url)
+      new(client_id, client_secret, auth_url).token
+    end
+
+    def initialize(client_id, client_secret, auth_url)
+      @client_id = client_id
+      @client_secret = client_secret
+      @auth_url = auth_url
+    end
+
+    # Request an access_token
+    def token
+      response = connection.post("/v2/oauth2/token", form_data)
+
+      JSON.parse(response.body)["access_token"]
+    end
+
+    private
+
+    attr_reader :client_id, :client_secret, :auth_url
+
+    def connection
+      Faraday.new(url: auth_url)
+    end
+
+    def form_data
+      {
+        client_id:,
+        client_secret:,
+        encoding: "form",
+        grant_type: "client_credentials",
+        scope: "urn:globus:auth:scope:transfer.api.globus.org:all"
+      }
+    end
+  end
+end

data/lib/globus_client/endpoint.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+class GlobusClient
+  # The namespace for endpoint API operations
+  class Endpoint
+    PATH_SEPARATOR = "/"
+
+    # @param config [#token, #uploads_directory, #transfer_endpoint_id, #transfer_url, #auth_url] configuration for the gem
+    # @param path [String] the path to operate on
+    # @param user_id [String] a Globus user ID (e.g., a @stanford.edu email address)
+    def initialize(config, path:, user_id:)
+      @config = config
+      @user_id = user_id
+      @path = path
+    end
+
+    def file_count
+      objects["total"]
+    end
+
+    def total_size
+      files.sum { |file| file["size"] }
+    end
+
+    # Create a directory https://docs.globus.org/api/transfer/file_operations/#make_directory
+    def mkdir
+      # transfer API does not support recursive directory creation
+      paths.each do |path|
+        response = connection.post("#{transfer_path}/mkdir") do |req|
+          req.headers["Content-Type"] = "application/json"
+          req.body = {
+            DATA_TYPE: "mkdir",
+            path:
+          }.to_json
+        end
+
+        next if response.success?
+
+        # Ignore error if directory already exists
+        if response.status == 502
+          error = JSON.parse(response.body)
+          next if error["code"] == "ExternalError.MkdirFailed.Exists"
+        end
+
+        UnexpectedResponse.call(response)
+      end
+    end
+
+    # Assign a user read/write permissions for a directory https://docs.globus.org/api/transfer/acl/#rest_access_create
+    def allow_writes
+      access_request(permissions: "rw")
+    end
+
+    # Assign a user read-only permissions for a directory https://docs.globus.org/api/transfer/acl/#rest_access_create
+    def disallow_writes
+      access_request(permissions: "r")
+    end
+
+    private
+
+    attr_reader :config, :path, :user_id
+
+    def connection
+      # Transfer API connection
+      Faraday.new(
+        url: config.transfer_url,
+        headers: {Authorization: "Bearer #{config.token}"}
+      )
+    end
+
+    def globus_identity_id
+      Identity.new(config).get_identity_id(user_id)
+    end
+
+    # Builds up a path from a list of path elements. E.g., input would look like:
+    #     "mjgiarlo/work123/version1"
+    # And this method returns:
+    #     ["/uploads/mjgiarlo/", "/uploads/mjgiarlo/work123/", "/uploads/mjgiarlo/work123/version1/"]
+    def paths
+      path_segments.map.with_index do |_segment, index|
+        File
+          .join(config.uploads_directory, path_segments.slice(..index))
+          .concat(PATH_SEPARATOR)
+      end
+    end
+
+    # @see #paths
+    def full_path
+      paths.last
+    end
+
+    def path_segments
+      path.split(PATH_SEPARATOR)
+    end
+
+    def objects
+      # List files at an endpoint https://docs.globus.org/api/transfer/file_operations/#list_directory_contents
+      response = connection.get("#{transfer_path}/ls?path=#{full_path}")
+      return JSON.parse(response.body) if response.success?
+
+      UnexpectedResponse.call(response)
+    end
+
+    def files
+      objects["DATA"].select { |object| object["DATA_TYPE"] == "file" }
+    end
+
+    def access_request(permissions:)
+      response = if access_rule_id
+        connection.put("#{access_path}/#{access_rule_id}") do |req|
+          req.body = {
+            DATA_TYPE: "access",
+            permissions:
+          }.to_json
+          req.headers["Content-Type"] = "application/json"
+        end
+      else
+        connection.post(access_path) do |req|
+          req.body = {
+            DATA_TYPE: "access",
+            principal_type: "identity",
+            principal: globus_identity_id,
+            path: full_path,
+            permissions:,
+            notify_email: user_id
+          }.to_json
+          req.headers["Content-Type"] = "application/json"
+        end
+      end
+
+      return true if response.success?
+
+      UnexpectedResponse.call(response)
+    end
+
+    def access_rule
+      response = connection.get(access_list_path) do |req|
+        req.headers["Content-Type"] = "application/json"
+      end
+
+      JSON
+        .parse(response.body)["DATA"]
+        .find { |acl| acl["path"] == full_path }
+    end
+
+    def access_rule_id
+      access_rule&.fetch("id")
+    end
+
+    def transfer_path
+      "/v0.10/operation/endpoint/#{config.transfer_endpoint_id}"
+    end
+
+    def access_path
+      "/v0.10/endpoint/#{config.transfer_endpoint_id}/access"
+    end
+
+    def access_list_path
+      "/v0.10/endpoint/#{config.transfer_endpoint_id}/access_list"
+    end
+  end
+end

data/lib/globus_client/identity.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class GlobusClient
+  # Lookup of a Globus identity ID
+  class Identity
+    def initialize(config)
+      @config = config
+    end
+
+    def get_identity_id(user_id)
+      @email = user_id
+
+      response = lookup_identity
+      UnexpectedResponse.call(response) unless response.success?
+
+      data = JSON.parse(response.body)
+      extract_id(data)
+    end
+
+    def exists?(user_id)
+      get_identity_id(user_id)
+      true
+    rescue
+      false
+    end
+
+    private
+
+    attr_reader :config
+
+    def connection
+      Faraday.new(url: config.auth_url)
+    end
+
+    def lookup_identity
+      id_endpoint = "/v2/api/identities"
+      connection.get(id_endpoint) do |req|
+        req.params["usernames"] = @email
+        req.headers["Authorization"] = "Bearer #{config.token}"
+      end
+    end
+
+    def extract_id(data)
+      identities = data["identities"]
+      # Select identity with "used" or "private" status
+      matching_users = identities.select { |id| id["username"] == @email }
+      active_users = matching_users.select { |user| (user["status"] == "used" || user["status"] == "private") }
+      raise "No matching active Globus user found for #{@email}." if active_users.empty?
+
+      active_users.first["id"]
+    end
+  end
+end

data/lib/globus_client/unexpected_response.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class GlobusClient
+  # Handles unexpected responses when communicating with Globus
+  class UnexpectedResponse
+    # Error raised when the Globus Auth or Transfer API returns a 400 error
+    class BadRequestError < StandardError; end
+
+    # Error raised by the Globus Auth API returns a 401 Unauthorized
+    class UnauthorizedError < StandardError; end
+
+    # Error raised when the Globus Auth or Transfer API returns a 403 Forbidden
+    class ForbiddenError < StandardError; end
+
+    # Error raised when the Globus Auth or Transfer API returns a 404 NotFound
+    class ResourceNotFound < StandardError; end
+
+    # Error raised when the Globus Transfer API returns a 502 Bad Gateway
+    class EndpointError < StandardError; end
+
+    # Error raised when the remote server returns a 503 Bad Gateway
+    class ServiceUnavailable < StandardError; end
+
+    # @param [Faraday::Response] response
+    # https://docs.globus.org/api/transfer/file_operations/#common_errors
+    # https://docs.globus.org/api/transfer/file_operations/#errors
+    # https://docs.globus.org/api/transfer/acl/#common_errors
+    # https://docs.globus.org/api/auth/reference/
+    def self.call(response)
+      case response.status
+      when 400
+        raise BadRequestError, "Invalid path or another error with the request: #{response.body}"
+      when 401
+        raise UnauthorizedError, "There was a problem with the access token: #{response.body} "
+      when 403
+        raise ForbiddenError, "The operation requires privileges which the client does not have: #{response.body}"
+      when 404
+        raise ResourceNotFound, "Endpoint ID not found or resource does not exist: #{response.body}"
+      when 502
+        raise EndpointError, "Other error with endpoint: #{response.body}"
+      when 503
+        raise ServiceUnavailable, "The service is down for maintenance."
+      else
+        raise StandardError, "Unexpected response: #{response.status} #{response.body}"
+      end
+    end
+  end
+end

data/lib/globus_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class GlobusClient
+  VERSION = "0.5.0"
+end

data/lib/globus_client.rb

@@ -1,5 +1,73 @@
-require "globus/client"
+# frozen_string_literal: true
 
-# This is here to make Zeitwerk happy
-module GlobusClient
+require "active_support/core_ext/module/delegation"
+require "faraday"
+require "ostruct"
+require "singleton"
+require "zeitwerk"
+
+# Load the gem's internal dependencies: use Zeitwerk instead of needing to manually require classes
+Zeitwerk::Loader.for_gem.setup
+
+# Client for interacting with the Globus API
+class GlobusClient
+  include Singleton
+
+  class << self
+    # @param client_id [String] the client identifier registered with Globus
+    # @param client_secret [String] the client secret to authenticate with Globus
+    # @param uploads_directory [String] where to upload files
+    # @param transfer_endpoint_id [String] the transfer API endpoint ID supplied by Globus
+    # @param transfer_url [String] the transfer API URL
+    # @param auth_url [String] the authentication API URL
+    def configure(client_id:, client_secret:, uploads_directory:, transfer_endpoint_id:, transfer_url: default_transfer_url, auth_url: default_auth_url)
+      instance.config = OpenStruct.new(
+        token: Authenticator.token(client_id, client_secret, auth_url),
+        uploads_directory:,
+        transfer_endpoint_id:,
+        transfer_url:,
+        auth_url:
+      )
+
+      self
+    end
+
+    delegate :config, :disallow_writes, :file_count, :mkdir, :total_size, :user_exists?, to: :instance
+
+    def default_transfer_url
+      "https://transfer.api.globusonline.org"
+    end
+
+    def default_auth_url
+      "https://auth.globus.org"
+    end
+  end
+
+  attr_accessor :config
+
+  def mkdir(...)
+    endpoint = Endpoint.new(config, ...)
+    endpoint.mkdir
+    endpoint.allow_writes
+  end
+
+  def disallow_writes(...)
+    endpoint = Endpoint.new(config, ...)
+    endpoint.disallow_writes
+  end
+
+  def file_count(...)
+    endpoint = Endpoint.new(config, ...)
+    endpoint.file_count
+  end
+
+  def total_size(...)
+    endpoint = Endpoint.new(config, ...)
+    endpoint.total_size
+  end
+
+  def user_exists?(...)
+    identity = Identity.new(config)
+    identity.exists?(...)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: globus_client
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Aaron Collier
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-07 00:00:00.000000000 Z
+date: 2022-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -166,14 +166,12 @@ files:
 - Rakefile
 - api_test.rb
 - globus_client.gemspec
-- lib/globus/client.rb
-- lib/globus/client/authenticator.rb
-- lib/globus/client/endpoint.rb
-- lib/globus/client/identity.rb
-- lib/globus/client/unexpected_response.rb
-- lib/globus/client/version.rb
 - lib/globus_client.rb
-- sig/globus_client.rbs
+- lib/globus_client/authenticator.rb
+- lib/globus_client/endpoint.rb
+- lib/globus_client/identity.rb
+- lib/globus_client/unexpected_response.rb
+- lib/globus_client/version.rb
 homepage: https://github.com/sul-dlss/globus_client
 licenses: []
 metadata:

data/lib/globus/client/authenticator.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Globus
-  class Client
-    # The namespace for the "login" command
-    class Authenticator
-      def self.token(client_id, client_secret, auth_url)
-        new(client_id, client_secret, auth_url).token
-      end
-
-      def initialize(client_id, client_secret, auth_url)
-        @client_id = client_id
-        @client_secret = client_secret
-        @auth_url = auth_url
-      end
-
-      # Request an access_token
-      def token
-        response = connection.post("/v2/oauth2/token", form_data)
-
-        JSON.parse(response.body)["access_token"]
-      end
-
-      private
-
-      attr_reader :client_id, :client_secret, :auth_url
-
-      def connection
-        Faraday.new(url: auth_url)
-      end
-
-      def form_data
-        {
-          client_id:,
-          client_secret:,
-          encoding: "form",
-          grant_type: "client_credentials",
-          scope: "urn:globus:auth:scope:transfer.api.globus.org:all"
-        }
-      end
-    end
-  end
-end

data/lib/globus/client/endpoint.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module Globus
-  class Client
-    # The namespace for endpoint API operations
-    class Endpoint
-      # @param config [#token, #uploads_directory, #transfer_endpoint_id, #transfer_url, #auth_url] configuration for the gem
-      # @param user_id [String] conventionally, we use the SUNet ID, not an email address
-      # @param work_id [#to_s] the identifier of the work (e.g., an H2 work)
-      # @param work_version [#to_s] the version of the work (e.g., an H2 version)
-      def initialize(config, user_id:, work_id:, work_version:)
-        @config = config
-        @user_id = user_id
-        @work_id = work_id
-        @work_version = work_version
-      end
-
-      def file_count
-        objects["total"]
-      end
-
-      def total_size
-        files.sum { |file| file["size"] }
-      end
-
-      # Create a directory https://docs.globus.org/api/transfer/file_operations/#make_directory
-      def mkdir
-        # transfer API does not support recursive directory creation
-        paths.each do |path|
-          response = connection.post("#{transfer_path}/mkdir") do |req|
-            req.headers["Content-Type"] = "application/json"
-            req.body = {
-              DATA_TYPE: "mkdir",
-              path:
-            }.to_json
-          end
-
-          next if response.success?
-
-          # Ignore error if directory already exists
-          if response.status == 502
-            error = JSON.parse(response.body)
-            next if error["code"] == "ExternalError.MkdirFailed.Exists"
-          end
-
-          UnexpectedResponse.call(response)
-        end
-      end
-
-      # Assign a user read/write permissions for a directory https://docs.globus.org/api/transfer/acl/#rest_access_create
-      def allow_writes
-        access_request(permissions: "rw")
-      end
-
-      # Assign a user read-only permissions for a directory https://docs.globus.org/api/transfer/acl/#rest_access_create
-      def disallow_writes
-        access_request(permissions: "r")
-      end
-
-      private
-
-      attr_reader :config, :user_id, :work_id, :work_version
-
-      def connection
-        # Transfer API connection
-        Faraday.new(
-          url: config.transfer_url,
-          headers: {Authorization: "Bearer #{config.token}"}
-        )
-      end
-
-      def user
-        Identity.new(config).get_identity_id(user_id)
-      end
-
-      # Builds up a path from a list of path elements. E.g., input would look like:
-      #     ["mjgiarlo", "work123", "version1"]
-      # And this method returns:
-      #     ["/uploads/mjgiarlo/", "/uploads/mjgiarlo/work123/", "/uploads/mjgiarlo/work123/version1/"]
-      def paths
-        path_segments.map.with_index do |_segment, index|
-          File.join(config.uploads_directory, path_segments.slice(..index)).concat("/")
-        end
-      end
-
-      # @see #paths
-      def full_path
-        paths.last
-      end
-
-      def path_segments
-        [user_id, "work#{work_id}", "version#{work_version}"]
-      end
-
-      def objects
-        # List files at an endpoint https://docs.globus.org/api/transfer/file_operations/#list_directory_contents
-        response = connection.get("#{transfer_path}/ls?path=#{full_path}")
-        return JSON.parse(response.body) if response.success?
-
-        UnexpectedResponse.call(response)
-      end
-
-      def files
-        objects["DATA"].select { |object| object["DATA_TYPE"] == "file" }
-      end
-
-      def access_request(permissions:)
-        response = if access_rule_id
-          connection.put("#{access_path}/#{access_rule_id}") do |req|
-            req.body = {
-              DATA_TYPE: "access",
-              permissions:
-            }.to_json
-            req.headers["Content-Type"] = "application/json"
-          end
-        else
-          connection.post(access_path) do |req|
-            req.body = {
-              DATA_TYPE: "access",
-              principal_type: "identity",
-              principal: user,
-              path: full_path,
-              permissions:,
-              notify_email: "#{user_id}@stanford.edu"
-            }.to_json
-            req.headers["Content-Type"] = "application/json"
-          end
-        end
-
-        return response if response.success?
-
-        UnexpectedResponse.call(response)
-      end
-
-      def access_rule
-        response = connection.get(access_list_path) do |req|
-          req.headers["Content-Type"] = "application/json"
-        end
-
-        JSON
-          .parse(response.body)["DATA"]
-          .find { |acl| acl["path"] == full_path }
-      end
-
-      def access_rule_id
-        access_rule&.fetch("id")
-      end
-
-      def transfer_path
-        "/v0.10/operation/endpoint/#{config.transfer_endpoint_id}"
-      end
-
-      def access_path
-        "/v0.10/endpoint/#{config.transfer_endpoint_id}/access"
-      end
-
-      def access_list_path
-        "/v0.10/endpoint/#{config.transfer_endpoint_id}/access_list"
-      end
-    end
-  end
-end

data/lib/globus/client/identity.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Globus
-  class Client
-    # Lookup of a Globus identity ID
-    class Identity
-      def initialize(config)
-        @config = config
-      end
-
-      def get_identity_id(sunetid)
-        @email = "#{sunetid}@stanford.edu"
-
-        response = lookup_identity
-        UnexpectedResponse.call(response) unless response.success?
-
-        data = JSON.parse(response.body)
-        extract_id(data)
-      end
-
-      def exists?(sunetid)
-        get_identity_id(sunetid)
-        true
-      rescue
-        false
-      end
-
-      private
-
-      attr_reader :config
-
-      def connection
-        Faraday.new(url: config.auth_url)
-      end
-
-      def lookup_identity
-        id_endpoint = "/v2/api/identities"
-        connection.get(id_endpoint) do |req|
-          req.params["usernames"] = @email
-          req.headers["Authorization"] = "Bearer #{config.token}"
-        end
-      end
-
-      def extract_id(data)
-        identities = data["identities"]
-        # Select identity with "used" or "private" status
-        matching_users = identities.select { |id| id["username"] == @email }
-        active_users = matching_users.select { |user| (user["status"] == "used" || user["status"] == "private") }
-        raise "No matching active Globus user found for #{@email}." if active_users.empty?
-
-        active_users.first["id"]
-      end
-    end
-  end
-end

data/lib/globus/client/unexpected_response.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Globus
-  class Client
-    # Handles unexpected responses when communicating with Globus
-    class UnexpectedResponse
-      # Error raised when the Globus Auth or Transfer API returns a 400 error
-      class BadRequestError < StandardError; end
-
-      # Error raised by the Globus Auth API returns a 401 Unauthorized
-      class UnauthorizedError < StandardError; end
-
-      # Error raised when the Globus Auth or Transfer API returns a 403 Forbidden
-      class ForbiddenError < StandardError; end
-
-      # Error raised when the Globus Auth or Transfer API returns a 404 NotFound
-      class ResourceNotFound < StandardError; end
-
-      # Error raised when the Globus Transfer API returns a 502 Bad Gateway
-      class EndpointError < StandardError; end
-
-      # Error raised when the remote server returns a 503 Bad Gateway
-      class ServiceUnavailable < StandardError; end
-
-      # @param [Faraday::Response] response
-      # https://docs.globus.org/api/transfer/file_operations/#common_errors
-      # https://docs.globus.org/api/transfer/file_operations/#errors
-      # https://docs.globus.org/api/transfer/acl/#common_errors
-      # https://docs.globus.org/api/auth/reference/
-      def self.call(response)
-        case response.status
-        when 400
-          raise BadRequestError, "Invalid path or another error with the request: #{response.body}"
-        when 401
-          raise UnauthorizedError, "There was a problem with the access token: #{response.body} "
-        when 403
-          raise ForbiddenError, "The operation requires privileges which the client does not have: #{response.body}"
-        when 404
-          raise ResourceNotFound, "Endpoint ID not found or resource does not exist: #{response.body}"
-        when 502
-          raise EndpointError, "Other error with endpoint: #{response.body}"
-        when 503
-          raise ServiceUnavailable, "The service is down for maintenance."
-        else
-          raise StandardError, "Unexpected response: #{response.status} #{response.body}"
-        end
-      end
-    end
-  end
-end

data/lib/globus/client/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Globus
-  class Client
-    VERSION = "0.3.2"
-  end
-end

data/lib/globus/client.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/module/delegation"
-require "faraday"
-require "ostruct"
-require "singleton"
-require "zeitwerk"
-
-# Load the gem's internal dependencies
-loader = Zeitwerk::Loader.new
-loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
-loader.push_dir(File.absolute_path("#{__FILE__}/../.."))
-loader.setup
-
-module Globus
-  # Client for interacting with the Globus API
-  class Client
-    include Singleton
-
-    class << self
-      # @param client_id [String] the client identifier registered with Globus
-      # @param client_secret [String] the client secret to authenticate with Globus
-      # @param uploads_directory [String] where to upload files
-      # @param transfer_endpoint_id [String] the transfer API endpoint ID supplied by Globus
-      # @param transfer_url [String] the transfer API URL
-      # @param auth_url [String] the authentication API URL
-      def configure(client_id:, client_secret:, uploads_directory:, transfer_endpoint_id:, transfer_url: default_transfer_url, auth_url: default_auth_url)
-        instance.config = OpenStruct.new(
-          token: Globus::Client::Authenticator.token(client_id, client_secret, auth_url),
-          uploads_directory:,
-          transfer_endpoint_id:,
-          transfer_url:,
-          auth_url:
-        )
-
-        self
-      end
-
-      delegate :config, :disallow_writes, :file_count, :mkdir, :total_size, :user_exists?, to: :instance
-
-      def default_transfer_url
-        "https://transfer.api.globusonline.org"
-      end
-
-      def default_auth_url
-        "https://auth.globus.org"
-      end
-    end
-
-    attr_accessor :config
-
-    def mkdir(...)
-      endpoint = Globus::Client::Endpoint.new(config, ...)
-      endpoint.mkdir
-      endpoint.allow_writes
-    end
-
-    def disallow_writes(...)
-      endpoint = Globus::Client::Endpoint.new(config, ...)
-      endpoint.disallow_writes
-    end
-
-    def file_count(...)
-      endpoint = Globus::Client::Endpoint.new(config, ...)
-      endpoint.file_count
-    end
-
-    def total_size(...)
-      endpoint = Globus::Client::Endpoint.new(config, ...)
-      endpoint.total_size
-    end
-
-    def user_exists?(...)
-      identity = Globus::Client::Identity.new(config)
-      identity.exists?(...)
-    end
-  end
-end

data/sig/globus_client.rbs

@@ -1,4 +0,0 @@
-module GlobusClient
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end