def listenIn(self, port, callbackObject, useSSL=False):
"""
Creates a server using its arguments.
@attention: This is a non-blocking operation. Please, check if the connection is ready BEFORE
you send anything through it.
Args:
port: The port to listen in. If it's not free, a NetworkManagerException will be raised.
callbackObject: the callback object that will process all the incoming
packages received through this connection.
useSSL: if True, the SSL version 4 protocol will be used. Otherwise, we'll stick
to TCP version 4.
Returns:
Nothing
"""
if self.__connectionPool.has_key(('', port)):
raise NetworkManagerException("The port " + str(port) +
" is already in use")
# The port is free => proceed
# Allocate the connection resources
(queue, thread) = self.__allocateConnectionResources(callbackObject)
# Create the NetworkConnection object
connection = ServerConnection(useSSL, self.__certificatesDirectory,
port, queue, thread, callbackObject)
try:
# Establish it
connection.establish(None)
if (connection.getError() == None):
# Register the new connection
self.__connectionPool[('', port)] = connection
else:
raise ConnectionException(str(connection.getError()))
except ConnectionException as e:
raise NetworkManagerException(e.message)
def sendPacket(self, host, port, packet):
"""
Sends a packet through the specified port and IP address.
Args:
port: The port assigned to the connection that will be used to send the packet.
packet: The packet to send.
Returns:
Nothing
Raises:
NetworkManagerException: a NetworkManagerException will be raised if
- there were errors while establishing the connection, or
- if the connection was abnormally closed, or
- if the connection is a server connection and it's not ready yet, or
- if the supplied port is free
"""
if not self.__connectionPool.has_key((host, port)):
raise NetworkManagerException(
"There's nothing attached to the port " + str(port))
connection = self.__connectionPool[(host, port)]
self.__detectConnectionErrors(connection)
if not connection.isReady():
if (connection.isServerConnection()):
raise NetworkManagerException(
"No clients have connected to this port yet")
else:
raise NetworkManagerException(
"The connection is not ready yet")
connection.registerPacket()
self.__outgoingDataQueue.queue(packet.getPriority(),
(connection, packet))
def connectTo(self, host, port, timeout, callbackObject, useSSL=False):
"""
Connects to a remote server using its arguments
@attention: This is a blocking operation. The calling thread will be blocked until
the connection is established or until a timeout error is detected.
Args:
host: host IP address
port: the port where the host is listenning
timeout: timeout in seconds.
callbackObject: the callback object that will process all the incoming
packages received through this connection.
Returns:
Nothing
Raises:
NetworkManagerException: If no answer is received after timeout
seconds, the connection process will be aborted and a
NetworkManagerException will be raised.
"""
if self.__connectionPool.has_key((host, port)):
raise NetworkManagerException("The port " + str(port) +
" is already in use")
# The port is free => proceed
# Allocate the connection resources
(queue, thread) = self.__allocateConnectionResources(callbackObject)
# Create and configure the endpoint
factory = _CygnusCloudProtocolFactory(queue)
if (not useSSL):
endpoint = TCP4ClientEndpoint(reactor, host, port, timeout, None)
else:
keyPath = self.__certificatesDirectory + "/" + "server.key"
certificatePath = self.__certificatesDirectory + "/" + "server.crt"
try:
endpoint = SSL4ClientEndpoint(
reactor, host, port,
ssl.DefaultOpenSSLContextFactory(keyPath, certificatePath))
except Exception:
raise NetworkManagerException(
"The key, the certificate or both were not found")
endpoint.connect(factory)
# Wait until the connection is ready
time = 0
while factory.isDisconnected() and time <= timeout:
sleep(0.01)
time += 0.01
if factory.isDisconnected():
raise NetworkManagerException("The host " + host + ":" +
str(port) +
" seems to be unreachable")
# Create the new connection
connection = _NetworkConnection(False, host, port, factory, queue,
thread, callbackObject)
# Add the new connection to the connection pool
self.__connectionPool[(host, port)] = connection
def listenIn(self, port, callbackObject, useSSL=False):
"""
Creates a server using its arguments.
@attention: This is a non-blocking operation. Please, check if the connection is ready BEFORE
you send anything through it.
Args:
port: The port to listen in. If it's not free, a NetworkManagerException will be raised.
callbackObject: the callback object that will process all the incoming
packages received through this connection.
Returns:
Nothing
"""
if self.__connectionPool.has_key(('127.0.0.1', port)):
raise NetworkManagerException("The port " + str(port) +
" is already in use")
# The port is free => proceed
# Allocate the connection resources
(queue, thread) = self.__allocateConnectionResources(callbackObject)
# Create and configure the endpoint
if (not useSSL):
endpoint = TCP4ServerEndpoint(reactor, port)
else:
keyPath = self.__certificatesDirectory + "/" + "server.key"
certificatePath = self.__certificatesDirectory + "/" + "server.crt"
try:
endpoint = SSL4ServerEndpoint(
reactor, port,
ssl.DefaultOpenSSLContextFactory(keyPath, certificatePath))
except Exception:
raise NetworkManagerException(
"The key, the certificate or both were not found")
factory = _CygnusCloudProtocolFactory(queue)
# Create the connection
connection = _NetworkConnection(True, '', port, factory, queue, thread,
callbackObject)
# Create the deferred to retrieve the IListeningPort object
def registerListeningPort(port):
connection.setListeningPort(port)
def onError(failure):
connection.setError(failure)
deferred = endpoint.listen(factory)
deferred.addCallback(registerListeningPort)
deferred.addErrback(onError)
connection.setDeferred(deferred)
# Register the new connection
self.__connectionPool[('', port)] = connection
def connectTo(self,
host,
port,
timeout,
callbackObject,
useSSL=True,
reconnect=False):
"""
Connects to a remote server using its arguments
@attention: This is a blocking operation. The calling thread will be blocked until
the connection is established or until a timeout error is detected.
Args:
host: host IP address
port: the port where the host is listenning
timeout: timeout in seconds.
callbackObject: the callback object that will process all the incoming
packages received through this connection.
useSSL: if True, the SSL version 4 protocol will be used. Otherwise, we'll stick
to TCP version 4.
reconnect: if True, the network subsystem will try to reconnect to the server
when the connection is lost.
Returns:
Nothing
Raises:
NetworkManagerException: If no answer is received after timeout
seconds, the connection process will be aborted and a
NetworkManagerException will be raised.
"""
if self.__connectionPool.has_key((host, port)):
raise NetworkManagerException("The port " + str(port) +
" is already in use")
# The port is free => proceed
# Allocate the connection resources
(queue, thread) = self.__allocateConnectionResources(callbackObject)
# Create the NetworkConnection object
connection = ClientConnection(useSSL, self.__certificatesDirectory,
host, port, queue, thread, reconnect,
callbackObject)
# Try to establish the connection
try:
if (connection.establish(timeout)):
# The connection could be created => add it to the connection pool
self.__connectionPool[(host, port)] = connection
else:
# Raise an exception
raise NetworkManagerException(str(connection.getError()))
except ConnectionException as e:
raise NetworkManagerException(e.message)
def __detectConnectionErrors(self, connection):
"""
Checks if the given connection is in an error state or was unexpectedly closed.
Args:
connection: the connection to monitor.
Returns:
Nothing
"""
if connection.isInErrorState():
# Something bad has happened => close the connection, warn the user
self.__connectionPool.pop(
(connection.getHost(), connection.getPort()))
raise NetworkManagerException(str(connection.getError()))
if (connection.wasUnexpectedlyClosed()):
self.__connectionPool.pop(
(connection.getHost(), connection.getPort()))
raise NetworkManagerException(
"The connection was closed abnormally")
def closeConnection(self, host, port):
"""
Closes a connection
Args:
port: The port assigned to the connection. If it's free, a NetworkManagerException will be
raised.
Returns:
Nothing
"""
if not self.__connectionPool.has_key((host, port)):
raise NetworkManagerException(
"There's nothing attached to the port " + str(port))
# Retrieve the connection
connection = self.__connectionPool[(host, port)]
# Ask the connection to close
connection.close()
def createPacket(self, priority):
"""
Creates an empty data packet and returns it
Args:
priority: The new packet's priority.
Returns:
a new data packet.
Raises:
NetworkManagerException: this exception will be raised when the packet's priority
is not a positive integer.
"""
if not isinstance(priority, int) or priority < 0:
raise NetworkManagerException(
"Data packets\' priorities MUST be positive integers")
p = _Packet(Packet_TYPE.DATA, priority)
return p
def isConnectionReady(self, host, port):
"""
Checks wether a connection is ready or not.
Args:
port: the port assigned to the connection.
Returns:
True if the connection is ready or False otherwise.
Raises:
NetworkManagerException: a NetworkManagerException will be raised if
- there were errors while establishing the connection, or if
- the connection was abnormally closed, or if
- the supplied port is free
"""
if not self.__connectionPool.has_key((host, port)):
raise NetworkManagerException("The port " + str(port) +
" is not in use")
connection = self.__connectionPool[(host, port)]
self.__detectConnectionErrors(connection)
return connection.isReady()