cartography-api 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd800af9e8bd0913f046d0bab7b9f6b2ed94befba22208b42071f6f89d79c90a
+  data.tar.gz: 25228b868b185e7981beb12701ddedb0aac075a95309ddabdad4fee135647caf
+SHA512:
+  metadata.gz: 3ad6dbedd9029037d3c1a59c02e598762fbd6bfa6f3c5f694c36574f07a376543cbd7ad526eebed663f2452a9735c7f55e7203c75ea79398017a552fd7d57f07
+  data.tar.gz: edfcc9e11de37de65d724a300bb319104b78f1ce5ec50026a181b046d6d296ddb6ca0bcb0066a82505423fd81f175e74cd0281220fa060370500653320befa96

data/lib/cartography/acceptance.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Cartography
+  class AcceptanceResult
+    attr_reader :checks, :summary
+
+    def initialize(params = {})
+      @checks = params["Checks"].map { |c| Check.new(c) }
+      @summary = Summary.new(params["Summary"])
+    end
+
+    def success?
+      summary.status == "SUCCESS"
+    end
+
+    class Check
+      attr_reader :address,
+        :dns,
+        :duration,
+        :error,
+        :http,
+        :skipped,
+        :success
+
+      def initialize(params = {})
+        @address = params["Address"] && Address.new(params["Address"])
+        @dns = params["DNS"] && DNS.new(params["DNS"])
+        @duration = params["Duration"].to_i
+        @error = params["Error"]
+        @http = params["HTTP"] && HTTP.new(params["HTTP"])
+        @skipped = params["Skipped"]
+        @success = params["Success"]
+      end
+
+      class Address
+        attr_reader :port,
+          :record
+
+        def initialize(params = {})
+          @port = params["Port"].to_i
+          @record = params["Record"]
+        end
+      end
+
+      class DNS
+        attr_reader :record,
+          :type
+
+        def initialize(params = {})
+          @record = params["Record"]
+          @type = params["Type"]
+        end
+      end
+
+      class HTTP
+        attr_reader :url
+
+        def initialize(params = {})
+          @url = params["URL"]
+        end
+      end
+    end
+
+    class Summary
+      attr_reader :status, :total_failed, :total_skipped, :total_success
+
+      def initialize(params = {})
+        @status = params["Status"]
+        @total_failed = params["TotalFailed"].to_i
+        @total_skipped = params["TotalSkipped"].to_i
+        @total_success = params["TotalSuccess"].to_i
+      end
+    end
+  end
+end

data/lib/cartography/client.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+require "http"
+require "json"
+
+module Cartography
+  # Client class is the base method for making calls to the API. Methods
+  # either return plain objects or class instances.
+  #
+  # @attr_reader [String] api_key The API key used for authentication
+  # @attr_reader [String] endpoint The API endpoint
+  # @attr_reader [Bool] whether to return dynamic data
+  # @attr_reader [Integer] the number of retries for the request
+  class Client
+    attr_reader :username, :password, :endpoint, :dynamic, :retries
+
+    RETRY_ERRORS = [
+      HTTP::ConnectionError,
+      HTTP::TimeoutError
+    ]
+
+    def initialize(username:, password:, endpoint:, dynamic: false, retries: 5)
+      @username = username
+      @password = password
+      @endpoint = endpoint
+      @dynamic = dynamic
+      @retries = retries
+    end
+
+    # Returns true if the endpoint is healthy
+    #
+    # @return [Bool]
+    def ping?
+      get_body("ping")["message"] == "pong"
+    end
+
+    # Returns all custom CNAMEs
+    #
+    # @return [Array<CustomCname>] a list of all custom CNAMEs
+    def get_custom_cnames
+      cnames = get_body(custom_cnames_root_path)
+
+      cnames.map do |cname|
+        Cartography::CustomCname.new(cname)
+      end
+    end
+
+    # Returns all custom cnames associated with the specified account ID
+    #
+    # @param account_id [String] the account ID
+    # @return [Array<CustomCname>] a list of all custom CNAMEs
+    def get_custom_cnames_by_account_id(account_id)
+      cnames = get_body(custom_cnames_root_path, params: {account_id: account_id})
+
+      cnames.map do |cname|
+        Cartography::CustomCname.new(cname)
+      end
+    end
+
+    # Query the API for a custom CNAME
+    #
+    # @param cname_id [String] the custom CNAME ID
+    # @return [Class<CustomCnamey>] a CustomCname instance
+    def get_custom_cname(cname_id:)
+      params = get_body("#{custom_cnames_root_path}/#{cname_id}")
+
+      Cartography::CustomCname.new(params)
+    end
+
+    # Perform an acceptance test for a custom CNAME
+    #
+    # @param cname_id [String] the custom CNAME ID
+    # @return [Class<AcceptanceResult>] a AcceptanceResult instance
+    def perform_custom_cname_acceptance(cname_id:)
+      params = post_body("#{custom_cnames_root_path}/#{cname_id}/acceptance")
+
+      Cartography::AcceptanceResult.new(params)
+    end
+
+    # Return Goss configuration
+    #
+    # @param cname_id [String] the custom CNAME ID
+    # @param format [String] the format of the result, such as json or yaml
+    # @return [String] the Goss configuration
+    def get_custom_cname_acceptance_config(cname_id:, format: "json")
+      get_body("#{custom_cnames_root_path}/#{cname_id}/acceptance/config", params: {format: format}).to_s
+    end
+
+    # Returns all routing policies
+    #
+    # @return [Array<RoutingPolicy>] a list of all routing policies
+    def get_routing_policies
+      policies = get_body(routing_policies_root_path)
+
+      policies.map do |policy|
+        Cartography::RoutingPolicy.new(policy)
+      end
+    end
+
+    # Returns all routing policies associated with the specified account ID
+    #
+    # @param account_id [String] the account ID
+    # @return [Array<RoutingPolicy>] a list of all routing policies
+    def get_routing_policies_by_account_id(account_id)
+      policies = get_body(routing_policies_root_path, params: {account_id: account_id})
+
+      policies.map do |policy|
+        Cartography::RoutingPolicy.new(policy)
+      end
+    end
+
+    # Query the API for a routing policy
+    #
+    # @param policy_id [String] the routing policy ID
+    # @return [Class<RoutingPolicy>] a RoutingPolicy instance
+    def get_routing_policy(policy_id:)
+      params = get_body("#{routing_policies_root_path}/#{policy_id}")
+
+      Cartography::RoutingPolicy.new(params)
+    end
+
+    # Perform an acceptance test for a routing policy
+    #
+    # @param policy_id [String] the routing policy ID
+    # @return [Class<AcceptanceResult>] a AcceptanceResult instance
+    def perform_routing_policy_acceptance(policy_id:)
+      params = post_body("#{routing_policies_root_path}/#{policy_id}/acceptance")
+
+      Cartography::AcceptanceResult.new(params)
+    end
+
+    # Return Goss configuration
+    #
+    # @param policy_id [String] the routing policy ID
+    # @param format [String] the format of the result, such as json or yaml
+    # @return [String] the Goss configuration
+    def get_routing_policy_acceptance_config(policy_id:, format: "json")
+      get_body("#{routing_policies_root_path}/#{policy_id}/acceptance/config", params: {format: format}).to_s
+    end
+
+    # Query the API for all clusters
+    #
+    # @return [Array<Cluster>]
+    def get_clusters
+      clusters = get_body(clusters_root_path)
+
+      clusters.map do |cluster|
+        Cartography::Cluster.new(cluster)
+      end
+    end
+
+    # Query the API for clusters by type
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @return [Array<Cluster>]
+    def get_clusters_by_type(type:)
+      clusters = get_body("#{clusters_root_path}/#{type}")
+
+      clusters.map do |cluster|
+        Cartography::Cluster.new(cluster)
+      end
+    end
+
+    # Query the API for a specific cluster
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @return [Array<Cluster>]
+    def get_cluster(type:, namespace:)
+      cluster = get_body("#{clusters_root_path}/#{type}/#{namespace}")
+      Cartography::Cluster.new(cluster)
+    end
+
+    # Perform an acceptance test for a cluster
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @return [Class<AcceptanceResult>] an AcceptanceResult instance
+    def perform_cluster_acceptance(type:, namespace:)
+      params = post_body("#{clusters_root_path}/#{type}/#{namespace}/acceptance")
+
+      Cartography::AcceptanceResult.new(params)
+    end
+
+    # Return Goss configuration for a cluster
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @param format [String] the format of the result, such as json or yaml
+    # @return [String] the Goss configuration
+    def get_cluster_acceptance_config(type:, namespace:, format: "json")
+      get_body("#{clusters_root_path}/#{type}/#{namespace}/acceptance/config", params: {format: format}).to_s
+    end
+
+    # Query the API for a specific cluster site by type, namespace and site
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @param site [String] the cluster site, such as eu-west-1-A
+    # @return [Cluster]
+    def get_cluster_site(type:, namespace:, site:)
+      site = get_body("#{clusters_root_path}/#{type}/#{namespace}/#{site}")
+      Cartography::Cluster::Site.new(site)
+    end
+
+    # Perform an acceptance test for a cluster site
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @param site [String] the cluster site, such as eu-west-1-A
+    # @return [Class<AcceptanceResult>] an AcceptanceResult instance
+    def perform_cluster_site_acceptance(type:, namespace:, site:)
+      params = post_body("#{clusters_root_path}/#{type}/#{namespace}/#{site}/acceptance")
+
+      Cartography::AcceptanceResult.new(params)
+    end
+
+    # Return Goss configuration for a cluster site
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @param site [String] the cluster site, such as eu-west-1-A
+    # @param format [String] the format of the result, such as json or yaml
+    # @return [String] the Goss configuration
+    def get_cluster_site_acceptance_config(type:, namespace:, site:, format: "json")
+      get_body("#{clusters_root_path}/#{type}/#{namespace}/#{site}/acceptance/config", params: {format: format}).to_s
+    end
+
+    # Query the API for all server groups in a specific cluster site by type,
+    # namespace and site
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @param site [String] the cluster site, such as eu-west-1-A
+    # @return [Array<ServerGroup>]
+    def get_cluster_site_server_groups(type:, namespace:, site:)
+      server_groups = get_body("#{clusters_root_path}/#{type}/#{namespace}/#{site}/server-groups")
+
+      server_groups.map do |sg|
+        Cartography::Cluster::Site::ServerGroup.new(sg)
+      end
+    end
+
+    # Query the API for a specific server group in a specific cluster site by
+    # type, namespace and site
+    #
+    # @param type [String] the cluster type, such as realtime
+    # @param namespace [String] the cluster namespace, such as main
+    # @param site [String] the cluster site, such as eu-west-1-A
+    # @param server_group [String] the server group, such as core
+    # @return [ServerGroup]
+    def get_cluster_site_server_group(type:, namespace:, site:, server_group:)
+      server_group = get_body("#{clusters_root_path}/#{type}/#{namespace}/#{site}/server-groups/#{server_group}")
+      Cartography::Cluster::Site::ServerGroup.new(server_group)
+    end
+
+    # Returns all placement constraints
+    #
+    # @return [Array<PlacementConstraint>] a list of all placement constraints
+    def get_placement_constraints
+      constraints = get_body(placement_constraints_root_path)
+
+      constraints.map do |constraint|
+        Cartography::PlacementConstraint.new(constraint)
+      end
+    end
+
+    # Returns all placement constraints associated with the specified account ID
+    #
+    # @param account_id [String] the account ID
+    # @return [Array<PlacementConstraint>] a list of all placement constraints
+    def get_placement_constraints_by_account_id(account_id)
+      constraints = get_body(placement_constraints_root_path, params: {account_id: account_id})
+
+      constraints.map do |constraint|
+        Cartography::PlacementConstraint.new(constraint)
+      end
+    end
+
+    # Query the API for a placement constraint
+    #
+    # @param placement_constraint_id [String] the placement constraint ID
+    # @return [Class<PlacementConstraint>] a PlacementConstraint instance
+    def get_placement_constraint(placement_constraint_id:)
+      params = get_body("#{placement_constraints_root_path}/#{placement_constraint_id}")
+
+      Cartography::PlacementConstraint.new(params)
+    end
+
+    class ResponseError < StandardError; end
+
+    def get(path, params: {})
+      retry_count ||= 0
+
+      resp = HTTP.basic_auth(user: username, pass: password).get("#{endpoint}/#{strip_path(path)}", params: default_params.merge(params))
+
+      raise ResponseError, resp.status.to_s unless resp.status.success?
+
+      resp
+    rescue *RETRY_ERRORS => e
+      sleep 1 * retry_count
+      retry if (retry_count += 1) < retries
+
+      raise e
+    end
+
+    def get_body(path, params: {})
+      JSON.parse(get(path, params: default_params.merge(params || {})).body)
+    end
+
+    def post(path, params: {})
+      resp = HTTP.basic_auth(user: username, pass: password).post("#{endpoint}/#{path}", params: default_params.merge(params))
+
+      raise ResponseError, resp.status.to_s unless resp.status.success?
+
+      resp
+    end
+
+    def post_body(path, params: {})
+      JSON.parse(post(path, params: default_params.merge(params)).body)
+    end
+
+    private
+
+    def default_params
+      if dynamic
+        {dynamic: dynamic}
+      else
+        {}
+      end
+    end
+
+    def placement_constraints_root_path
+      "placement-constraints"
+    end
+
+    def custom_cnames_root_path
+      "custom-cnames"
+    end
+
+    def routing_policies_root_path
+      "routing-policies"
+    end
+
+    def clusters_root_path
+      "clusters"
+    end
+
+    class InvalidClusterID < StandardError; end
+
+    def split_cluster_id(cluster_id:)
+      split_id = cluster_id.split(":")
+
+      raise InvalidClusterID if split_id.length != 3
+
+      {
+        environment: split_id.first,
+        type: split_id[1],
+        namespace: split_id.last
+      }
+    end
+
+    # Removes the leading / character
+    def strip_path(path)
+      if path.match?(/^\/.*$/)
+        path[1..]
+      else
+        path
+      end
+    end
+  end
+end

data/lib/cartography/cluster.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Cartography
+  class Cluster
+    attr_reader :cluster_id,
+      :environment,
+      :type,
+      :namespace,
+      :site_list,
+      :sites,
+      :endpoints
+
+    def initialize(params = {})
+      @cluster_id = params["ClusterID"]
+      @environment = params["Environment"]
+      @type = params["Type"]
+      @namespace = params["Namespace"]
+      @site_list = params["SiteList"]
+      @sites = params["Sites"].map { |s| Site.new(s) }
+      @endpoints = Endpoints.new(params["Endpoints"])
+    end
+
+    class Endpoints
+      attr_reader :primary,
+        :direct_fallback,
+        :latency_fallback,
+        :internal_api
+
+      def initialize(params = {})
+        @primary = params&.fetch("Primary")
+        @direct_fallback = params&.fetch("DirectFallback")
+        @latency_fallback = params&.fetch("LatencyFallback")
+        @internal_api = params&.fetch("InternalAPI")
+      end
+    end
+
+    class Site
+      attr_reader :cluster_id,
+        :environment,
+        :type,
+        :namespace,
+        :site,
+        :site_groups,
+        :region,
+        :server_groups,
+        :load_balancers,
+        :zone_assignment,
+        :availability_zone,
+        :endpoints
+
+      def initialize(params = {})
+        @site = params["Site"]
+        @site_groups = params["SiteGroups"]
+        @region = params["Region"]
+        @server_groups = params["ServerGroups"].map { |p| ServerGroup.new(p) }
+
+        @load_balancers = params["LoadBalancers"].each_with_object({}) do |(kind, lbs), hash|
+          hash[kind] = lbs.map { |lb| LoadBalancer.new(lb) }
+        end
+
+        @zone_assignment = params["ZoneAssignment"]
+        @availability_zone = params["AvailabilityZone"]
+        @endpoints = Endpoints.new(params["Endpoints"])
+      end
+
+      class LoadBalancer
+        attr_reader :name,
+          :arn
+
+        def initialize(params = {})
+          @name = params["Name"]
+          @arn = params["arn"]
+        end
+      end
+
+      class ServerGroup
+        attr_reader :name,
+          :full_name,
+          :arn,
+          :min_size,
+          :max_size,
+          :launch_templates,
+          :desired_size,
+          :actual_size
+
+        def initialize(params = {})
+          @name = params["Name"]
+          @full_name = params["FullName"]
+          @arn = params["Arn"]
+          @min_size = params["MinSize"]
+          @max_size = params["MaxSize"]
+          @launch_templates = params["LaunchTemplates"].map { |p| LaunchTemplate.new(p) }
+          @desired_size = params["DesiredSize"]
+          @actual_size = params["ActualSize"]
+        end
+
+        class LaunchTemplate
+          attr_reader :name,
+            :id,
+            :image_id,
+            :instance_type
+
+          def initialize(params = {})
+            @name = params["Name"]
+            @id = params["ID"]
+            @image_id = params["ImageID"]
+            @instance_type = params["InstanceType"]
+          end
+        end
+      end
+
+      class Endpoints
+        attr_reader :primary,
+          :fallback,
+          :internal_api
+
+        def initialize(params = {})
+          @primary = params&.fetch("Primary")
+          @fallback = params&.fetch("Fallback")
+          @internal_api = params&.fetch("InternalAPI")
+        end
+      end
+    end
+  end
+end

data/lib/cartography/custom_cname.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Cartography
+  # CustomCname holds data for the current state of a specific custom
+  # CNAME.
+  #
+  # @attr_reader [String] custom_cname_id The ID of the custom CNAME
+  class CustomCname
+    attr_reader :custom_cname_id,
+      :account_id,
+      :site_group,
+      :target_cluster,
+      :associated_routing_policy,
+      :cloudfront_distribution_id,
+      :target_record,
+      :cname_dns_validated,
+      :cloudfront_routing_disabled,
+      :aws_shield_enabled,
+      :fallbacks,
+      :certificate
+
+    def initialize(params = {})
+      @custom_cname_id = params["CustomCnameID"]
+      @account_id = params["AccountID"]
+      @site_group = params["SiteGroup"]
+      @target_cluster = params["TargetCluster"]
+      @associated_routing_policy = params["AssociatedRoutingPolicy"]
+      @cloudfront_distribution_id = params["CloudfrontDistributionID"]
+      @target_record = params["TargetRecord"]
+      @cname_dns_validated = params["CnameDNSValidated"]
+      @cloudfront_routing_disabled = params["CloudfrontRoutingDisabled"]
+      @aws_shield_enabled = params["AWSShieldEnabled"]
+      @fallbacks = params["Fallbacks"].map { |f| Fallback.new(f) }
+      @certificate = Certificate.new(params["Certificate"])
+    end
+
+    class Fallback
+      attr_reader :endpoint, :target
+
+      def initialize(params = {})
+        @endpoint = params["Endpoint"]
+        @target = params["Target"]
+      end
+    end
+
+    class Certificate
+      attr_reader :arn
+
+      def initialize(params = {})
+        @arn = params["Arn"]
+      end
+    end
+  end
+end

data/lib/cartography/placement_constraint.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cartography
+  # PlacementConstraint holds data for the current state of a specific
+  # placement constraint.
+  class PlacementConstraint
+    attr_reader :placement_constraint_id,
+      :account_id,
+      :cluster,
+      :environment,
+      :keyspace,
+      :placement_error,
+      :sites
+
+    def initialize(params = {})
+      @placement_constraint_id = params["PlacementConstraintID"]
+      @account_id = params["AccountID"]
+      @cluster = params["Cluster"]
+      @environment = params["Environment"]
+      @keyspace = params["Keyspace"]
+      @placement_error = PlacementError.new(params["PlacementError"])
+      @sites = params["Sites"]
+    end
+
+    class PlacementError
+      attr_reader :status_code
+
+      def initialize(params = {})
+        @status_code = params["StatusCode"]
+      end
+    end
+  end
+end

data/lib/cartography/routing_policy.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cartography
+  # RoutingPolicy holds data for the current state of a specific routing
+  # policy.
+  #
+  # @attr_reader [String] policy_id The ID of the routing policy
+  class RoutingPolicy
+    attr_reader :policy_id,
+      :account_id,
+      :protocols,
+      :site_group,
+      :target_cluster,
+      :fallbacks,
+      :certificate
+
+    def initialize(params = {})
+      @policy_id = params["PolicyID"]
+      @account_id = params["AccountID"]
+      @site_group = params["SiteGroup"]
+      @target_cluster = params["TargetCluster"]
+      @protocols = params["Protocols"].map { |p| Protocol.new(p) }
+      @fallbacks = params["Fallbacks"].map { |f| Fallback.new(f) }
+      @certificate = Certificate.new(params["Certificate"])
+    end
+
+    class Protocol
+      attr_reader :name, :endpoint, :cloudfront_enabled
+
+      def initialize(params = {})
+        @name = params["Name"]
+        @endpoint = params["Endpoint"]
+        @cloudfront_enabled = params["CloudFrontEnabled"]
+      end
+    end
+
+    class Fallback
+      attr_reader :endpoint, :target
+
+      def initialize(params = {})
+        @endpoint = params["Endpoint"]
+        @target = params["Target"]
+      end
+    end
+
+    class Certificate
+      attr_reader :arn, :domains
+
+      def initialize(params = {})
+        @arn = params["Arn"]
+        @domains = params["Domains"]
+      end
+    end
+  end
+end

data/lib/cartography/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cartography
+  VERSION = "0.7.0"
+end

data/lib/cartography.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "cartography/acceptance"
+require_relative "cartography/client"
+require_relative "cartography/cluster"
+require_relative "cartography/placement_constraint"
+require_relative "cartography/routing_policy"
+require_relative "cartography/custom_cname"
+require_relative "cartography/version"
+
+# The Cartography API is used for querying the current state of our
+# infrastructure.
+#
+# Currently only routing policies are supported.
+module Cartography
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: cartography-api
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Laura Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.4'
+description: 
+email:
+- laura.martin@ably.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cartography.rb
+- lib/cartography/acceptance.rb
+- lib/cartography/client.rb
+- lib/cartography/cluster.rb
+- lib/cartography/custom_cname.rb
+- lib/cartography/placement_constraint.rb
+- lib/cartography/routing_policy.rb
+- lib/cartography/version.rb
+homepage: 
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key: 
+specification_version: 4
+summary: Query the Cartography API.
+test_files: []