Cache Decorator, XML-RPC Server und Client
Stand: März 2008
- Sprungmarken:
- Server |
- Cache Decorator |
- Client
irgendein Text
Syntax:
XML RPC Server - server.py
import socket
from SocketServer import TCPServer
from SimpleXMLRPCServer import SimpleXMLRPCServer as Server
from cashdeco import Factorial as F, PrimeNumbers as P
class Handler(F, P):
pass
ip = socket.gethostbyname(socket.gethostname())
TCPServer.allow_reuse_address = True
serv = Server((ip,1337))
serv.register_instance(Handler())
print "XMLRPC - Server Adresse: http://%s:1337." % str(ip)
print 'Zum Beenden Strg+Pause benutzen.'
serv.serve_forever()
Kategorie: Python
Modul Cache Decorator
from math import sqrt
class Cache(object):
def __init__(self):
self.cache = {}
self.function = None
def function_cached(self, *args):
if args not in self.cache:
self.cache[args] = self.function(*args)
if args[1] == True: # Den Cache im Prompt des Servers anzeigen.
print 'neu berechnet '+str(args)+' -> id'+str(id(self.cache[args]))
else:
print 'neu berechnet '
else:
if args[1] == True: # Den Cache im Prompt des Servers anzeigen.
print 'aus dem Cache '+str(args)+' -> id'+str(id(self.cache[args]))
for key in self.cache:
if key == args:
print key
print self.cache[key]
break
else:
print 'aus dem Cache '
# Den errechneten Wert an den Client zurückgeben.
if args[2] == True:
# Hier als String
# - Beachten: lange Rückgabezeit bei 'großen' Zahlen
# - Vorteil: Unabhängigkeit von der benutzten Programmiersprache des Clients.
for key in self.cache:
if key == args:
result = str(self.cache[key])
break
## Alternativ als Binary 64Bit
## result = xmlrpclib.Binary(self.cache[key])
## mit Attribut .data wieder entpacken.
return result
else:
# Hier nur Rückgabe von [n]
# Es soll nur die benötigte Rechenzeit ermittelt werden.
return args
def __call__(self, function):
self.function = function
return self.function_cached
class Factorial(object):
def __init__(self):
pass
@Cache()
def fac(n, cache, result):
n = abs(n)
p = 1
for i in xrange(2, n+1):
p *= i
return p
class PrimeNumbers(object):
def __init__(self):
pass
@staticmethod
def determine_prime(to_limit):
numbers = dict([[i,True] for i in xrange(2, to_limit)])
for n in xrange(2, to_limit):
if numbers[n]:
yield n
if n <= sqrt(to_limit):
for key in numbers.iterkeys():
if not key % n:
numbers[key] = False
@Cache()
def call_determine_prime(to_limit, cache, result):
liste = [prime for prime in PrimeNumbers.determine_prime(to_limit)]
if result == True:
print liste
return liste
Kategorie: Python
XML-RPC-Client - client.py, cmd.Cmd Konsole
import cmd
import time
import xmlrpclib
class Console(cmd.Cmd):
def __init__(self, serv):
cmd.Cmd.__init__(self)
self.prompt = '>>> '
self.serv = serv
self.cache = False
self.result = False
def do_cache(self, arg):
result = raw_input('>>> Den internen Cache im Prompt des Servers anzeigen? (j|n): ')
result = result.strip().lower()
if result == 'j':
print '>>> Aufbau des Cache wird angezeigt.'
self.cache = True
elif result == 'n':
print '>>> Keine Cacheanzeige.'
self.cache = False
return False
def help_cache(self):
print '>>> Den Inhalt des internen Caches im Prompt des Servers anzeigen.'
print '>>> Vorsicht bei grossen Zahlen, grosse Wartezeiten^^'
def do_result(self, arg):
result = raw_input('>>> Ergebnis an den Aufrufer? (j|n): ')
result = result.strip().lower()
if result == 'j':
print '>>> Ergebnisse werden zurueckgegeben.'
self.result = True
elif result == 'n':
print '>>> Keine Ergebnisrueckgabe.'
self.result = False
return False
def help_result(self):
print '>>> Ergebnisrueckgabe an den Aufrufer.'
print '>>> Vorsicht bei grossen Zahlen, grosse Wartezeiten^^'
def do_factorial(self, arg):
try:
n = int(raw_input('>>> Wir benoetigen eine Zahl: '))
start = time.clock()
self.serv.fac(n, self.cache, self.result)
print ">>> Faktorielle der Zahl %d ermittelt." % n
print ">>> Total: %1.4f Sekunden: " % (time.clock() - start)
except ValueError, OverflowError:
print '>>> Es wird eine Zahl benoetigt!'
finally:
return False
def help_factorial(self):
print '>>> Die Faktorielle einer Zahl ermitteln.'
def do_prime(self, arg):
try:
to_limit = int(raw_input('>>> Eine Obergrenze festlegen: '))
start = time.clock()
self.serv.call_determine_prime(to_limit, self.cache, self.result)
print ">>> Alle Primzahlen bis zu der vorgegebenen Grenze %d ermitteln." % to_limit
print ">>> Total: %1.4f Sekunden: " % (time.clock() - start)
except ValueError:
print '>>> Eine Obergrenze muss festgelegt werden!'
finally:
return False
def help_prime(self):
print '>>> Alle Primzahlen bis zu einer vorgegebenen Obergrenze ermitteln'
def do_exit(self, arg):
print '>>> und Exit...'
return True
def help_exit(self):
print '>>> Beendet die Console.'
def main():
ip = raw_input('>>> Eingabe IP des Servers: ')
serv=xmlrpclib.ServerProxy("http://%s:1337" % ip)
console = Console(serv)
console.onecmd(console.precmd('help'))
console.cmdloop()
if __name__ == '__main__':
main()
Kategorie: Python
