Class: Mongo::URI

# File 'lib/mongo/uri.rb', line 49

attr_reader :servers

# File 'lib/mongo/uri.rb', line 44

attr_reader :uri_options

# File 'lib/mongo/uri.rb', line 315

def credentials
  { :user => @user, :password => @password }
end

# File 'lib/mongo/uri.rb', line 327

def database
  @database ? @database : Database::ADMIN
end

# File 'lib/mongo/uri.rb', line 481

def decode(value)
  ::URI::DEFAULT_PARSER.unescape(value)
end

# File 'lib/mongo/uri.rb', line 485

def encode(value)
  CGI.escape(value).gsub('+', '%20')
end

# File 'lib/mongo/uri.rb', line 418

def options_mapper
  @options_mapper ||= OptionsMapper.new(
    logger: @options[:logger],
  )
end

# File 'lib/mongo/uri.rb', line 374

def parse!(remaining)
  hosts_and_db, options = remaining.split('?', 2)
  if options && options.index('?')
    raise_invalid_error!("Options contain an unescaped question mark (?), or the database name contains a question mark and was not escaped")
  end

  hosts, db = hosts_and_db.split('/', 2)
  if db && db.index('/')
    raise_invalid_error!("Database name contains an unescaped slash (/): #{db}")
  end

  if hosts.index('@')
    creds, hosts = hosts.split('@', 2)
    if hosts.empty?
      raise_invalid_error!("Empty hosts list")
    end
    if hosts.index('@')
      raise_invalid_error!("Unescaped @ in auth info")
    end
  end

  unless hosts.length > 0
    raise_invalid_error!("Missing host; at least one must be provided")
  end

  @servers = hosts.split(',').map do |host|
    if host.empty?
      raise_invalid_error!('Empty host given in the host list')
    end
    decode(host).tap do |host|
      validate_address_str!(host)
    end
  end

  @user = parse_user!(creds)
  @password = parse_password!(creds)
  @uri_options = Options::Redacted.new(parse_uri_options!(options))
  if db
    @database = parse_database!(db)
  end
rescue Error::InvalidAddress => e
  raise_invalid_error!(e.message)
end

# File 'lib/mongo/uri.rb', line 468

def parse_database!(string)
  raise_invalid_error!(UNESCAPED_DATABASE) if string =~ UNSAFE
  decode(string) if string.length > 0
end

# File 'lib/mongo/uri.rb', line 455

def parse_password!(string)
  if (string && pwd = string.partition(AUTH_USER_PWD_DELIM)[2])
    if pwd.length > 0
      raise_invalid_error!(UNESCAPED_USER_PWD) if pwd =~ UNSAFE
      pwd_decoded = decode(pwd)
      if pwd_decoded =~ PERCENT_CHAR && encode(pwd_decoded) != pwd
        raise_invalid_error!(UNESCAPED_USER_PWD)
      end
      pwd_decoded
    end
  end
end

# File 'lib/mongo/uri.rb', line 424

def parse_uri_options!(string)
  uri_options = {}
  unless string
    return uri_options
  end
  string.split('&').each do |option_str|
    if option_str.empty?
      next
    end
    key, value = option_str.split('=', 2)
    if value.nil?
      raise_invalid_error!("Option #{key} has no value")
    end
    key = decode(key)
    value = decode(value)
    options_mapper.add_uri_option(key, value, uri_options)
  end
  uri_options
end

# File 'lib/mongo/uri.rb', line 444

def parse_user!(string)
  if (string && user = string.partition(AUTH_USER_PWD_DELIM)[0])
    raise_invalid_error!(UNESCAPED_USER_PWD) if user =~ UNSAFE
    user_decoded = decode(user)
    if user_decoded =~ PERCENT_CHAR && encode(user_decoded) != user
      raise_invalid_error!(UNESCAPED_USER_PWD)
    end
    user_decoded
  end
end

# File 'lib/mongo/uri.rb', line 473

def raise_invalid_error!(details)
  raise Error::InvalidURI.new(@string, details, FORMAT)
end

# File 'lib/mongo/uri.rb', line 477

def raise_invalid_error_no_fmt!(details)
  raise Error::InvalidURI.new(@string, details)
end

# File 'lib/mongo/uri.rb', line 347

def reconstruct_uri
  servers = @servers.join(',')
  options = options_mapper.ruby_to_string(@uri_options).map do |k, vs|
    unless vs.nil?
      if vs.is_a?(Array)
        vs.map { |v| "#{k}=#{v}" }.join('&')
      else
        "#{k}=#{vs}"
      end
    end
  end.compact.join('&')

  uri = "#{scheme}#{SCHEME_DELIM}"
  uri += @user.to_s if @user
  uri += "#{AUTH_USER_PWD_DELIM}#{@password}" if @password
  uri += "@" if @user || @password
  uri += @query_hostname || servers
  uri += "/" if @database || !options.empty?
  uri += @database.to_s if @database
  uri += "?#{options}" unless options.empty?
  uri
end

# File 'lib/mongo/uri.rb', line 370

def scheme
  MONGODB_SCHEME
end

# File 'lib/mongo/uri.rb', line 267

def srv_records
  nil
end

# File 'lib/mongo/uri.rb', line 337

def to_s
  reconstruct_uri
end

# File 'lib/mongo/uri.rb', line 489

def validate_uri_options!
  # The URI options spec requires that we raise an error if there are conflicting values of
  # 'tls' and 'ssl'. In order to fulfill this, we parse the values of each instance into an
  # array; assuming all values in the array are the same, we replace the array with that value.
  unless uri_options[:ssl].nil? || uri_options[:ssl].empty?
    unless uri_options[:ssl].uniq.length == 1
      raise_invalid_error_no_fmt!("all instances of 'tls' and 'ssl' must have the same value")
    end

    uri_options[:ssl] = uri_options[:ssl].first
  end

  # Check for conflicting TLS insecure options.
  unless uri_options[:ssl_verify].nil?
    unless uri_options[:ssl_verify_certificate].nil?
      raise_invalid_error_no_fmt!("'tlsInsecure' and 'tlsAllowInvalidCertificates' cannot both be specified")
    end

    unless uri_options[:ssl_verify_hostname].nil?
      raise_invalid_error_no_fmt!("tlsInsecure' and 'tlsAllowInvalidHostnames' cannot both be specified")
    end

    unless uri_options[:ssl_verify_ocsp_endpoint].nil?
      raise_invalid_error_no_fmt!("tlsInsecure' and 'tlsDisableOCSPEndpointCheck' cannot both be specified")
    end
  end

  unless uri_options[:ssl_verify_certificate].nil?
    unless uri_options[:ssl_verify_ocsp_endpoint].nil?
      raise_invalid_error_no_fmt!("tlsAllowInvalidCertificates' and 'tlsDisableOCSPEndpointCheck' cannot both be specified")
    end
  end

  # Since we know that the only URI option that sets :ssl_cert is
  # "tlsCertificateKeyFile", any value set for :ssl_cert must also be set
  # for :ssl_key.
  if uri_options[:ssl_cert]
    uri_options[:ssl_key] = uri_options[:ssl_cert]
  end

  if uri_options[:write_concern] && !uri_options[:write_concern].empty?
    begin
      WriteConcern.get(uri_options[:write_concern])
    rescue Error::InvalidWriteConcern => e
      raise_invalid_error_no_fmt!("#{e.class}: #{e}")
    end
  end

  if uri_options[:direct_connection]
    if uri_options[:connect] && uri_options[:connect].to_s != 'direct'
      raise_invalid_error_no_fmt!("directConnection=true cannot be used with connect=#{uri_options[:connect]}")
    end
    if servers.length > 1
      raise_invalid_error_no_fmt!("directConnection=true cannot be used with multiple seeds")
    end
  elsif uri_options[:direct_connection] == false && uri_options[:connect].to_s == 'direct'
    raise_invalid_error_no_fmt!("directConnection=false cannot be used with connect=direct")
  end

  if uri_options[:load_balanced]
    if servers.length > 1
      raise_invalid_error_no_fmt!("loadBalanced=true cannot be used with multiple seeds")
    end

    if uri_options[:direct_connection]
      raise_invalid_error_no_fmt!("directConnection=true cannot be used with loadBalanced=true")
    end

    if uri_options[:connect] && uri_options[:connect].to_sym == :direct
      raise_invalid_error_no_fmt!("connect=direct cannot be used with loadBalanced=true")
    end

    if uri_options[:replica_set]
      raise_invalid_error_no_fmt!("loadBalanced=true cannot be used with replicaSet option")
    end
  end

  unless self.is_a?(URI::SRVProtocol)
    if uri_options[:srv_max_hosts]
      raise_invalid_error_no_fmt!("srvMaxHosts cannot be used on non-SRV URI")
    end

    if uri_options[:srv_service_name]
      raise_invalid_error_no_fmt!("srvServiceName cannot be used on non-SRV URI")
    end
  end

  if uri_options[:srv_max_hosts] && uri_options[:srv_max_hosts] > 0
    if uri_options[:replica_set]
      raise_invalid_error_no_fmt!("srvMaxHosts > 0 cannot be used with replicaSet option")
    end

    if options[:load_balanced]
      raise_invalid_error_no_fmt!("srvMaxHosts > 0 cannot be used with loadBalanced=true")
    end
  end
end