### Navigation

- index
- modules |
- gevent-socketio 0.3.1 documentation »

# `socketio.virtsocket`

Virtual Socket implementation, unifies all the Transports into one single interface, and abstracts the work of the long-polling methods.

This module also has the `default_error_handler` implementation. You can define your own so that the error messages are logged or sent in a different way

copyright: | 2012, Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>
moduleauthor: | Alexandre Bourget <alexandre.bourget@savoirfairelinux.com>

class `socketio.virtsocket.``Socket`(server, config, error_handler=None)

  Bases: `object`

  Virtual Socket implementation, checks heartbeats, writes to local queues for message passing, holds the Namespace objects, dispatches de packets to the underlying namespaces.

  This is the abstraction on top of the different transports. It’s like if you used a WebSocket only...

  `GLOBAL_NS` = ''

    Use this to be explicit when specifying a Global Namespace (an endpoint with no name, not ‘/chat’ or anything.

  `STATE_CONNECTED` = 'CONNECTED'
  `STATE_CONNECTING` = 'CONNECTING'
  `STATE_DISCONNECTED` = 'DISCONNECTED'
  `STATE_DISCONNECTING` = 'DISCONNECTING'
  `connected`

    Returns whether the state is CONNECTED or not.

  `detach`()

    Detach this socket from the server. This should be done in conjunction with kill(), once all the jobs are dead, detach the socket for garbage collection.

  `disconnect`(silent=False)

    Calling this method will call the `disconnect()` method on all the active Namespaces that were open, killing all their jobs and sending ‘disconnect’ packets for each of them.

    Normally, the Global namespace (endpoint = ‘’) has special meaning, as it represents the whole connection,

    Parameters: | silent – when True, pass on the `silent` flag to the Namespace `disconnect()` calls.

  `error`(error_name, error_message, endpoint=None, msg_id=None, quiet=False)

    Send an error to the user, using the custom or default ErrorHandler configured on the [TODO: Revise this] Socket/Handler object.

    Parameters:

    - error_name – is a simple string, for easy association on the client side
    - error_message – is a human readable message, the user will eventually see
    - endpoint – set this if you have a message specific to an end point
    - msg_id – set this if your error is relative to a specific message
    - quiet – way to make the error handler quiet. Specific to the handler. The default handler will only log, with quiet.

  `get_client_msg`(**kwargs)

    Grab a message to send it to the browser

  `get_multiple_client_msgs`(**kwargs)

    Get multiple messages, in case we’re going through the various XHR-polling methods, on which we can pack more than one message if the rate is high, and encode the payload for the HTTP channel.

  `get_server_msg`(**kwargs)

    Grab a message, to process it by the server and dispatch calls

  `heartbeat`()

    This makes the heart beat for another X seconds. Call this when you get a heartbeat packet in.

    This clear the heartbeat disconnect timeout (resets for X seconds).

  `incr_hits`()
  static `json_dumps`(data)
  static `json_loads`(data)
  `kill`(detach=False)

    This function must/will be called when a socket is to be completely shut down, closed by connection timeout, connection error or explicit disconnection from the client.

    It will call all of the Namespace’s `disconnect()` methods so that you can shut-down things properly.

  `put_client_msg`(msg)

    Writes to the client’s pipe, to end up in the browser

  `put_server_msg`(msg)

    Writes to the server’s pipe, to end up in in the Namespaces

  `remove_namespace`(namespace)

    This removes a Namespace object from the socket.

    This is usually called by `disconnect()`.

  `send_packet`(pkt)

    Low-level interface to queue a packet on the wire (encoded as wire protocol

  `spawn`(fn, *args, **kwargs)

    Spawn a new Greenlet, attached to this Socket instance.

    It will be monitored by the “watcher” method

`socketio.virtsocket.``default_error_handler`(socket, error_name, error_message, endpoint, msg_id, quiet)

  This is the default error handler, you can override this when calling `socketio.socketio_manage()`.

  It basically sends an event through the socket with the ‘error’ name.

  See documentation for `Socket.error()`.

  Parameters: | quiet – if quiet, this handler will not send a packet to the user, but only log for the server developer.

### Navigation

- index
- modules |
- gevent-socketio 0.3.1 documentation »