core.sock_js
index

# Copyright 2011 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

 
Modules
       
core

 
Classes
       
__builtin__.object
SockJSServer
core.streams.ReadStream(__builtin__.object)
SockJSSocket(core.streams.ReadStream, core.streams.WriteStream)
core.streams.WriteStream(__builtin__.object)
SockJSSocket(core.streams.ReadStream, core.streams.WriteStream)
org.vertx.java.core.Handler(java.lang.Object)
org.python.proxies.core.sock_js$SockJSSocketHandler$17(org.vertx.java.core.Handler, java.lang.Object)
SockJSSocketHandler

 
class SockJSServer(__builtin__.object)
    This is an implementation of the server side part of https://github.com/sockjs
 
SockJS enables browsers to communicate with the server using a simple WebSocket-like api for sending
and receiving messages. Under the bonnet SockJS chooses to use one of several protocols depending on browser
capabilities and what apppears to be working across the network.
 
Available protocols include:
 
WebSockets
xhr-polling
xhr-streaming
json-polling
event-source
html-file
 
This means, it should just work irrespective of what browser is being used, and whether there are nasty
things like proxies and load balancers between the client and the server.
 
For more detailed information on SockJS, see their website.
 
On the server side, you interact using instances of SockJSSocket - this allows you to send data to the
client or receive data via the ReadStream data_handler.
 
You can register multiple applications with the same SockJSServer, each using different path prefixes, each
application will have its own handler, and configuration is described in a Hash.
 
  Methods defined here:
__init__(self, http_server)
bridge(self, config, inbound_permitted, outbound_permitted, auth_timeout=300000, auth_address=None)
install_app(self, config, handler)
Install an application
 
Keyword arguments:
@param config: Configuration for the application
@param proc: Proc representing the handler
@param handler: Handler to call when a new SockJSSocket is created

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class SockJSSocket(core.streams.ReadStream, core.streams.WriteStream)
    You interact with SockJS clients through instances of SockJS socket.
The API is very similar to WebSocket. It implements both
ReadStream and WriteStream so it can be used with Pump to enable
flow control.
 
 
Method resolution order:
SockJSSocket
core.streams.ReadStream
core.streams.WriteStream
__builtin__.object

Methods defined here:
__init__(self, java_sock)
close(self)
Close the socket
handler_id(self)
When a SockJSSocket is created it automatically registers an event handler with the system, the ID of that
handler is given by handler_id.
Given this ID, a different event loop can send a buffer to that event handler using the event bus. This
allows you to write data to other SockJSSockets which are owned by different event loops.

Methods inherited from core.streams.ReadStream:
data_handler(self, handler)
Set a data handler. As data is read, the handler will be called with the data.
 
Keyword arguments:
@param handler: The data handler
end_handler(self, handler)
Set an end handler on the stream. Once the stream has ended, and there is no more data to be read, this handler will be called.
 
Keyword arguments:
@param handler: The exception handler
exception_handler(self, handler)
Set an execption handler on the stream.
param [Block] hndlr. The exception handler
pause(self)
Pause the ReadStream. After calling this, the ReadStream will aim to send no more data to the
resume(self)
Resume reading. If the ReadStream has been paused, reading will recommence on it.

Data descriptors inherited from core.streams.ReadStream:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Methods inherited from core.streams.WriteStream:
drain_handler(self, handler)
Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write
queue has been reduced to maxSize / 2. See  for an example of this being used.
 
Keyword arguments:
@param handler: The drain handler
set_write_queue_max_size(self, size)
Set the maximum size of the write queue. You will still be able to write to the stream even
if there is more data than this in the write queue. This is used as an indicator by classes such as
to provide flow control.
 
Keyword arguments:
@param size: The maximum size, in bytes.
write_buffer(self, buff)
Write some data to the stream. The data is put on an internal write queue, and the write actually happens
asynchronously. To avoid running out of memory by putting too much on the write queue,
check the  method before writing. This is done automatically if using a .
param [Buffer]. The buffer to write.

Data descriptors inherited from core.streams.WriteStream:
write_queue_full
Is the write queue full?
 
return True if there are more bytes in the write queue than the max write queue size.
write_queue_max_size

 
class SockJSSocketHandler(org.python.proxies.core.sock_js$SockJSSocketHandler$17)
    SockJS Socket handler
 
 
Method resolution order:
SockJSSocketHandler
org.python.proxies.core.sock_js$SockJSSocketHandler$17
org.vertx.java.core.Handler
java.lang.Object
__builtin__.object

Methods defined here:
__init__(self, handler)
handle(self, sock)
Call the handler after SockJS Socket is ready

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__initProxy__ = <java function __initProxy__ 0xc0>
__supernames__ = array('java.lang.String', [u'clone', u'finalize'])
classDictInit = <java function classDictInit 0xc1>
clone = <java function clone 0xc2>
finalize = <java function finalize 0xc3>

Methods inherited from java.lang.Object:
__copy__(...)
__deepcopy__(...)
__eq__(...)
__hash__(...)
__ne__(...)
__repr__(...)
__unicode__(...)

Data and other attributes inherited from java.lang.Object:
equals = <java function equals 0xc4>
getClass = <java function getClass 0xc5>
hashCode = <java function hashCode 0xc6>
notify = <java function notify 0xc7>
notifyAll = <java function notifyAll 0xc8>
toString = <java function toString 0xc9>
wait = <java function wait 0xca>

 
Data
        __author__ = 'Scott Horn'
__credits__ = 'Based entirely on work by Tim Fox http://tfox.org'
__email__ = 'scott@hornmicro.com'
org = <java package org 0x2>

 
Author
        Scott Horn

 
Credits
        Based entirely on work by Tim Fox http://tfox.org