Als neuer Python-Fan habe ich mir eine XML-RPC Schnittstelle gebaut (Client/Server) für 5 bzw. 6 Parameter auszutauschen. Diese Parameter werden Serverseitig verwendet, um eine Audio-Datei und eine Strukturierte Textdatei zu erzeugen.
Fehlerbeschreibung:
Client und Server binden sich auf unterschiedlichen Rechnern.
A) Ich melde mich über ssh (putty 0.60) auf dem Rechner an, auf dem der Server laufen soll und starte ihn.
b) Ich melde mich über ssh (puyy 0.60) auf dem Rechner an, auf dem der Client aufgerufen wird.
c) Ich führe das Client-Skript aus und es funktioniert alles wunderbar. Auch mehrmals hintereinander!!!
d) Ich schließe beide ssh-sessions (PS: Server läuft weiterhin)
==================================
Nun melde ich mich wieder auf beiden Rechnern über ssh an!
Nichts wurde verändert
a) der Server läuft weiterhin
b) ich führe das Client-Skript aus
c) Es passiert ein Fehler
d) Der Server wird beendet.
Jetzt bekomme ich folgenden merkwürdigen Fehler: (Dieses Ausgabe kann später im Codelisting eingesehen werden)
Argumente werden uebertragen....
XML-RPC Protokollfehler:
Fehlercode: -1
URL: 172.19.201.39:9001/RPC2
HTTP-Header: None
Fehlermeldung:
Ich wäre sehr dankbar, wenn jemand den Fehler finden würde oder mir bescheinigt, dass die ganze Syntax korrekt ist.
Oder über Verbesserungen z.B. das Exception-Handling
Danke!!
XML-RPC-Server
Code: Alles auswählen
#!/usr/bin/python
# coding: utf-8
import SimpleXMLRPCServer
import xmlrpclib
import sys
import os
import logging
import time
LINEBREAK = "-----------------------------------"
HOST = "10.1.0.34"
PORT = 9001
class xmlServer():
def __init__(self): # Konstruktor
print LINEBREAK
print "Objekt wird erstellt..."
def __del__(self): # Destruktor
print LINEBREAK
print "Objekt wird zerstoert..."
# Audiodatei wird erstellt
def create_wave_file(self, paramsHash):
length = len(paramsHash)
paramsHash["HOSTADDR"] = paramsHash["HOSTADDR"].replace(".", " Punkt ")
if length == 5:
msg = "Der Host %s mit der Adresse %s befindet sich im Zustand %s. Es liegt folgender Fehler vor: %s. Ende der Nachricht" %(paramsHash["HOSTNAME"], paramsHash["HOSTADDR"], paramsHash["HOSTSTATE"], paramsHash["HOSTOUTPUT"])
else:
msg = "Der Service %s auf dem Host %s mit der Adresse %s befindet sich im Zustand %s. Es liegt folgender Fehler vor: %s. Ende der Nachricht" %(paramsHash["SERVICEDESC"], paramsHash["HOSTNAME"], paramsHash["HOSTADDR"], paramsHash["SERVICESTATE"], paramsHash["SERVICEOUTPUT"])
cmd = "swift -o /home/fstrauss/xmlrpc/files/msgFile-%s.wav -p speech/rate=130,audio/sampling-rate=8000,audio/channels=1 %s" %(paramsHash["CONTACTPAGER"], msg)
convert = 'sox /home/fstrauss/xmlrpc/files/msgFile-%s.wav /home/fstrauss/xmlrpc/files/msgFile-%s.gsm' %(paramsHash["CONTACTPAGER"], paramsHash["CONTACTPAGER"] )
logging.info("------CREATE WAVE-FILE----------------------------------------------")
logging.info(cmd)
os.system(cmd)
time.sleep(2)
os.system(convert)
logging.info("...finished...")
logging.info("------WAVE-FILE CREATED---------------------------------------------")
# Callfile wird erstellt
def create_call_file(self, paramsHash):
# Zuordnungsverzeichnis
dictionary = {}
# Temporaere Liste
tmpList = []
# Lese die Datei und parse sie
call_file = open("/home/fstrauss/xmlrpc/template.call", "r")
for line in call_file:
line = line.strip()
mapping = line.split(" ")
(key, value) = tuple(mapping)
tmpList.append(key)
dictionary[key] = value
call_file.close()
logging.info("------CREATE CALLFILE----------------------------------------------")
# Erstelle ein neues Call-File mit den geaenderten Parametern
newFile = "/home/fstrauss/xmlrpc/files/call-%s.call" %(paramsHash["CONTACTPAGER"])
new_call_file = open(newFile, "w")
for key in tmpList:
value = dictionary[key]
new_call_file.write(key + " " + value + '\n')
new_call_file.close()
logging.info("...finished..")
logging.info("------CALLFILE CREATED---------------------------------------------")
# Funktionsdeklaration - Oeffentliche Funktion
def get_params(paramsHash):
print "Folgende Daten erhalten..."
print LINEBREAK
print paramsHash.items()
logging.info("------PARAMETER INCOMING------------------------------------")
logging.info("Folgende Parameter erhalten: %s" % paramsHash.items())
logging.info("------PARAMETER END-----------------------------------------")
print LINEBREAK
xml_server = xmlServer()
xml_server.create_wave_file(paramsHash)
xml_server.create_call_file(paramsHash)
def main():
try:
logging.basicConfig(
filename = '/var/log/xml_rpc_server.log',
filemode = "a",
level = logging.INFO,
format = "%(asctime)s %(levelname)s: %(message)s",
datefmt = "%d.%m.%Y %H:%M:%S")
# Der XMLRPC-Server wird erstellt und an die IP-Adresse "10.207.100.100" mit dem Port "8111" gebunden.
logging.info("------BEGIN SERVER STATE-----------------------------------")
server = SimpleXMLRPCServer.SimpleXMLRPCServer((HOST, PORT), allow_none=1)
# Die bereit gestellten Funktionen werden veroeffentlicht
logging.info("Funktionen werden veroeffentlicht...")
server.register_function(get_params)
# Der Server laeuft auf unbestimmte Zeit, bis er manuell beendet wird
logging.info("Server wird gestartet und wartet auf Anfragen...")
logging.info("------END SERVER STATE-------------------------------------")
server.serve_forever()
except IOError:
# Es sind Fehler bei der Argumentuebergabe aufgetreten
logging.error("Folgender Fehler ist aufgetreten: %s! -- Der Server wird beendet" %error)
etype, evalue, tb = sys.exc_info()
print_exception(etype, evalue, tb)
except Exception, error:
# Es sind Fehler bei der Argumentuebergabe aufgetreten
print "Error-Message: %s" %error
logging.error("Folgender Fehler ist aufgetreten: %s! -- Der Server wird beendet" %error)
if __name__ == "__main__":
# Start der Main-Funktion
main()
XML-RPC-Client
Code: Alles auswählen
#!/usr/bin/python
# coding: utf-8
import xmlrpclib
import sys
import os
import socket
XMLRPC_SERVER = "http://10.1.0.34:9001"
HOST = "10.1.0.34"
PORT = 9001
LINEBREAK = "--------------------------------------"
# Klasse XmlClient wird definiert
class xmlClient:
def __init__(self): # Konstruktor
print LINEBREAK
print "Objekt wird erstellt..."
self.paramsHash = {}
def __del__(self): # Destruktor
print LINEBREAK
print "Objekt wird zerstoert..."
def get_xml(self, paramsHash): # Funktion
# Uebergebene Parameter werden in XML-Darstellung ausgegeben
tuple_params = tuple([paramsHash])
xmlrpc = xmlrpclib.dumps(tuple_params, 'get_params')
print "*******************"
print xmlrpc
print "*******************"
def getArguments(self, argv): # Funktion
if len(sys.argv) == 6:
# Parameter werden zugeordnet
self.paramsHash["HOSTNAME"] = argv[0]
self.paramsHash["HOSTADDR"] = argv[1]
self.paramsHash["HOSTSTATE"] = argv[2]
self.paramsHash["HOSTOUTPUT"] = argv[3]
self.paramsHash["CONTACTPAGER"] = argv[4]
#self.get_xml(self.paramsHash)
return self.paramsHash
elif len(sys.argv) == 7:
# Parameter werden zugeordnet
self.paramsHash["HOSTNAME"] = argv[0]
self.paramsHash["HOSTADDR"] = argv[1]
self.paramsHash["SERVICESTATE"] = argv[2]
self.paramsHash["SERVICEOUTPUT"] = argv[3]
self.paramsHash["SERVICEDESC"] = argv[4]
self.paramsHash["CONTACTPAGER"] = argv[5]
#self.get_xml(self.paramsHash)
return self.paramsHash
else:
print "#################################"
raise Exception("Anzahl der Argumente fehlerhaft. Min. 5 - Max. 6!")
def is_alive(self): # Funktion
print LINEBREAK
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.shutdown(2)
print "XMLRPC-Schnittstelle ist auf %s:%s erreichbar..." %(HOST, PORT)
def sendParams(self, server, paramsHash): # Funktion
# Ruft die Funktion auf dem XMLRPC-Server auf
print LINEBREAK
print "Argumente werden uebertragen...."
server.get_params(paramsHash)
print LINEBREAK
print "...fertig..."
# Begin der Hauptfunktion
def main(argv):
try:
xml_client= xmlClient() # Objekt wird erstellt
paramsHash = xml_client.getArguments(argv) # Parameter werden uebergeben
xml_client.is_alive() # Ist die Schnittstelle erreichbar?
xml_server = xmlrpclib.ServerProxy(XMLRPC_SERVER) # Erstellung des Server-Objekts
xml_client.sendParams(xml_server, paramsHash) # Parameter werden gesendet
except xmlrpclib.Fault, fErr:
print "XML-RPC Fehler:"
print "Fehlercode: %d" %(fErr.faultCode)
print "Fehlermeldung: %s" %(fErr.faultString)
except xmlrpclib.ProtocolError, pErr:
print "XML-RPC Protokollfehler:"
print "Fehlercode: %d" %(pErr.errcode)
print "URL: %s" %(pErr.url)
print "HTTP-Header: %s" %(pErr.headers)
print "Fehlermeldung: %s" %(pErr.errmsg)
except:
# Es sind Fehler bei der Argumentuebergabe aufgetreten
print "Es ist folgender Fehler aufgetreten: %s" %sys.exc_info()[0]
print "Beschreibung: %s" %sys.exc_info()[1]
print "----Programm wird beendet!----"
if __name__ == "__main__":
# Start der Main-Funktion
main(sys.argv[1:])