class Aws::EC2Metadata

def backoff(backoff)
  case backoff
  when Proc then backoff
  when Numeric then ->(_) { Kernel.sleep(backoff) }
  else ->(num_failures) { Kernel.sleep(1.2**num_failures) }
  end
end

def fetch_token
  open_connection do |conn|
    created_time = Time.now
    token_value, token_ttl = http_put(conn, @token_ttl)
    @token = Token.new(value: token_value, ttl: token_ttl, created_time: created_time)
  end
end

def get(path)
  retry_errors(max_retries: @retries) do
    @mutex.synchronize do
      fetch_token unless @token && !@token.expired?
    end
    open_connection do |conn|
      http_get(conn, path, @token.value)
    end
  end
end

def http_get(connection, path, token)
  headers = {
    'User-Agent' => "aws-sdk-ruby3/#{CORE_GEM_VERSION}",
    'x-aws-ec2-metadata-token' => token
  }
  request = Net::HTTP::Get.new(path, headers)
  response = connection.request(request)
  case response.code.to_i
  when 200
    response.body
  when 401
    raise TokenExpiredError
  when 404
    raise MetadataNotFoundError
  end
end

def http_put(connection, ttl)
  headers = {
    'User-Agent' => "aws-sdk-ruby3/#{CORE_GEM_VERSION}",
    'x-aws-ec2-metadata-token-ttl-seconds' => ttl.to_s
  }
  request = Net::HTTP::Put.new(METADATA_TOKEN_PATH, headers)
  response = connection.request(request)
  case response.code.to_i
  when 200
    [
      response.body,
      response.header['x-aws-ec2-metadata-token-ttl-seconds'].to_i
    ]
  when 400
    raise TokenRetrievalError
  when 403
    raise RequestForbiddenError
  end
end

def initialize(options = {})
  @token_ttl = options[:token_ttl] || 21_600
  @retries = options[:retries] || 3
  @backoff = backoff(options[:backoff])
  endpoint_mode = options[:endpoint_mode] || 'IPv4'
  @endpoint = resolve_endpoint(options[:endpoint], endpoint_mode)
  @port = options[:port] || 80
  @http_open_timeout = options[:http_open_timeout] || 1
  @http_read_timeout = options[:http_read_timeout] || 1
  @http_debug_output = options[:http_debug_output]
  @token = nil
  @mutex = Mutex.new
end

def open_connection
  uri = URI.parse(@endpoint)
  http = Net::HTTP.new(uri.hostname || @endpoint, uri.port || @port)
  http.open_timeout = @http_open_timeout
  http.read_timeout = @http_read_timeout
  http.set_debug_output(@http_debug_output) if @http_debug_output
  http.start
  yield(http).tap { http.finish }
end

def resolve_endpoint(endpoint, endpoint_mode)
  return endpoint if endpoint
  case endpoint_mode.downcase
  when 'ipv4' then 'http://169.254.169.254'
  when 'ipv6' then 'http://[fd00:ec2::254]'
  else
    raise ArgumentError,
          ':endpoint_mode is not valid, expected IPv4 or IPv6, '\
          "got: #{endpoint_mode}"
  end
end

def retry_errors(options = {}, &_block)
  max_retries = options[:max_retries]
  retries = 0
  begin
    yield
  # These errors should not be retried.
  rescue TokenRetrievalError, MetadataNotFoundError, RequestForbiddenError
    raise
  # StandardError is not ideal but it covers Net::HTTP errors.
  # https://gist.github.com/tenderlove/245188
  rescue StandardError, TokenExpiredError
    raise unless retries < max_retries
    @backoff.call(retries)
    retries += 1
    retry
  end
end