def __init__(self, reactor):
QtGui.QLabel.__init__(self)
self.reactor = reactor
self.setAlignment(QtCore.Qt.AlignCenter)
self.setWindowIcon(QtGui.QIcon(':/images/cspace32.png'))
self.setWindowTitle('%s - VNC Server' % env.displayName)
self.setText('Connecting to CSpace...')
tcpConnect(('127.0.0.1', env.port), self.reactor,
self._onCSpaceConnect)
def __init__( self, reactor ) :
QtGui.QLabel.__init__( self )
self.reactor = reactor
self.setAlignment( QtCore.Qt.AlignCenter )
self.setWindowIcon( QtGui.QIcon(':/images/cspace32.png') )
self.setWindowTitle( '%s - VNC Server' % env.displayName )
self.setText( 'Connecting to CSpace...' )
tcpConnect( ('127.0.0.1',env.port), self.reactor,
self._onCSpaceConnect )
def __init__( self, reactor ) :
QWidget.__init__( self )
FlashWindow.__init__( self, reactor )
self.ui = Ui_FileReceiverWindow()
self.ui.setupUi( self )
self.reactor = reactor
self.setWindowTitle( env.displayName + ' - ' + str(self.windowTitle()) )
self.connect( self.ui.acceptButton, SIGNAL('clicked()'), self._onAcceptFiles )
self.connect( self.ui.cancelButton, SIGNAL('clicked()'), self.close )
tcpConnect( ('127.0.0.1',env.port), self.reactor, self._onConnect )
self._setStatus( 'Connecting to CSpace...' )
self.disconnected = False
def __init__(self, reactor):
QWidget.__init__(self)
FlashWindow.__init__(self, reactor)
self.ui = Ui_FileReceiverWindow()
self.ui.setupUi(self)
self.reactor = reactor
self.setWindowTitle(env.displayName + ' - ' + str(self.windowTitle()))
self.connect(self.ui.acceptButton, SIGNAL('clicked()'),
self._onAcceptFiles)
self.connect(self.ui.cancelButton, SIGNAL('clicked()'), self.close)
tcpConnect(('127.0.0.1', env.port), self.reactor, self._onConnect)
self._setStatus('Connecting to CSpace...')
self.disconnected = False
def __init__( self, reactor, callback=None ) :
assert env.isContactAction or env.isIncoming
self.reactor = reactor
self.op = AsyncOp( callback, self._doCancel )
self.state = self.CONNECTING
self.connectOp = tcpConnect( ('127.0.0.1',env.port), self.reactor, self._onConnect )
self.stream = None
def routerAccept( routerAddr, connectionId, reactor, callback=None ) :
obj = Dummy()
def doCancel() :
if obj.op : obj.op.cancel()
if obj.rpcConn : obj.rpcConn.close()
def onError() :
doCancel()
op.notify( None )
def onRouterAccept( err, result ) :
obj.op = None
if err < 0 :
onError()
return
sock = obj.rpcConn.getSock()
obj.rpcConn.shutdown()
op.notify( sock )
def onTCPConnect( connector ) :
obj.op = None
if connector.getError() != 0 :
onError()
return
obj.rpcConn = RPCConnection( connector.getSock(), reactor )
obj.rpcConn.setCloseCallback( onError )
obj.op = _doRPCCall( obj.rpcConn, 'Accept', [connectionId],
onRouterAccept )
obj.op = tcpConnect( routerAddr, reactor, onTCPConnect )
op = AsyncOp( callback, doCancel )
obj.rpcConn = None
return op
def connectTo(self, peerPubKey, callback=None):
assert self.state == self.INITIAL
self.connectCallback = callback
self.state = self.CONNECTING
self.peerPubKey = peerPubKey
self.connectOp = tcpConnect(('127.0.0.1', env.port), self.reactor,
self._onConnect)
def acceptConnection(self, connectionId, callback=None):
assert self.state == self.INITIAL
self.connectCallback = callback
self.state = self.ACCEPTING
self.connectionId = connectionId
self.connectOp = tcpConnect(('127.0.0.1', env.port), self.reactor,
self._onConnect)
def __init__(self, reactor, callback=None):
assert env.isContactAction or env.isIncoming
self.reactor = reactor
self.op = AsyncOp(callback, self._doCancel)
self.state = self.CONNECTING
self.connectOp = tcpConnect(('127.0.0.1', env.port), self.reactor,
self._onConnect)
self.stream = None
def _doConnect( self ) :
def onConnect( connector ) :
self.connectOp = None
if connector.getError() != 0 :
self._setError( 'Unable to connect to CSpace.' )
return
self._doConnectUser( connector.getSock() )
self.connectOp = tcpConnect( ('127.0.0.1',env.port), self.reactor, onConnect )
self._setStatus( 'Connecting to CSpace...' )
self.state = self.CONNECTINGCSPACE
def cspaceConnect( cspaceAddr, remoteUser, remoteService, reactor, callback ) :
def onTCPConnect( connector ) :
if connector.getError() != 0 :
op.notify( -1, None )
return
connectOp = CSpaceConnector( connector.getSock(), remoteUser,
remoteService, reactor, op.notify ).getOp()
op.setCanceler( connectOp.cancel )
tcpOp = tcpConnect( cspaceAddr, reactor, onTCPConnect )
op = AsyncOp( callback, tcpOp.cancel )
return op
def cspaceAccept( cspaceAddr, connectionId, reactor, callback ) :
def onTCPConnect( connector ) :
if connector.getError() != 0 :
op.notify( -1, None )
return
acceptOp = CSpaceAcceptor( connector.getSock(), connectionId,
reactor, op.notify ).getOp()
op.setCanceler( acceptOp.cancel )
tcpOp = tcpConnect( cspaceAddr, reactor, onTCPConnect )
op = AsyncOp( callback, tcpOp.cancel )
return op
def cspaceAccept(cspaceAddr, connectionId, reactor, callback):
def onTCPConnect(connector):
if connector.getError() != 0:
op.notify(-1, None)
return
acceptOp = CSpaceAcceptor(connector.getSock(), connectionId, reactor,
op.notify).getOp()
op.setCanceler(acceptOp.cancel)
tcpOp = tcpConnect(cspaceAddr, reactor, onTCPConnect)
op = AsyncOp(callback, tcpOp.cancel)
return op
def _directConnect( sslContext, remotePublicKey, directLocation,
reactor, callback=None ) :
def onConnect( connector ) :
if connector.getError() != 0 :
op.notify( None )
return
authOp = _authenticateUser( connector.getSock(), sslContext,
remotePublicKey, reactor, op.notify )
op.setCanceler( authOp.cancel )
connectOp = tcpConnect( directLocation.addr, reactor, onConnect )
op = AsyncOp( callback, connectOp.cancel )
return op
def _doConnect(self):
def onConnect(connector):
self.connectOp = None
if connector.getError() != 0:
self._setError('Unable to connect to CSpace.')
return
self._doConnectUser(connector.getSock())
self.connectOp = tcpConnect(('127.0.0.1', env.port), self.reactor,
onConnect)
self._setStatus('Connecting to CSpace...')
self.state = self.CONNECTINGCSPACE
def cspaceConnect(cspaceAddr, remoteUser, remoteService, reactor, callback):
def onTCPConnect(connector):
if connector.getError() != 0:
op.notify(-1, None)
return
connectOp = CSpaceConnector(connector.getSock(), remoteUser,
remoteService, reactor, op.notify).getOp()
op.setCanceler(connectOp.cancel)
tcpOp = tcpConnect(cspaceAddr, reactor, onTCPConnect)
op = AsyncOp(callback, tcpOp.cancel)
return op
def connect( self, connectCallback ) :
assert self.state == self.CLOSED
def onTCPConnect( connector ) :
self.connectOp = None
if connector.getError() != 0 :
self.state = self.CLOSED
connectCallback( False )
return
self.rpcConn = RPCConnection( connector.getSock(), self.reactor )
self.rpcConn.setCloseCallback( self._onClose )
self.state = self.CONNECTED
connectCallback( True )
self.connectOp = tcpConnect( self.routerAddr, self.reactor, onTCPConnect )
self.state = self.CONNECTING
def __init__(self, parent, reactor):
QVBox.__init__(self, parent)
self.reactor = reactor
self.setCaption('CSpace Test Applet')
self.chatOutputView = QTextEdit(self)
self.chatOutputView.setReadOnly(True)
self.chatInputEdit = QLineEdit(self)
self.chatInputEdit.setFocus()
self.state = self.CONNECTING
self.chatInputEdit.setEnabled(False)
self.isClient = (cspaceEvent == 'CONTACTACTION')
self.chatOutputView.append(
self.isClient and 'Connecting to %s...' % cspaceContactNickName
or 'Accepting connection from %s' % cspacePeerNickName)
addr = ('127.0.0.1', int(cspacePort))
self.tcpConnectOp = tcpConnect(addr, self.reactor, self._onTCPConnect)
self.stream = None
def firewallTestClient( addr, reactor, callback=None ) :
obj = Dummy()
def doCancel() :
if obj.connectOp :
obj.connectOp.cancel()
obj.connectOp = None
if obj.stream :
obj.stream.close()
obj.stream = None
if obj.timerOp :
obj.timerOp.cancel()
obj.timerOp = None
def doNotify() :
doCancel()
if obj.data :
op.notify( 0, obj.data )
else :
op.notify( -1, '' )
def onClose( *args ) :
doNotify()
def onInput( data ) :
obj.data += data
if len(obj.data) > 100 :
obj.data = ''
doNotify()
return
def onTimer() :
obj.timerOp = None
doNotify()
def onConnect( connector ) :
obj.connectOp = None
if connector.getError() != 0 :
doNotify()
return
sock = connector.getSock()
obj.stream = TCPStream( sock, reactor )
obj.stream.setCloseCallback( onClose )
obj.stream.setErrorCallback( onClose )
obj.stream.setInputCallback( onInput )
obj.stream.initiateRead( 100 )
obj.connectOp = tcpConnect( addr, reactor, onConnect )
obj.timerOp = reactor.callLater( 15, onTimer )
obj.stream = None
obj.data = ''
op = AsyncOp( callback, doCancel )
return op
def __init__( self, parent, reactor ) :
QVBox.__init__( self, parent )
self.reactor = reactor
self.setCaption( 'CSpace Test Applet' )
self.chatOutputView = QTextEdit( self )
self.chatOutputView.setReadOnly( True )
self.chatInputEdit = QLineEdit( self )
self.chatInputEdit.setFocus()
self.state = self.CONNECTING
self.chatInputEdit.setEnabled( False )
self.isClient = (cspaceEvent == 'CONTACTACTION')
self.chatOutputView.append( self.isClient and
'Connecting to %s...' % cspaceContactNickName or
'Accepting connection from %s' % cspacePeerNickName )
addr = ('127.0.0.1',int(cspacePort))
self.tcpConnectOp = tcpConnect( addr, self.reactor, self._onTCPConnect )
self.stream = None
def connectTo( self, peerPubKey, callback=None ) :
assert self.state == self.INITIAL
self.connectCallback = callback
self.state = self.CONNECTING
self.peerPubKey = peerPubKey
self.connectOp = tcpConnect( ('127.0.0.1',env.port), self.reactor, self._onConnect )
def acceptConnection( self, connectionId, callback=None ) :
assert self.state == self.INITIAL
self.connectCallback = callback
self.state = self.ACCEPTING
self.connectionId = connectionId
self.connectOp = tcpConnect( ('127.0.0.1',env.port), self.reactor, self._onConnect )
