GObject.Object
Soup.Session
Soup.SessionSync
Import line: | Soup = imports.gi.Soup; |
GIR File: | Soup-2.4.gir |
C documentation: | SoupSessionSync |
Class : | SessionSync |
Extends: | Soup.Session |
Show / Hide Inherited methods, properties and signals |
Properties | Defined By | |
---|---|---|
accept_language : String
|
Soup.Session | |
accept_language_auto : Boolean
|
Soup.Session | |
add_feature : Soup.SessionFeature
|
Soup.Session | |
add_feature_by_type : Number
|
Soup.Session | |
async_context : void*
|
Soup.Session | |
idle_timeout : Number
|
Soup.Session | |
max_conns : Number
|
Soup.Session | |
max_conns_per_host : Number
|
Soup.Session | |
parent : Soup.Session
read only
|
Soup.SessionSync | |
proxy_uri : Soup.URI
|
Soup.Session | |
remove_feature_by_type : Number
|
Soup.Session | |
ssl_ca_file : String
|
Soup.Session | |
ssl_strict : Boolean
|
Soup.Session | |
timeout : Number
|
Soup.Session | |
use_ntlm : Boolean
|
Soup.Session | |
user_agent : String
|
Soup.Session |
Method / Constructor | Defined By | |
---|---|---|
new Soup.SessionSync
(Object properties)
Create a new Soup.SessionSync
Create a new Soup.SessionSync
|
||
abort
()
:
none
Cancels all pending requests in session.
Cancels all pending requests in session.
|
Soup.Session | |
add_feature
(SessionFeature feature)
:
none
Adds feature's functionality to session.
Adds feature's functionality to session. You can also add a feature to the session at construct time by using the SOUP_SESSION_ADD_FEATURE property.
|
Soup.Session | |
add_feature_by_type
(Number feature_type)
:
none
Creates a new feature of type feature_type and adds it to the case wher you don't need to customize the new feature in any way.
Creates a new feature of type feature_type and adds it to the case wher you don't need to customize the new feature in any way. You can also add a feature to the session at construct time by using the SOUP_SESSION_ADD_FEATURE_BY_TYPE property.
|
Soup.Session | |
SOUP_STATUS_CANCELLED) Causes session to immediately finish processing msg (regardless of its current state) with a final status_code of status_code.
SOUP_STATUS_CANCELLED) Causes session to immediately finish processing msg (regardless of its current state) with a final status_code of status_code. You may call this at any time after handing msg off to session; if the complete response, then it will close the request's connection. Note that with non-idempotent requests (eg, POST, PUT, DELETE) it is possible that you might cancel the request after the server acts on it, but before it returns a response, leaving the remote resource in an unknown state. If the message is cancelled while its response body is being read, then the response body in msg will be left partially-filled-in. The response headers, on the other hand, will always be either empty or complete. For messages queued with soup_session_queue_message() (and cancelled from the same thread), the callback will be invoked before soup_session_cancel_message() returns.
|
Soup.Session | |
Soup.Session | ||
connection_failed
(Connection conn, Number status)
:
none
|
Soup.Session | |
get_async_context
()
:
GLib.MainContext
Gets session's async_context.
Gets session's async_context. This does not add a ref to the context, so you will need to ref it yourself if you want it to outlive its session.
|
Soup.Session | |
Tries to find or create a connection for item; this is an internal method for SoupSession subclasses.
Tries to find or create a connection for item; this is an internal method for SoupSession subclasses. If there is an idle connection to the relevant host available, then that connection will be returned. The connection will be set to SOUP_CONNECTION_IN_USE, so the caller must call soup_connection_set_state() to set it to SOUP_CONNECTION_IDLE if it ends up not using the connection right away. If there is no idle connection available, but it is possible to create a new connection, then one will be created and returned (with state SOUP_CONNECTION_NEW). The caller MUST then call soup_connection_connect_sync() or soup_connection_connect_async() to connect it. If the connection attempt fails, the caller must call soup_session_connection_failed() to tell the session to free the connection. If no connection is available and a new connection cannot be made, soup_session_get_connection() will return NULL. If session has the maximum number of open connections open, but does not have the maximum number of per-host connections open to the relevant host, then *try_pruning will be set to TRUE. In this case, the caller can call soup_session_try_prune_connection() to close an idle connection, and then try soup_session_get_connection() again. (If calling soup_session_try_prune_connection() wouldn't help, then *try_pruning is left untouched; it is NOT set to FALSE.)
|
Soup.Session | |
get_feature
(Number feature_type)
:
Soup.SessionFeature
Gets the first feature in session of type feature_type.
Gets the first feature in session of type feature_type. For features where there may be more than one feature of a given type, use soup_session_get_features(). by session.
|
Soup.Session | |
Gets the first feature in session of type feature_type, provided that it is not disabled for msg.
Gets the first feature in session of type feature_type, provided that it is not disabled for msg. As with soup_session_get_feature(), this should only be used for features where feature_type is only expected to match a single feature. In particular, if there are two matching features, and the first is disabled on msg, and the second is not, then this will return NULL, not the second feature. by session.
|
Soup.Session | |
Soup.Session | ||
get_queue
()
:
Soup.MessageQueue
|
Soup.Session | |
make_connect_message
(Address server_addr)
:
Soup.MessageQueueItem
|
Soup.Session | |
pause_message
(Message msg)
:
none
Pauses HTTP I/O on msg.
Pauses HTTP I/O on msg. Call soup_session_unpause_message() to resume I/O.
|
Soup.Session | |
prepare_for_uri
(URI uri)
:
none
|
Soup.Session | |
be called after the message completes or when an unrecoverable error occurs.
be called after the message completes or when an unrecoverable error occurs. Queues the message msg for sending. All messages are processed while the glib main loop runs. If msg has been processed before, any resources related to the time it was last sent are freed. Upon message completion, the callback specified in callback will be invoked (in the thread associated with session's async context). If after returning from this callback the message has not been requeued, msg will be unreffed.
|
Soup.Session | |
remove_feature
(SessionFeature feature)
:
none
Removes feature's functionality from session.
Removes feature's functionality from session.
|
Soup.Session | |
remove_feature_by_type
(Number feature_type)
:
none
Removes all features of type feature_type (or any subclass of from the session at construct time by using the SOUP_SESSION_REMOVE_FEATURE_BY_TYPE property.
Removes all features of type feature_type (or any subclass of from the session at construct time by using the SOUP_SESSION_REMOVE_FEATURE_BY_TYPE property.
|
Soup.Session | |
requeue_message
(Message msg)
:
none
This causes msg to be placed back on the queue to be attempted again.
This causes msg to be placed back on the queue to be attempted again.
|
Soup.Session | |
Synchronously send msg.
Synchronously send msg. This call will not return until the transfer is finished successfully or there is an unrecoverable error.
|
Soup.Session | |
send_queue_item
(MessageQueueItem item, Connection conn)
:
none
|
Soup.Session | |
unpause_message
(Message msg)
:
none
Resumes HTTP I/O on msg.
Resumes HTTP I/O on msg. Use this to resume after calling soup_session_pause_message(). If msg is being sent via blocking I/O, this will resume reading or writing immediately. If msg is using non-blocking I/O, then reading or writing won't resume until you return to the main loop.
|
Soup.Session |
Event | Defined By | |
---|---|---|
|
Soup.Session | |
|
Soup.Session | |
|
Soup.Session | |
|
Soup.Session | |
|
Soup.Session | |
|
Soup.Session |