def _monitor(self, address, buffer_size, retry):
while True:
try:
self.status = CONNECTING
yield kaa.inprogress(self)
# Python 2.4 code
# TODO: remove all python 2.4 supporting code
self._connect_inprogress.result
self.status = CONNECTED
# wait until the socket is closed
yield self.signals.subset('closed').any()
except Exception, e:
# connection failed
pass
self._connect_inprogress = kaa.InProgress()
self.status = DISCONNECTED
# wait some time until we retry
yield kaa.delay(retry)
# reset variables
self._authenticated = False
self._pending_challenge = None
self._read_buffer = []
self.status = CONNECTING
self._socket = kaa.Socket(buffer_size)
self._socket.chunk_size = 1024
self._socket.signals['read'].connect(self._handle_read)
self._socket.signals['closed'].connect(self._handle_close)
self._socket.connect(address).exception.connect(
self._handle_refused)
def __init__(self, address, auth_secret='', buffer_size=None, retry=None):
super(Client, self).__init__(kaa.Socket(buffer_size), auth_secret)
self._socket.connect(address).exception.connect(self._handle_refused)
self.monitoring = False
if retry is not None:
self._monitor(address, buffer_size, retry)
self.monitoring = True
def __init__(self, address, auth_secret='', buffer_size=None):
super(Server, self).__init__()
self._auth_secret = py3_b(auth_secret)
self._socket = kaa.Socket(buffer_size=buffer_size)
self._socket.listen(address)
self._socket.signals['new-client'].connect_weak(self._new_connection)
self.objects = []
def __init__(self, rc):
"""
init the network event handler
"""
logger.debug('TCPNetwork.__init__()')
self.rc = rc
self.socket = kaa.Socket()
self.socket.signals['new-client'].connect(self.__accept)
self.socket.listen(
(config.REMOTE_CONTROL_TCP_HOST, config.REMOTE_CONTROL_TCP_PORT))
def connect(self, host):
self.host = host
self.socket = kaa.Socket()
self.socket.signals['read'].connect(self.__read)
yield self.socket.connect((host, 9982))
yield self.send('hello',
htspversion=5,
clientname='Freevo',
clientversion='2.0git')
self.send('enableAsyncMetadata', epg=1, async=False)
yield self.connected
def _connect(self):
"""
Connect to the server and init the connection.
"""
if self._connected:
yield False
self.socket = kaa.Socket()
try:
yield self.socket.connect((self._server, self._port))
except Exception, e:
# try again later
log.error('LCDproc connection error; will try again later')
kaa.OneShotTimer(self._connect).start(10)
yield False
def plugin_activate(self, level):
"""
Activate the plugin
"""
super(PluginInterface, self).plugin_activate(level)
self.httpserver = freevo.get_plugin('httpserver')
if not self.httpserver:
raise RuntimeError('httpserver plugin not running')
self.httpserver.server.add_json_handler('/jsonrpc', self.jsonrpc)
self.httpserver.server.add_handler('/image/', self.provide_image)
self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._sock.bind(('', freevo.config.plugin.jsonrpc.eventserver))
udp = kaa.Socket()
udp.wrap(self._sock, kaa.IO_READ | kaa.IO_WRITE)
udp.signals['read'].connect(eventserver.handle)
utils.imagedir = (yield kaa.beacon.get_db_info())['directory']
utils.cachedir = os.path.join(os.environ['HOME'], '.thumbnails')
self.api = {}
for module in ('VideoLibrary', 'Player', 'Playlist'):
for name in dir(eval(module)):
method = getattr(eval(module), name)
if callable(method) and not name.startswith('_'):
self.api[module + '.' + name] = method
import logging
import kaa
from kaa.net.tls import TLSSocket
log = logging.getLogger('tls').ensureRootHandler()
@kaa.coroutine()
def new_client(client):
ip, port = client.peer[:2]
print 'New connection from %s:%s' % (ip, port)
#yield client.starttls_server()
client.write('Hello %s, connecting from port %d\n' % (ip, port))
remote = TLSSocket()
yield remote.connect('www.google.com:443')
yield remote.starttls_client()
yield remote.write('GET / HTTP/1.0\n\n')
while remote.readable:
data = yield remote.read()
yield client.write(data)
client.write('\n\nBye!\n')
client.close()
server = kaa.Socket()
server.signals['new-client'].connect(new_client)
server.listen(8080)
print "Connect to localhost:8080"
kaa.main.run()
