On 11/5/2010 8:10 PM, Alan Gauld wrote:
"Chris King" <g.nius...@gmail.com> wrote
If you are using Windows, turn off the built-in firewall. That's
what fixed my problems.
~Corey
also, it is on the same network, so the server shouldn't be a problem
I think Corey means the firewall on your PC if you have one. It could
be blocking outgoing traffic to uncommon port numbers or somesuch.
Its worth trying if only to eliminate the possibility
Alan G.
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
http://mail.python.org/mailman/listinfo/tutor
The firewall pops up and I click allow. It has nothing to do with the
firewall at all. Did you find any other errors at all?
import SocketServer, cPickle, socket
def IP(): return socket.gethostbyname(socket.gethostname()) #return IP address
def echo(self): #the default handling function
if self.data == 'shut down': # if user wants to kill self
self.shut_down() #shut
print 'Recieved %s from %s. Echoing back.' % (self.data, self.client_address)
self.send(self.data) #echo
class BreakOutError(Exception): pass #an error for breaking out
def create_handler(handle_func=echo): #creates an handler
class Handler(SocketServer.BaseRequestHandler): #the handler
'''A handler which calls %s in the handle method.'''%handle_func
def handle(self): #the handle method
self.data = self.request.recv(1024) #the data
handle_func(self) #call the handle method giving self
def send(self, data): self.request.send(data) #send data
def shut_down(self): #if you want to stop server
'''End server loop'''
self.server.shut_self_down = True #set shut down to true
raise BreakOutError #raise error
return Handler
def pickle_echo(self):
print 'Recived %s, a %s, from %s. Echoing back.' % (self.data, type(self.data), self.client_address)
self.send(self.data)
def pickle_HC(handle_func = pickle_echo): #a function that returns a handler that can send a recvieve more than strings if to a pickle client
base = create_handler(handle_func) #make a base
class pickle_Handler(base):
'''A handler which call %s in the handle method and pickle/unpickles on the way in and out.'''%handle_func
def handle(self):
self.data = cPickle.loads(self.request.recv(1024)) #unpickle data
handle_func(self)
def send(self, data): base.send(self, cPickle.dumps(data))
return pickle_Handler
class EB_Server(SocketServer.TCPServer):
'''Error Breakout Server
When you use server.shutdown, it waits for the handle to end, but this is the only place to do stuff.
So the error breakout server uses error to break out of a server loop, which will be caught outside.'''
def __init__(self, address, handler):
'''Init, set self.shutdown to False'''
SocketServer.TCPServer.__init__(self, address, handler) #make a handler from a function
self.shut_self_down = False #When an error is raised and handle_error catches it, it will check if its an breakout error
def handle_error(self, request, address):
'''Test to see if shutting down.'''
if self.shut_self_down: raise BreakOutError #if shutdown, raise breakout error
else: SocketServer.TCPServer.handle_error(self, request, address) #If not, do normal error handling
def run(handle_func = echo, host = 'localhost', port=1024): #init function
try: EB_Server((host, port), create_handler(handle_func)).serve_forever() #serve forever
except BreakOutError: pass #If it tries to break out, catch it before it destroys us at the main level
def pickle_run(handle_func = pickle_echo, host='localhost', port = 1024):
try: EB_Server((host, port), pickle_HC(handle_func)).serve_forever()
except BreakOutError: pass
if __name__ == '__main__':
print 'The IP is %s.' % IP()
run(port = int(raw_input('What port? '))) #if run directly, run server
import socket, cPickle
class NotConnectedError(Exception): pass #A ClosedError
class Client(object): #client object
def __init__(self, host = 'localhost', port = 1024, timeout = None):
print host
self.host = host #set attributes
self.port = port
self.timeout = timeout
self.closed = False
def send(self, data): #send data
try: self.__sock.close() #close old socket
except AttributeError: pass #If there isn't a socket, don't worry about it
self.__sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #make a new one
self.__sock.connect((self.host, self.port))
self.closed = False
self.__sock.settimeout(self.timeout)
self.__sock.sendall(data)
def old_send(self, data): #send with same socket
self.__sock.send(data)
def recv(self): #receive data
if self.closed: raise NotConnectedError, 'The socket isn\'t connected.' #if closed, raise error
return self.__sock.recv(1024)
def close(self): #close sock
self.__sock.close()
self.closed = True
def connect(self, host, port): #connect or reconnect
self.__sock.connect((host, port))
self.closed = True #set closed to false
def __get_timeout(self):
try: return self.__sock.gettimeout()
except AttributeError: return self.__timeout #sock may not exist, so do predefined
def __set_timeout(self, timeout):
self.__timeout = timeout
try: self.__sock.settimeout(self.__timeout)
except AttributeError: pass #sock may not exist
timeout = property(__get_timeout, __set_timeout)
class Pickle_Client(Client): #a client to send objects, not just strings
def send(self, data):
Client.send(self, cPickle.dumps(data)) #pickle the object first
def recv(self):
return cPickle.loads(Client.recv(self)) #unpickles object first
if __name__ == '__main__':
client = Client(raw_input('What host? '), int(raw_input('What port? ')))
while True:
client.send(raw_input('What do you want to send? '))
print client.recv()
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
http://mail.python.org/mailman/listinfo/tutor
