Session

Soup session state object.

#SoupSession is the object that controls client-side HTTP. A #SoupSession encapsulates all of the state that libsoup is keeping on behalf of your program; cached HTTP connections, authentication information, etc. It also keeps track of various global options and features that you are using.

Most applications will only need a single #SoupSession; the primary reason you might need multiple sessions is if you need to have multiple independent authentication contexts. (Eg, you are connecting to a server and authenticating as two different users at different times; the easiest way to ensure that each class@Message is sent with the authentication information you intended is to use one session for the first user, and a second session for the other user.)

Additional #SoupSession functionality is provided by iface@SessionFeature objects, which can be added to a session with soup.session.Session.addFeature or soup.session.Session.addFeatureByType For example, class@Logger provides support for logging HTTP traffic, class@ContentDecoder provides support for compressed response handling, and class@ContentSniffer provides support for HTML5-style response body content sniffing. Additionally, subtypes of class@Auth can be added as features, to add support for additional authentication types.

All soup.session.Sessions are created with a class@AuthManager, and support for SOUP_TYPE_AUTH_BASIC and SOUP_TYPE_AUTH_DIGEST. Additionally, sessions using the plain #SoupSession class (rather than one of its deprecated subtypes) have a class@ContentDecoder by default.

Note that all async methods will invoke their callbacks on the thread-default context at the time of the function call.

class Session : ObjectG {

void abort();

void addFeature(soup.session_feature.SessionFeature feature);

void addFeatureByType(gobject.types.GType featureType);

string getAcceptLanguage();

bool getAcceptLanguageAuto();

soup.message.Message getAsyncResultMessage(gio.async_result.AsyncResult result);

soup.session_feature.SessionFeature getFeature(gobject.types.GType featureType);

soup.session_feature.SessionFeature getFeatureForMessage(gobject.types.GType featureType, soup.message.Message msg);

uint getIdleTimeout();

gio.inet_socket_address.InetSocketAddress getLocalAddress();

uint getMaxConns();

uint getMaxConnsPerHost();

gio.proxy_resolver.ProxyResolver getProxyResolver();

gio.socket_connectable.SocketConnectable getRemoteConnectable();

uint getTimeout();

gio.tls_database.TlsDatabase getTlsDatabase();

gio.tls_interaction.TlsInteraction getTlsInteraction();

string getUserAgent();

bool hasFeature(gobject.types.GType featureType);

void preconnectAsync(soup.message.Message msg, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback);

bool preconnectFinish(gio.async_result.AsyncResult result);

void removeFeature(soup.session_feature.SessionFeature feature);

void removeFeatureByType(gobject.types.GType featureType);

gio.input_stream.InputStream send(soup.message.Message msg, gio.cancellable.Cancellable cancellable);

glib.bytes.Bytes sendAndRead(soup.message.Message msg, gio.cancellable.Cancellable cancellable);

void sendAndReadAsync(soup.message.Message msg, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback);

glib.bytes.Bytes sendAndReadFinish(gio.async_result.AsyncResult result);

ptrdiff_t sendAndSplice(soup.message.Message msg, gio.output_stream.OutputStream outStream, gio.types.OutputStreamSpliceFlags flags, gio.cancellable.Cancellable cancellable);

void sendAndSpliceAsync(soup.message.Message msg, gio.output_stream.OutputStream outStream, gio.types.OutputStreamSpliceFlags flags, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback);

ptrdiff_t sendAndSpliceFinish(gio.async_result.AsyncResult result);

void sendAsync(soup.message.Message msg, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback);

gio.input_stream.InputStream sendFinish(gio.async_result.AsyncResult result);

void setAcceptLanguage(string acceptLanguage);

void setAcceptLanguageAuto(bool acceptLanguageAuto);

void setIdleTimeout(uint timeout);

void setProxyResolver(gio.proxy_resolver.ProxyResolver proxyResolver);

void setTimeout(uint timeout);

void setTlsDatabase(gio.tls_database.TlsDatabase tlsDatabase);

void setTlsInteraction(gio.tls_interaction.TlsInteraction tlsInteraction);

void setUserAgent(string userAgent);

void websocketConnectAsync(soup.message.Message msg, string origin, string[] protocols, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback);

soup.websocket_connection.WebsocketConnection websocketConnectFinish(gio.async_result.AsyncResult result);

ulong connectRequestQueued(T callback, Flag!"After" after);

ulong connectRequestUnqueued(T callback, Flag!"After" after);

}

Constructors

this this(): Creates a #SoupSession with the default options.

Members

Functions

abort void abort(): Cancels all pending requests in session and closes all idle persistent connections.
addFeature void addFeature(soup.session_feature.SessionFeature feature): Adds feature's functionality to session. You cannot add multiple features of the same aliasGLib.Type to a session.
addFeatureByType void addFeatureByType(gobject.types.GType featureType): If feature_type is the type of a class that implements ifaceSessionFeature, this creates a new feature of that type and adds it to session as with soup.session.Session.addFeature. You can use this when you don't need to customize the new feature in any way. Adding multiple features of the same feature_type is not allowed.
connectRequestQueued ulong connectRequestQueued(T callback, Flag!"After" after): Connect to RequestQueued signal.
connectRequestUnqueued ulong connectRequestUnqueued(T callback, Flag!"After" after): Connect to RequestUnqueued signal.
getAcceptLanguage string getAcceptLanguage(): Get the value used by session for the "Accept-Language" header on new requests.
getAcceptLanguageAuto bool getAcceptLanguageAuto(): Gets whether session automatically sets the "Accept-Language" header on new requests.
getAsyncResultMessage soup.message.Message getAsyncResultMessage(gio.async_result.AsyncResult result): Gets the classMessage of the result asynchronous operation This is useful to get the classMessage of an asynchronous operation started by session from its gio.types.AsyncReadyCallback.
getFeature soup.session_feature.SessionFeature getFeature(gobject.types.GType featureType): Gets the feature in session of type feature_type.
getFeatureForMessage soup.session_feature.SessionFeature getFeatureForMessage(gobject.types.GType featureType, soup.message.Message msg): Gets the feature in session of type feature_type, provided that it is not disabled for msg.
getIdleTimeout uint getIdleTimeout(): Get the timeout in seconds for idle connection lifetime currently used by session.
getLocalAddress gio.inet_socket_address.InetSocketAddress getLocalAddress(): Get the gio.inet_socket_address.InetSocketAddress to use for the client side of connections in session.
getMaxConns uint getMaxConns(): Get the maximum number of connections that session can open at once.
getMaxConnsPerHost uint getMaxConnsPerHost(): Get the maximum number of connections that session can open at once to a given host.
getProxyResolver gio.proxy_resolver.ProxyResolver getProxyResolver(): Get the gio.proxy_resolver.ProxyResolver currently used by session.
getRemoteConnectable gio.socket_connectable.SocketConnectable getRemoteConnectable(): Gets the remote connectable if one set.
getTimeout uint getTimeout(): Get the timeout in seconds for socket I/O operations currently used by session.
getTlsDatabase gio.tls_database.TlsDatabase getTlsDatabase(): Get the gio.tls_database.TlsDatabase currently used by session.
getTlsInteraction gio.tls_interaction.TlsInteraction getTlsInteraction(): Get the gio.tls_interaction.TlsInteraction currently used by session.
getUserAgent string getUserAgent(): Get the value used by session for the "User-Agent" header on new requests.
hasFeature bool hasFeature(gobject.types.GType featureType): Tests if session has at a feature of type feature_type (which can be the type of either a ifaceSessionFeature, or else a subtype of some class managed by another feature, such as classAuth).
preconnectAsync void preconnectAsync(soup.message.Message msg, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback): Start a preconnection to msg.
preconnectFinish bool preconnectFinish(gio.async_result.AsyncResult result): Complete a preconnect async operation started with soup.session.Session.preconnectAsync.
removeFeature void removeFeature(soup.session_feature.SessionFeature feature): Removes feature's functionality from session.
removeFeatureByType void removeFeatureByType(gobject.types.GType featureType): Removes all features of type feature_type (or any subclass of feature_type) from session.
send gio.input_stream.InputStream send(soup.message.Message msg, gio.cancellable.Cancellable cancellable): Synchronously sends msg and waits for the beginning of a response.
sendAndRead glib.bytes.Bytes sendAndRead(soup.message.Message msg, gio.cancellable.Cancellable cancellable): Synchronously sends msg and reads the response body.
sendAndReadAsync void sendAndReadAsync(soup.message.Message msg, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback): Asynchronously sends msg and reads the response body.
sendAndReadFinish glib.bytes.Bytes sendAndReadFinish(gio.async_result.AsyncResult result): Gets the response to a soup.session.Session.sendAndReadAsync.
sendAndSplice ptrdiff_t sendAndSplice(soup.message.Message msg, gio.output_stream.OutputStream outStream, gio.types.OutputStreamSpliceFlags flags, gio.cancellable.Cancellable cancellable): Synchronously sends msg and splices the response body stream into out_stream.
sendAndSpliceAsync void sendAndSpliceAsync(soup.message.Message msg, gio.output_stream.OutputStream outStream, gio.types.OutputStreamSpliceFlags flags, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback): Asynchronously sends msg and splices the response body stream into out_stream. When callback is called, then either msg has been sent and its response body spliced, or else an error has occurred.
sendAndSpliceFinish ptrdiff_t sendAndSpliceFinish(gio.async_result.AsyncResult result): Gets the response to a soup.session.Session.sendAndSpliceAsync.
sendAsync void sendAsync(soup.message.Message msg, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback): Asynchronously sends msg and waits for the beginning of a response.
sendFinish gio.input_stream.InputStream sendFinish(gio.async_result.AsyncResult result): Gets the response to a soup.session.Session.sendAsync call.
setAcceptLanguage void setAcceptLanguage(string acceptLanguage): Set the value to use for the "Accept-Language" header on classMessages sent from session.
setAcceptLanguageAuto void setAcceptLanguageAuto(bool acceptLanguageAuto): Set whether session will automatically set the "Accept-Language" header on requests using a value generated from system languages based on funcGLib.get_language_names.
setIdleTimeout void setIdleTimeout(uint timeout): Set a timeout in seconds for idle connection lifetime to be used by session on new connections.
setProxyResolver void setProxyResolver(gio.proxy_resolver.ProxyResolver proxyResolver): Set a gio.proxy_resolver.ProxyResolver to be used by session on new connections.
setTimeout void setTimeout(uint timeout): Set a timeout in seconds for socket I/O operations to be used by session on new connections.
setTlsDatabase void setTlsDatabase(gio.tls_database.TlsDatabase tlsDatabase): Set a classGIo.TlsDatabase to be used by session on new connections.
setTlsInteraction void setTlsInteraction(gio.tls_interaction.TlsInteraction tlsInteraction): Set a gio.tls_interaction.TlsInteraction to be used by session on new connections.
setUserAgent void setUserAgent(string userAgent): Set the value to use for the "User-Agent" header on classMessages sent from session.
websocketConnectAsync void websocketConnectAsync(soup.message.Message msg, string origin, string[] protocols, int ioPriority, gio.cancellable.Cancellable cancellable, gio.types.AsyncReadyCallback callback): Asynchronously creates a classWebsocketConnection to communicate with a remote server.
websocketConnectFinish soup.websocket_connection.WebsocketConnection websocketConnectFinish(gio.async_result.AsyncResult result): Gets the classWebsocketConnection response to a soup.session.Session.websocketConnectAsync call.

Inherited Members

From ObjectG

setGObject void setGObject(void* cObj, Flag!"Take" take): Set the GObject of a D ObjectG wrapper.
cPtr void* cPtr(Flag!"Dup" dup): Get a pointer to the underlying C object.
ref_ void* ref_(void* gObj): Calls g_object_ref() on a GObject.
unref unref(void* gObj): Calls g_object_unref() on a GObject.
getType GType getType(): Get the GType of an object.
gType GType gType [@property getter]: GObject GType property.
self ObjectG self(): Convenience method to return this cast to a type. For use in D with statements.
getDObject T getDObject(void* cptr, Flag!"Take" take): Template to get the D object from a C GObject and cast it to the given D object type.
connectSignalClosure ulong connectSignalClosure(string signalDetail, DClosure closure, Flag!"After" after): Connect a D closure to an object signal.
setProperty void setProperty(string propertyName, T val): Template for setting a GObject property.
getProperty T getProperty(string propertyName): Template for getting a GObject property.
compatControl size_t compatControl(size_t what, void* data)
bindProperty gobject.binding.Binding bindProperty(string sourceProperty, gobject.object.ObjectG target, string targetProperty, gobject.types.BindingFlags flags): Creates a binding between source_property on source and target_property on target.
bindPropertyFull gobject.binding.Binding bindPropertyFull(string sourceProperty, gobject.object.ObjectG target, string targetProperty, gobject.types.BindingFlags flags, gobject.closure.Closure transformTo, gobject.closure.Closure transformFrom): Creates a binding between source_property on source and target_property on target, allowing you to set the transformation functions to be used by the binding.
forceFloating void forceFloating(): This function is intended for #GObject implementations to re-enforce a floating[floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling gobject.object.ObjectG.refSink.
freezeNotify void freezeNotify(): Increases the freeze count on object. If the freeze count is non-zero, the emission of "notify" signals on object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one #GObject::notify signal is emitted for each property modified while the object is frozen.
getData void* getData(string key): Gets a named field from the objects table of associations (see gobject.object.ObjectG.setData).
getProperty void getProperty(string propertyName, gobject.value.Value value): Gets a property of an object.
getQdata void* getQdata(glib.types.Quark quark): This function gets back user data pointers stored via gobject.object.ObjectG.setQdata.
getv void getv(string[] names, gobject.value.Value[] values): Gets n_properties properties for an object. Obtained properties will be set to values. All properties must be valid. Warnings will be emitted and undefined behaviour may result if invalid properties are passed in.
isFloating bool isFloating(): Checks whether object has a floating[floating-ref] reference.
notify void notify(string propertyName): Emits a "notify" signal for the property property_name on object.
notifyByPspec void notifyByPspec(gobject.param_spec.ParamSpec pspec): Emits a "notify" signal for the property specified by pspec on object.
refSink gobject.object.ObjectG refSink(): Increase the reference count of object, and possibly remove the floating[floating-ref] reference, if object has a floating reference.
runDispose void runDispose(): Releases all references to other objects. This can be used to break reference cycles.
setData void setData(string key, void* data): Each object carries around a table of associations from strings to pointers. This function lets you set an association.
setProperty void setProperty(string propertyName, gobject.value.Value value): Sets a property on an object.
stealData void* stealData(string key): Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
stealQdata void* stealQdata(glib.types.Quark quark): This function gets back user data pointers stored via gobject.object.ObjectG.setQdata and removes the data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier, for example:
thawNotify void thawNotify(): Reverts the effect of a previous call to gobject.object.ObjectG.freezeNotify. The freeze count is decreased on object and when it reaches zero, queued "notify" signals are emitted.
watchClosure void watchClosure(gobject.closure.Closure closure): This function essentially limits the life time of the closure to the life time of the object. That is, when the object is finalized, the closure is invalidated by calling gobject.closure.Closure.invalidate on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, gobject.object.ObjectG.ref_ and gobject.object.ObjectG.unref are added as marshal guards to the closure, to ensure that an extra reference count is held on object during invocation of the closure. Usually, this function will be called on closures that use this object as closure data.
connectNotify ulong connectNotify(string detail, T callback, Flag!"After" after): Connect to Notify signal.

soup session classes

Session