modul Net

Constants

HTTPGatewayTimeOut

Response-Klasse für Antworten vom Typ Gateway Timeout (Statuscode 504).

Der Server fungierte als Gateway oder Proxy und erhielt keine zeitnahe Antwort vom Upstream-Server.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPMovedTemporarily

Response-Klasse für Antworten vom Typ Found (Statuscode 302).

Die Antwort Found zeigt an, dass der Client eine andere URL suchen (durchsuchen) soll.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPMultipleChoice

Response-Klasse für Antworten vom Typ Multiple Choices (Statuscode 300).

Die Antwort Multiple Choices zeigt an, dass der Server mehrere Optionen für die Ressource anbietet, aus denen der Client wählen kann.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPRequestEntityTooLarge

Response-Klasse für Antworten vom Typ Payload Too Large (Statuscode 413).

Die Anfrage ist größer als der Server verarbeiten möchte oder kann.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPRequestTimeOut

Response-Klasse für Antworten vom Typ Request Timeout (Statuscode 408).

Der Server hat beim Warten auf die Anfrage ein Timeout erreicht.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPRequestURITooLarge

Response-Klasse für Antworten vom Typ URI Too Long (Statuscode 414).

Die bereitgestellte URI war für den Server zu lang, um sie zu verarbeiten.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPRequestURITooLong

Response-Klasse für Antworten vom Typ URI Too Long (Statuscode 414).

Die bereitgestellte URI war für den Server zu lang, um sie zu verarbeiten.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPRequestedRangeNotSatisfiable

Response-Klasse für Antworten vom Typ Range Not Satisfiable (Statuscode 416).

Die Anfrage hat einen Medientyp, der vom Server oder der Ressource nicht unterstützt wird.

Diese Klasse enthält auch (indirekt) das Modul Net::HTTPHeader, das Zugriff auf seine Methoden zum Abrufen von Headern bietet.

Referenzen

HTTPSession

Die Klasse Net::HTTP bietet eine umfangreiche Bibliothek, die den Client in einem Client-Server-Modell implementiert, das das HTTP-Anfrage-Antwort-Protokoll verwendet. Informationen zu HTTP finden Sie unter

Über die Beispiele

Die hier angenommenen Codebeispiele erfordern, dass net/http geladen wurde (was auch uri lädt)

require 'net/http'

Viele Codebeispiele hier verwenden diese Beispiel-Websites

Einige Beispiele gehen auch von diesen Variablen aus

uri = URI('https://jsonplaceholder.typicode.com/')
uri.freeze # Examples may not modify.
hostname = uri.hostname # => "jsonplaceholder.typicode.com"
path = uri.path         # => "/"
port = uri.port         # => 443

So dass Beispielanfragen geschrieben werden können als

Net::HTTP.get(uri)
Net::HTTP.get(hostname, '/index.html')
Net::HTTP.start(hostname) do |http|
  http.get('/todos/1')
  http.get('/todos/2')
end

Ein Beispiel, das eine modifizierte URI benötigt, dupliziert zuerst uri und modifiziert dann die Kopie

_uri = uri.dup
_uri.path = '/todos/1'

Strategien

Wenn Sie nur wenige GET-Anfragen stellen möchten, sollten Sie OpenURI verwenden.

Wenn Sie nur wenige Anfragen aller Art stellen möchten, sollten Sie die verschiedenen Singleton-Komfortmethoden dieser Klasse verwenden. Jede der folgenden Methoden startet und beendet automatisch eine Sitzung, die eine einzelne Anfrage sendet.

# Return string response body.
Net::HTTP.get(hostname, path)
Net::HTTP.get(uri)

# Write string response body to $stdout.
Net::HTTP.get_print(hostname, path)
Net::HTTP.get_print(uri)

# Return response as Net::HTTPResponse object.
Net::HTTP.get_response(hostname, path)
Net::HTTP.get_response(uri)
data = '{"title": "foo", "body": "bar", "userId": 1}'
Net::HTTP.post(uri, data)
params = {title: 'foo', body: 'bar', userId: 1}
Net::HTTP.post_form(uri, params)
data = '{"title": "foo", "body": "bar", "userId": 1}'
Net::HTTP.put(uri, data)

Wenn die Leistung wichtig ist, sollten Sie Sitzungen verwenden, die den Anfrage-Overhead reduzieren. Diese Sitzung unterstützt mehrere Anfragen für HTTP-Methoden und WebDAV-Methoden.

Net::HTTP.start(hostname) do |http|
  # Session started automatically before block execution.
  http.get(path)
  http.head(path)
  body = 'Some text'
  http.post(path, body)  # Can also have a block.
  http.put(path, body)
  http.delete(path)
  http.options(path)
  http.trace(path)
  http.patch(path, body) # Can also have a block.
  http.copy(path)
  http.lock(path, body)
  http.mkcol(path, body)
  http.move(path)
  http.propfind(path, body)
  http.proppatch(path, body)
  http.unlock(path, body)
  # Session finished automatically at block exit.
end

Die oben genannten Methoden sind Komfortmethoden, die mit ihren wenigen Argumenten eine minimale Kontrolle über die Anfragen ermöglichen. Für mehr Kontrolle sollten Sie Anfrageobjekte verwenden.

URIs

Im Internet ist eine URI (Uniform Resource Identifier) eine Zeichenkette, die eine bestimmte Ressource identifiziert. Sie besteht aus einigen oder allen der folgenden Teile: Schema, Hostname, Pfad, Query und Fragment; siehe URI-Syntax.

Ein Ruby URI::Generic-Objekt repräsentiert eine Internet-URI. Es bietet unter anderem die Methoden scheme, hostname, path, query und fragment.

Schemata

Eine Internet-URI hat ein Schema.

Die beiden in Net::HTTP unterstützten Schemata sind 'https' und 'http'.

uri.scheme                       # => "https"
URI('http://example.com').scheme # => "http"

Hostnamen

Ein Hostname identifiziert einen Server (Host), an den Anfragen gesendet werden können.

hostname = uri.hostname # => "jsonplaceholder.typicode.com"
Net::HTTP.start(hostname) do |http|
  # Some HTTP stuff.
end

Pfade

Ein Host-spezifischer Pfad identifiziert eine Ressource auf dem Host.

_uri = uri.dup
_uri.path = '/todos/1'
hostname = _uri.hostname
path = _uri.path
Net::HTTP.get(hostname, path)

Abfragen

Eine Host-spezifische Query fügt der URI Namens-/Wert-Paare hinzu.

_uri = uri.dup
params = {userId: 1, completed: false}
_uri.query = URI.encode_www_form(params)
_uri # => #<URI::HTTPS https://jsonplaceholder.typicode.com?userId=1&completed=false>
Net::HTTP.get(_uri)

Fragmente

Ein URI-Fragment hat in Net::HTTP keine Auswirkung; es werden dieselben Daten zurückgegeben, unabhängig davon, ob ein Fragment enthalten ist.

Anfrageheader

Anfrage-Header können verwendet werden, um dem Host zusätzliche Informationen zu übermitteln, ähnlich wie Argumente bei einem Methodenaufruf; jeder Header ist ein Namens-/Wert-Paar.

Jede der Net::HTTP-Methoden, die eine Anfrage an den Host sendet, hat ein optionales Argument headers, wobei die Header als Hash von Feldnamen/Wert-Paaren ausgedrückt werden.

headers = {Accept: 'application/json', Connection: 'Keep-Alive'}
Net::HTTP.get(uri, headers)

Listen von Standard-Anfragefeldern und gebräuchlichen Anfragefeldern finden Sie unter Request Fields. Ein Host kann auch andere benutzerdefinierte Felder akzeptieren.

HTTP-Sitzungen

Eine Sitzung ist eine Verbindung zwischen einem Server (Host) und einem Client, die

durch die Instanzmethode Net::HTTP#start begonnen wird.
beliebige Anzahl von Anfragen enthalten kann.
durch die Instanzmethode Net::HTTP#finish beendet wird.

Beispiele für Sitzungen finden Sie unter Strategies.

Sitzung mit Net::HTTP.start

Wenn Sie viele Anfragen an einen einzelnen Host (und Port) stellen müssen, sollten Sie die Singleton-Methode Net::HTTP.start mit einem Block verwenden; die Methode verwaltet die Sitzung automatisch, indem sie

start vor der Ausführung des Blocks aufruft.
den Block ausführt.
finish nach der Ausführung des Blocks aufruft.

Im Block können Sie diese Instanzmethoden verwenden, von denen jede eine einzelne Anfrage sendet.

HTTP-Methoden:
- get, request_get: GET.
- head, request_head: HEAD.
- post, request_post: POST.
- delete: DELETE.
- options: OPTIONS.
- trace: TRACE.
- patch: PATCH.
WebDAV-Methoden:
- copy: COPY.
- lock: LOCK.
- mkcol: MKCOL.
- move: MOVE.
- propfind: PROPFIND.
- proppatch: PROPPATCH.
- unlock: UNLOCK.

Sitzung mit Net::HTTP.start und Net::HTTP.finish

Sie können eine Sitzung manuell mit den Methoden start und finish verwalten.

http = Net::HTTP.new(hostname)
http.start
http.get('/todos/1')
http.get('/todos/2')
http.delete('/posts/1')
http.finish # Needed to free resources.

Sitzung mit einer einzelnen Anfrage

Bestimmte Komfortmethoden verwalten eine Sitzung automatisch, indem sie

ein HTTP-Objekt erstellen.
eine Sitzung starten.
eine einzelne Anfrage senden.
die Sitzung beenden.
das Objekt zerstören.

Solche Methoden, die GET-Anfragen senden

::get: Gibt den String-Antwortkörper zurück.
::get_print: Schreibt den String-Antwortkörper nach $stdout.
::get_response: Gibt ein Net::HTTPResponse-Objekt zurück.

Solche Methoden, die POST-Anfragen senden

::post: Sendet Daten an den Host.
::post_form: Sendet Formulardaten an den Host.

HTTP-Anfragen und -Antworten

Viele der oben genannten Methoden sind Komfortmethoden, von denen jede eine Anfrage sendet und einen String zurückgibt, ohne direkt Net::HTTPRequest- und Net::HTTPResponse-Objekte zu verwenden.

Sie können jedoch direkt ein Anfrageobjekt erstellen, die Anfrage senden und das Antwortobjekt abrufen; siehe

Weiterleitung folgen

Jede zurückgegebene Antwort ist eine Instanz einer Unterklasse von Net::HTTPResponse. Sehen Sie die Antwortklassenhierarchie.

Insbesondere ist die Klasse Net::HTTPRedirection die übergeordnete Klasse aller Weiterleitungsklassen. Dies ermöglicht Ihnen, eine `case`-Anweisung zu erstellen, um Weiterleitungen ordnungsgemäß zu behandeln.

def fetch(uri, limit = 10)
  # You should choose a better exception.
  raise ArgumentError, 'Too many HTTP redirects' if limit == 0

  res = Net::HTTP.get_response(URI(uri))
  case res
  when Net::HTTPSuccess     # Any success class.
    res
  when Net::HTTPRedirection # Any redirection class.
    location = res['Location']
    warn "Redirected to #{location}"
    fetch(location, limit - 1)
  else                      # Any other class.
    res.value
  end
end

fetch(uri)

Grundlegende Authentifizierung

Die grundlegende Authentifizierung erfolgt gemäß RFC2617.

req = Net::HTTP::Get.new(uri)
req.basic_auth('user', 'pass')
res = Net::HTTP.start(hostname) do |http|
  http.request(req)
end

Streaming von Antwortkörpern

Standardmäßig liest Net::HTTP eine gesamte Antwort in den Speicher. Wenn Sie große Dateien verarbeiten oder eine Fortschrittsanzeige implementieren möchten, können Sie den Körper stattdessen direkt an eine IO streamen.

Net::HTTP.start(hostname) do |http|
  req = Net::HTTP::Get.new(uri)
  http.request(req) do |res|
    open('t.tmp', 'w') do |f|
      res.read_body do |chunk|
        f.write chunk
      end
    end
  end
end

HTTPS

HTTPS wird für eine HTTP-Verbindung durch Net::HTTP#use_ssl= aktiviert.

Net::HTTP.start(hostname, :use_ssl => true) do |http|
  req = Net::HTTP::Get.new(uri)
  res = http.request(req)
end

Oder wenn Sie einfach nur eine GET-Anfrage stellen möchten, können Sie ein URI-Objekt übergeben, das eine HTTPS-URL hat. Net::HTTP schaltet die TLS-Verifizierung automatisch ein, wenn das URI-Objekt ein "https"-URI-Schema hat.

uri # => #<URI::HTTPS https://jsonplaceholder.typicode.com/>
Net::HTTP.get(uri)

Proxy-Server

Ein HTTP-Objekt kann einen Proxy-Server haben.

Sie können ein HTTP-Objekt mit einem Proxy-Server über die Methode Net::HTTP.new oder die Methode Net::HTTP.start erstellen.

Der Proxy kann entweder durch das Argument p_addr oder durch die Umgebungsvariable 'http_proxy' definiert werden.

Proxy mit Argument `p_addr` als String

Wenn das Argument p_addr ein Hostname als String ist, hat das zurückgegebene http den gegebenen Host als Proxy.

http = Net::HTTP.new(hostname, nil, 'proxy.example')
http.proxy?          # => true
http.proxy_from_env? # => false
http.proxy_address   # => "proxy.example"
# These use default values.
http.proxy_port      # => 80
http.proxy_user      # => nil
http.proxy_pass      # => nil

Der Port, Benutzername und das Passwort für den Proxy können ebenfalls angegeben werden.

http = Net::HTTP.new(hostname, nil, 'proxy.example', 8000, 'pname', 'ppass')
# => #<Net::HTTP jsonplaceholder.typicode.com:80 open=false>
http.proxy?          # => true
http.proxy_from_env? # => false
http.proxy_address   # => "proxy.example"
http.proxy_port      # => 8000
http.proxy_user      # => "pname"
http.proxy_pass      # => "ppass"

Proxy mit '`ENV['http_proxy']`'

Wenn die Umgebungsvariable 'http_proxy' auf eine URI-Zeichenkette gesetzt ist, hat das zurückgegebene http den Server unter dieser URI als seinen Proxy; beachten Sie, dass die URI-Zeichenkette ein Protokoll wie 'http' oder 'https' haben muss.

ENV['http_proxy'] = 'http://example.com'
http = Net::HTTP.new(hostname)
http.proxy?          # => true
http.proxy_from_env? # => true
http.proxy_address   # => "example.com"
# These use default values.
http.proxy_port      # => 80
http.proxy_user      # => nil
http.proxy_pass      # => nil

Die URI-Zeichenkette kann Proxy-Benutzernamen, -Passwort und -Portnummer enthalten.

ENV['http_proxy'] = 'http://pname:ppass@example.com:8000'
http = Net::HTTP.new(hostname)
http.proxy?          # => true
http.proxy_from_env? # => true
http.proxy_address   # => "example.com"
http.proxy_port      # => 8000
http.proxy_user      # => "pname"
http.proxy_pass      # => "ppass"

Proxy-Filterung

Mit der Methode Net::HTTP.new (aber nicht mit Net::HTTP.start) können Sie das Argument p_no_proxy verwenden, um Proxys zu filtern.

eine bestimmte Adresse ablehnen.

http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'proxy.example')
http.proxy_address # => nil

bestimmte Domänen oder Unterdomänen ablehnen.

http = Net::HTTP.new('example.com', nil, 'my.proxy.example', 8000, 'pname', 'ppass', 'proxy.example')
http.proxy_address # => nil

bestimmte Adressen und Portkombinationen ablehnen.

http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'proxy.example:1234')
http.proxy_address # => "proxy.example"

http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'proxy.example:8000')
http.proxy_address # => nil

eine Liste der oben genannten Typen ablehnen, die durch ein Komma getrennt ist.

http = Net::HTTP.new('example.com', nil, 'proxy.example', 8000, 'pname', 'ppass', 'my.proxy,proxy.example:8000')
http.proxy_address # => nil

http = Net::HTTP.new('example.com', nil, 'my.proxy', 8000, 'pname', 'ppass', 'my.proxy,proxy.example:8000')
http.proxy_address # => nil

Kompression und Dekompression

Net::HTTP komprimiert den Körper einer Anfrage vor dem Senden nicht.

Standardmäßig fügt Net::HTTP den Header 'Accept-Encoding' zu einem neuen Anfrageobjekt hinzu.

Net::HTTP::Get.new(uri)['Accept-Encoding']
# => "gzip;q=1.0,deflate;q=0.6,identity;q=0.3"

Dies fordert den Server auf, den Antwortkörper zu zippen, falls vorhanden; der Server ist nicht verpflichtet, dies zu tun.

Net::HTTP dekomprimiert einen Antwortkörper nicht automatisch, wenn die Antwort den Header 'Content-Range' hat.

Andernfalls hängt die Dekompression (oder nicht) vom Wert des Headers Content-Encoding ab.

'deflate', 'gzip' oder 'x-gzip': dekomprimiert den Körper und löscht den Header.
'none' oder 'identity': dekomprimiert den Körper nicht, löscht aber den Header.
Jeder andere Wert: belässt den Körper und den Header unverändert.

Was gibt es hier

Zuerst, was ist woanders. Klasse Net::HTTP

Erbt von Klasse Object.

Dies ist eine kategorisierte Zusammenfassung von Methoden und Attributen.

Net::HTTP-Objekte

::new: Erstellt eine neue Instanz.
#inspect: Gibt eine String-Repräsentation von self zurück.

Sitzungen

::start: Beginnt eine neue Sitzung in einem neuen Net::HTTP-Objekt.
#started?: Gibt zurück, ob eine Sitzung aktiv ist.
#finish: Beendet eine aktive Sitzung.
#start: Beginnt eine neue Sitzung in einem bestehenden Net::HTTP-Objekt (self).

Verbindungen

:continue_timeout: Gibt das Continue-Timeout zurück.
#continue_timeout=: Legt die Continue-Timeout-Sekunden fest.
:keep_alive_timeout: Gibt das Keep-Alive-Timeout zurück.
:keep_alive_timeout=: Legt das Keep-Alive-Timeout fest.
:max_retries: Gibt die maximale Anzahl von Wiederholungsversuchen zurück.
#max_retries=: Legt die maximale Anzahl von Wiederholungsversuchen fest.
:open_timeout: Gibt das Öffnungs-Timeout zurück.
:open_timeout=: Legt das Öffnungs-Timeout fest.
:read_timeout: Gibt das Lese-Timeout zurück.
:read_timeout=: Legt das Lese-Timeout fest.
:ssl_timeout: Gibt das SSL-Timeout zurück.
:ssl_timeout=: Legt das SSL-Timeout fest.
:write_timeout: Gibt das Schreib-Timeout zurück.
write_timeout=: Legt das Schreib-Timeout fest.

Anfragen

::get: Sendet eine GET-Anfrage und gibt den String-Antwortkörper zurück.
::get_print: Sendet eine GET-Anfrage und schreibt den String-Antwortkörper nach $stdout.
::get_response: Sendet eine GET-Anfrage und gibt ein Antwortobjekt zurück.
::post_form: Sendet eine POST-Anfrage mit Formulardaten und gibt ein Antwortobjekt zurück.
::post: Sendet eine POST-Anfrage mit Daten und gibt ein Antwortobjekt zurück.
::put: Sendet eine PUT-Anfrage mit Daten und gibt ein Antwortobjekt zurück.
#copy: Sendet eine COPY-Anfrage und gibt ein Antwortobjekt zurück.
#delete: Sendet eine DELETE-Anfrage und gibt ein Antwortobjekt zurück.
#get: Sendet eine GET-Anfrage und gibt ein Antwortobjekt zurück.
#head: Sendet eine HEAD-Anfrage und gibt ein Antwortobjekt zurück.
#lock: Sendet eine LOCK-Anfrage und gibt ein Antwortobjekt zurück.
#mkcol: Sendet eine MKCOL-Anfrage und gibt ein Antwortobjekt zurück.
#move: Sendet eine MOVE-Anfrage und gibt ein Antwortobjekt zurück.
#options: Sendet eine OPTIONS-Anfrage und gibt ein Antwortobjekt zurück.
#patch: Sendet eine PATCH-Anfrage und gibt ein Antwortobjekt zurück.
#post: Sendet eine POST-Anfrage und gibt ein Antwortobjekt zurück.
#propfind: Sendet eine PROPFIND-Anfrage und gibt ein Antwortobjekt zurück.
#proppatch: Sendet eine PROPPATCH-Anfrage und gibt ein Antwortobjekt zurück.
#put: Sendet eine PUT-Anfrage und gibt ein Antwortobjekt zurück.
#request: Sendet eine Anfrage und gibt ein Antwortobjekt zurück.
#request_get: Sendet eine GET-Anfrage und erstellt ein Antwortobjekt; wenn ein Block gegeben ist, ruft er den Block mit dem Objekt auf, andernfalls gibt er das Objekt zurück.
#request_head: Sendet eine HEAD-Anfrage und erstellt ein Antwortobjekt; wenn ein Block gegeben ist, ruft er den Block mit dem Objekt auf, andernfalls gibt er das Objekt zurück.
#request_post: Sendet eine POST-Anfrage und erstellt ein Antwortobjekt; wenn ein Block gegeben ist, ruft er den Block mit dem Objekt auf, andernfalls gibt er das Objekt zurück.
#send_request: Sendet eine Anfrage und gibt ein Antwortobjekt zurück.
#trace: Sendet eine TRACE-Anfrage und gibt ein Antwortobjekt zurück.
#unlock: Sendet eine UNLOCK-Anfrage und gibt ein Antwortobjekt zurück.

Antworten

:close_on_empty_response: Gibt zurück, ob die Verbindung bei einer leeren Antwort geschlossen werden soll.
:close_on_empty_response=: Legt fest, ob die Verbindung bei einer leeren Antwort geschlossen werden soll.
:ignore_eof: Gibt zurück, ob das Ende der Datei beim Lesen eines Antwortkörpers mit Content-Length-Headern ignoriert werden soll.
:ignore_eof=: Legt fest, ob das Ende der Datei beim Lesen eines Antwortkörpers mit Content-Length-Headern ignoriert werden soll.
:response_body_encoding: Gibt die für den Antwortkörper zu verwendende Kodierung zurück.
#response_body_encoding=: Legt die Kodierung des Antwortkörpers fest.

Proxys

:proxy_address: Gibt die Proxy-Adresse zurück.
:proxy_address=: Legt die Proxy-Adresse fest.
::proxy_class?: Gibt zurück, ob self eine Proxy-Klasse ist.
#proxy?: Gibt zurück, ob self einen Proxy hat.
#proxy_address: Gibt die Proxy-Adresse zurück.
#proxy_from_env?: Gibt zurück, ob der Proxy aus einer Umgebungsvariable übernommen wird.
:proxy_from_env=: Legt fest, ob der Proxy aus einer Umgebungsvariable übernommen werden soll.
:proxy_pass: Gibt das Proxy-Passwort zurück.
:proxy_pass=: Legt das Proxy-Passwort fest.
:proxy_port: Gibt den Proxy-Port zurück.
:proxy_port=: Legt den Proxy-Port fest.
#proxy_user: Gibt den Proxy-Benutzernamen zurück.
:proxy_user=: Legt den Proxy-Benutzer fest.

Security

:ca_file: Gibt den Pfad zu einer CA-Zertifikatsdatei zurück.
:ca_file=: Legt den Pfad zu einer CA-Zertifikatsdatei fest.
:ca_path: Gibt den Pfad zu einem CA-Verzeichnis zurück, das Zertifikatsdateien enthält.
:ca_path=: Legt den Pfad zu einem CA-Verzeichnis fest, das Zertifikatsdateien enthält.
:cert: Gibt das OpenSSL::X509::Certificate-Objekt zurück, das für die Client-Zertifizierung verwendet werden soll.
:cert=: Legt das OpenSSL::X509::Certificate-Objekt fest, das für die Client-Zertifizierung verwendet werden soll.
:cert_store: Gibt den X509::Store zurück, der zur Überprüfung des Peer-Zertifikats verwendet werden soll.
:cert_store=: Legt den X509::Store fest, der zur Überprüfung des Peer-Zertifikats verwendet werden soll.
:ciphers: Gibt die verfügbaren SSL-Chiffren zurück.
:ciphers=: Legt die verfügbaren SSL-Chiffren fest.
:extra_chain_cert: Gibt die zusätzlichen X509-Zertifikate zurück, die der Zertifikatskette hinzugefügt werden sollen.
:extra_chain_cert=: Legt die zusätzlichen X509-Zertifikate fest, die der Zertifikatskette hinzugefügt werden sollen.
:key: Gibt das OpenSSL::PKey::RSA- oder OpenSSL::PKey::DSA-Objekt zurück.
:key=: Legt das OpenSSL::PKey::RSA- oder OpenSSL::PKey::DSA-Objekt fest.
:max_version: Gibt die maximale SSL-Version zurück.
:max_version=: Legt die maximale SSL-Version fest.
:min_version: Gibt die minimale SSL-Version zurück.
:min_version=: Legt die minimale SSL-Version fest.
#peer_cert: Gibt die X509-Zertifikatskette des Socket-Peers der Sitzung zurück.
:ssl_version: Gibt die SSL-Version zurück.
:ssl_version=: Legt die SSL-Version fest.
#use_ssl=: Legt fest, ob eine neue Sitzung Transport Layer Security (TLS) verwenden soll.
#use_ssl?: Gibt zurück, ob self SSL verwendet.
:verify_callback: Gibt den Callback für die Serverzertifikatsprüfung zurück.
:verify_callback=: Legt den Callback für die Serverzertifikatsprüfung fest.
:verify_depth: Gibt die maximale Tiefe für die Zertifikatskettenprüfung zurück.
:verify_depth=: Legt die maximale Tiefe für die Zertifikatskettenprüfung fest.
:verify_hostname: Gibt die Flags für die Serverzertifikatsprüfung am Anfang der SSL/TLS-Sitzung zurück.
:verify_hostname=: Legt die Flags für die Serverzertifikatsprüfung am Anfang der SSL/TLS-Sitzung fest.
:verify_mode: Gibt die Flags für die Serverzertifikatsprüfung am Anfang der SSL/TLS-Sitzung zurück.
:verify_mode=: Legt die Flags für die Serverzertifikatsprüfung am Anfang der SSL/TLS-Sitzung fest.

Adressen und Ports

:address: Gibt den Hostnamen oder die Host-IP als String zurück.
::default_port: Gibt die Ganzzahl 80 zurück, den Standardport für HTTP-Anfragen.
::http_default_port: Gibt die Ganzzahl 80 zurück, den Standardport für HTTP-Anfragen.
::https_default_port: Gibt die Ganzzahl 443 zurück, den Standardport für HTTPS-Anfragen.
#ipaddr: Gibt die IP-Adresse für die Verbindung zurück.
#ipaddr=: Legt die IP-Adresse für die Verbindung fest.
:local_host: Gibt den lokalen Hostnamen als String zurück, der zum Herstellen der Verbindung verwendet wird.
:local_host=: Legt den lokalen Hostnamen als String fest, der zum Herstellen der Verbindung verwendet wird.
:local_port: Gibt den lokalen Port als Ganzzahl zurück, der zum Herstellen der Verbindung verwendet wird.
:local_port=: Legt den lokalen Port als Ganzzahl fest, der zum Herstellen der Verbindung verwendet wird.
:port: Gibt die Portnummer als Ganzzahl zurück.

HTTP-Version

::version_1_2? (alias für ::version_1_2): Gibt true zurück; beibehalten aus Kompatibilitätsgründen.

Debugging

#set_debug_output: Legt den Ausgabestream für Debugging fest.