def __init__(self, sourlient):
AFTNPaths.normalPaths(sourlient.name)
PXPaths.normalPaths()
self.sysman = SystemManager() # General system manager
self.sourlient = sourlient # Sourlient (Source/Client) object containing configuration infos.
self.logger = sourlient.logger # Logger object
self.subscriber = sourlient.subscriber # Determine if it will act like a subscriber or a provider(MHS)
self.host = sourlient.host # Remote host (name or ip)
self.portR = sourlient.portR # Receiving port
self.portS = sourlient.portS # Sending port
self.batch = sourlient.batch # Number of files we read in a pass (20)
self.timeout = sourlient.timeout # Timeout time in seconds (default = 10 seconds)
self.sleepBetweenConnect = int('10') # Time (in seconds) between connection trials
self.slow = sourlient.slow # Sleeps are added when we want to be able to decrypt log entries
self.igniter = None # Igniter object (link to pid)
self.writePath = AFTNPaths.RECEIVED # Where we write messages we receive
self.archivePath = AFTNPaths.SENT # Where we put sent messages
self.specialOrdersPath = AFTNPaths.SPECIAL_ORDERS # Where we put special orders
# Paths creation
self.sysman.createDir(PXPaths.TXQ + self.sourlient.name)
self.sysman.createDir(self.writePath)
self.sysman.createDir(self.archivePath)
self.sysman.createDir(self.specialOrdersPath)
self.mm = MessageManager(self.logger, self.sourlient) # AFTN Protocol is implemented in MessageManager Object
self.remoteAddress = None # Remote address (where we will connect())
self.socket = None # Socket object
self.dataFromFiles = [] # A list of tuples (content, filename) obtained from a DiskReader
self.reader = DiskReader(PXPaths.TXQ + self.sourlient.name, self.sourlient.batch,
self.sourlient.validation, self.sourlient.diskReaderPatternMatching,
self.sourlient.mtime, True, self.logger, eval(self.sourlient.sorter), self.sourlient)
self.debug = True # Debugging switch
self.justConnect = False # Boolean that indicates when a connexion just occur
self.totBytes = 0
#self.printInitInfos()
self.makeConnection()
def mergeTwoDict(dict1, dict2):
from SystemManager import SystemManager
"""
dict1 and dict2 must be of the following form:
dict1 = {'toto': [item1, item2, ...], 'titi':[item1], ...}
dict2 = {'toto': [item3, ...], 'tata':[item4], ...}
newDict = {'toto': [item1, item2, item3, ...], 'titi':[item1], 'tata':[item4], ...}
"""
newDict = {}
keys1 = dict1.keys(); keys2 = dict2.keys()
keys = keys1 + keys2
keys = SystemManager.removeDuplicate(keys)
keys.sort()
for key in keys:
for dict in [dict1, dict2]:
if dict.get(key, None):
newDict.setdefault(key, []).extend(dict.get(key))
return newDict
def mergeTwoDict(dict1, dict2):
from SystemManager import SystemManager
"""
dict1 and dict2 must be of the following form:
dict1 = {'toto': [item1, item2, ...], 'titi':[item1], ...}
dict2 = {'toto': [item3, ...], 'tata':[item4], ...}
newDict = {'toto': [item1, item2, item3, ...], 'titi':[item1], 'tata':[item4], ...}
"""
newDict = {}
keys1 = dict1.keys()
keys2 = dict2.keys()
keys = keys1 + keys2
keys = SystemManager.removeDuplicate(keys)
keys.sort()
for key in keys:
for dict in [dict1, dict2]:
if dict.get(key, None):
newDict.setdefault(key, []).extend(dict.get(key))
return newDict
class TransceiverAFTN:
"""
When started, a subscriber AFTN will listen on a port (56550), whishing to be
connected by the AFTN provider. If this does not happen rapidly enough (before
the timeout expires), the subscriber will try to connect (port 5160) to the
provider.
"""
def __init__(self, sourlient):
AFTNPaths.normalPaths(sourlient.name)
PXPaths.normalPaths()
self.sysman = SystemManager() # General system manager
self.sourlient = sourlient # Sourlient (Source/Client) object containing configuration infos.
self.logger = sourlient.logger # Logger object
self.subscriber = sourlient.subscriber # Determine if it will act like a subscriber or a provider(MHS)
self.host = sourlient.host # Remote host (name or ip)
self.portR = sourlient.portR # Receiving port
self.portS = sourlient.portS # Sending port
self.batch = sourlient.batch # Number of files we read in a pass (20)
self.timeout = sourlient.timeout # Timeout time in seconds (default = 10 seconds)
self.sleepBetweenConnect = int('10') # Time (in seconds) between connection trials
self.slow = sourlient.slow # Sleeps are added when we want to be able to decrypt log entries
self.igniter = None # Igniter object (link to pid)
self.writePath = AFTNPaths.RECEIVED # Where we write messages we receive
self.archivePath = AFTNPaths.SENT # Where we put sent messages
self.specialOrdersPath = AFTNPaths.SPECIAL_ORDERS # Where we put special orders
# Paths creation
self.sysman.createDir(PXPaths.TXQ + self.sourlient.name)
self.sysman.createDir(self.writePath)
self.sysman.createDir(self.archivePath)
self.sysman.createDir(self.specialOrdersPath)
self.mm = MessageManager(self.logger, self.sourlient) # AFTN Protocol is implemented in MessageManager Object
self.remoteAddress = None # Remote address (where we will connect())
self.socket = None # Socket object
self.dataFromFiles = [] # A list of tuples (content, filename) obtained from a DiskReader
self.reader = DiskReader(PXPaths.TXQ + self.sourlient.name, self.sourlient.batch,
self.sourlient.validation, self.sourlient.diskReaderPatternMatching,
self.sourlient.mtime, True, self.logger, eval(self.sourlient.sorter), self.sourlient)
self.debug = True # Debugging switch
self.justConnect = False # Boolean that indicates when a connexion just occur
self.totBytes = 0
#self.printInitInfos()
self.makeConnection()
#self.run()
def setIgniter(self, igniter):
self.igniter = igniter
def printInitInfos(self):
print("********************* Init. Infos ****************************")
print("Remote Host: %s" % self.host)
print("Port R: %s" % self.portR)
print("Port S: %s" % self.portS)
print("Remote Address: %s" % self.remoteAddress)
print("Timeout: %4.1f" % self.timeout)
print("Write Path: %s" % self.writePath)
print("Subscriber: %s" % self.subscriber)
print("**************************************************************")
def reconnect(self):
try:
#poller.unregister(self.socket.fileno())
self.socket.close()
except:
(type, value, tb) = sys.exc_info()
self.logger.error("Unable to close the socket! Type: %s, Value: %s" % (type, value))
# FIXME: Possibly some variable resetting should occur here?
self.logger.info("Sleeping %d seconds (just before makeConnection())" % (self.sleepBetweenConnect))
time.sleep(self.sleepBetweenConnect)
self.makeConnection()
def makeConnection(self):
if self.subscriber:
# The Subscriber first listens for a connection from Provider(MHS)
self.socket = self._listen(self.portR, self.logger)
if self.socket:
self.logger.info("Subscriber has been connected by Provider")
#self.run()
else:
# The Subscriber try to connect to the Provider(MHS)
self.remoteAddress = (self.host, self.portS)
self.logger.info("The subscriber will try to connect to MHS(%s)" % str(self.remoteAddress))
self.socket = self._connect(self.remoteAddress, self.logger)
#self.run()
else: # Provider(MHS) case
# The Provider first try to connect to the Subscriber
self.remoteAddress = (self.host, self.portS)
self.socket = self._connect(self.remoteAddress, self.logger)
if self.socket:
self.logger.info("Provider has completed the connection")
#self.run()
else:
# The Provider(MHS) listens for a connection from Subscriber
self.socket = self._listen(self.portR, self.logger)
if self.socket:
self.logger.info("Provider has been connected by the subscriber")
#self.run()
else:
self.logger.error("No socket (NONE)")
self.justConnect = True
def _connect(self, remoteAddress, logger):
trials = 0
if self.subscriber:
maxTrials = 1000
else:
maxTrials = 3
while trials < maxTrials:
if trials == 12:
self.sleepBetweenConnect = 60
socketSender = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socketSender.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
socketSender.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
socketSender.settimeout(self.timeout)
#print socketSender.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)
#socketSender.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF,4096)
#print socketSender.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)
#socketSender.setblocking(True)
trials += 1
try:
socketSender.connect(remoteAddress)
logger.info("Sender is now (after %d trial(s)) connected to: %s" % (trials, str(remoteAddress)))
break
except socket.gaierror, e:
logger.error("Address related error connecting to receiver: %s" % e)
sys.exit(1)
except socket.error, e:
(type, value, tb) = sys.exc_info()
logger.error("Type: %s, Value: %s, Sleeping %d seconds ..." % (type, value, self.sleepBetweenConnect))
socketSender.close()
socketSender = None
time.sleep(self.sleepBetweenConnect)
def createFlowDict(self):
mergedDict = SystemManager.mergeTwoDict(self.sourceCluster,
self.clientCluster)
return SystemManager.mergeTwoDict(mergedDict, self.sourlientCluster)
for file in filesToDelete:
file = file.strip()
try:
os.unlink(file)
if deleteLog is not None:
deleteLog.info("%s has been deleted" % file)
except:
(type, value, tb) = sys.exc_info()
if deleteLog is None:
print "Problem deleting %s , Type: %s Value: %s" % (
file, type, value)
else:
deleteLog.error(
"Problem deleting %s , Type: %s Value: %s" %
(file, type, value))
if __name__ == '__main__':
manager = SystemManager()
#print manager.getRxNames()
#print manager.getTxNames()
#manager.createDir('/apps/px/tutu/')
#manager.createDir('/apps/px/tata/')
manager.changePrefixPath('/apps/px/toto/')
manager.changePrefixPath('/apps/px/tutu/')
manager.copyFiles('/apps/px/toto/', '/apps/px/tarteau/',
'/apps/px/tarteau/copy.log')
#manager.deleteFiles('/apps/px/tarteau/copy.log', '/apps/px/tarteau/delete.log')
deleteLog.error("Problem opening %s , Type: %s Value: %s" % (cpLog, type, value))
filesToDelete = cpLog.readlines()
cpLog.close()
for file in filesToDelete:
file = file.strip()
try:
os.unlink(file)
if deleteLog is not None:
deleteLog.info("%s has been deleted" % file)
except:
(type, value, tb) = sys.exc_info()
if deleteLog is None:
print "Problem deleting %s , Type: %s Value: %s" % (file, type, value)
else:
deleteLog.error("Problem deleting %s , Type: %s Value: %s" % (file, type, value))
if __name__ == '__main__':
manager = SystemManager()
#print manager.getRxNames()
#print manager.getTxNames()
#manager.createDir('/apps/px/tutu/')
#manager.createDir('/apps/px/tata/')
manager.changePrefixPath('/apps/px/toto/')
manager.changePrefixPath('/apps/px/tutu/')
manager.copyFiles('/apps/px/toto/', '/apps/px/tarteau/', '/apps/px/tarteau/copy.log')
#manager.deleteFiles('/apps/px/tarteau/copy.log', '/apps/px/tarteau/delete.log')
def __init__(self):
self.__systemManager = SystemManager()
class RequestManager:
def __init__(self):
self.__systemManager = SystemManager()
def processRequest(self, request):
if not type(request) is dict:
return Messages.invalidRequest
elif not 'type' in request:
return Messages.invalidRequest
elif not 'login' in request or not 'password' in request:
return Messages.invalidRequest
elif request['type'] == 'REGISTER':
if not self.__systemManager.createClient(request['login'],
request['password']):
return Messages.loginExists
else:
return Messages.userCreated
elif not self.__systemManager.authenticate(request['login'],
request['password']):
return Messages.invalidLoginOrPassWord
elif request['type'] == 'AUTHENTICATE':
return Messages.authOk
elif request['type'].startswith('GET_ITEM'):
if not 'itemId' in request:
return Messages.invalidRequest
answer = False
if request['type'] == 'GET_ITEM_NAME':
answer = self.__systemManager.getItemName(
request['login'], request['itemId'])
elif request['type'] == 'GET_ITEM_DATA':
answer = self.__systemManager.getItemData(
request['login'], request['itemId'])
elif request['type'] == 'GET_ITEM_TYPE':
answer = self.__systemManager.getItemType(
request['login'], request['itemId'])
elif request['type'] == 'GET_ITEM_PARENT':
answer = self.__systemManager.getItemParentId(
request['login'], request['itemId'])
if type(answer) is bool and not answer:
return Messages.getError
else:
return dict(Messages.getOK, **{'answer': answer})
elif request['type'] == 'CREATE_FOLDER':
if not 'where' in request:
return Messages.invalidRequest
if not 'name' in request:
return Messages.invalidRequest
createdId = self.__systemManager.createFolder(
request['login'], request['name'], request['where'])
if type(createdId) is bool and not createdId:
return Messages.invalidRequest
return Messages.folderCreated
elif request['type'] == 'CREATE_FILE':
if not 'where' in request:
return Messages.invalidRequest
if not 'name' in request:
return Messages.invalidRequest
if not 'data' in request:
return Messages.invalidRequest
createdId = self.__systemManager.createFile(
request['login'], request['name'], request['data'],
request['where'])
if type(createdId) is bool and not createdId:
return Messages.invalidRequest
return Messages.fileCreated
elif request['type'] == 'GET_ROOT_FOLDER':
client = self.__systemManager.getClient(request['login'])
return dict(Messages.getOK, **{'answer': client.getRootFolder()})
elif request['type'] == 'GET_SHARED_FOLDER':
client = self.__systemManager.getClient(request['login'])
return dict(Messages.getOK, **{'answer': client.getSharedFolder()})
elif request['type'] == 'SHARE_ITEM':
if not 'itemId' in request or not 'toLogin' in request:
return Messages.invalidRequest
if not self.__systemManager.addPermission(
request['itemId'], request['login'], request['toLogin']):
return Messages.invalidRequest
else:
return Messages.permissionGiven
elif request['type'] == 'RENAME_ITEM':
if not 'itemId' in request or not 'newName' in request:
return Messages.invalidRequest
if not self.__systemManager.renameItem(
request['login'], request['itemId'], request['newName']):
return Messages.invalidRequest
else:
return Messages.itemRenamed
elif request['type'] == 'EDIT_FILE_DATA':
if not 'fileId' in request or not 'newData' in request:
return Messages.invalidRequest
if not self.__systemManager.editFileData(
request['login'], request['fileId'], request['newData']):
return Messages.invalidRequest
else:
return Messages.fileEdited
elif request['type'] == 'MOVE_ITEM':
if not 'itemId' in request or not 'newParent' in request:
return Messages.invalidRequest
if not self.__systemManager.moveItem(
request['login'], request['itemId'], request['newParent']):
return Messages.invalidRequest
else:
return Messages.itemMoved
else:
return Messages.invalidRequest
def createFlowDict(self):
mergedDict = SystemManager.mergeTwoDict(self.sourceCluster, self.clientCluster)
return SystemManager.mergeTwoDict(mergedDict, self.sourlientCluster)
