子类化套接字 [英] Subclassing socket
问题描述
套接字对象有点怪癖。如果你试图在
阻塞套接字上收到0个字节，它们会阻塞。也就是说，如果我调用recv（0），它会阻止
（直到某些数据到达）。
我认为这是错的，但我不想争辩。我想
创建一个修复问题的套接字子类。理想情况下，
之类的东西：
类new_socket（套接字）：
def recv（self，bufsize，flags = 0） ：
if bufsize == 0：
return""
else：
return socket.recv （bufsize，flags）
他们唯一的问题是，套接字通过接受
调用返回套接字对象。返回的套接字是socket类型，当然不是我想要的b $ b new_socket。我可以覆盖accept（）返回一个
new_socket，但我不知道如何将旧套接字转换为新的
套接字。也就是说，我想在上面的课程中添加一个方法
喜欢：
def接受（个体经营）：
conn，addr = socket.accept（）
<转换conn，这是类型socket以输入new_socket>
return（conn，addr）
有没有人对如何做到这一点有任何建议？
imho：
类new_socket（套接字）：
def __init __（self，family = AF_INET，type = SOCK_STREAM，proto = 0，
_sock = None）
socket .__ init __（self，family = AF_INET，type = SOCK_STREAM，proto = 0，
_sock = None）
def接受（个体经营）：
conn，addr = socket.accept（）
return（new_socket（_sock = conn），addr）
但是我认为你的问题有一个更简单的方式然后继承
你必须聚合套接字和对象必须有fileno方法，
那样可以使用select.select来使用你班级的实例。功能
class mySocket：
def __init __（self，...）：
self .__ socket = None
...
def fileno（个体经营）：
返回自我.__ socket.fileno（）
def connect（self ，__ host，__ port）：
试试：
self.close（）
self .__ socket = socket.socket（socket.AF_INET，socket .SOCK_STREAM）
self .__ socket.connect（（__ host，__ port））
...
def close（self）：
试试：
如果self .__ socket不是None：
self .__ socket.close（）
finally：
self .__ socket =无
...
gr ***************** @ spamgourmet.com 写道：套接字对象有点怪癖。如果您尝试在
阻塞套接字上接收0字节，则会阻止。也就是说，如果我调用recv（0），它会阻止
（直到某些数据到达）。
我认为这是错的，但我不想争辩。我想创建一个修复问题的套接字子类。理想情况下，类似于：
类new_socket（套接字）：
def recv（self，bufsize，flags = 0）：
如果bufsize == 0：
return"
else：
返回socket.recv（bufsize，flags）
他们唯一的问题是，套接字通过accept
打电话。返回的socket是socket类型，当然不是new_socket，正如我想的那样。我可以覆盖accept（）来返回一个
new_socket，但我不知道如何将旧套接字转换为新的套接字。也就是说，我想在上面的类中添加一个方法，例如：
def accept（self）：
conn，addr = socket.accept（）
<转换conn，这是类型socket以输入new_socket>
返回（conn，addr）
有没有人对如何进行上述操作有任何建议？
-
祝你好运，
Maksim Kasimov
mailto： ma ************ @ gmail.com
更简单的方法？那是什么？
socket objects have a little quirk. If you try to receive 0 bytes on a
blocking socket, they block. That is, if I call recv(0), it blocks
(until some data arrives).
I think that''s wrong, but I don''t want to argue that. I would like to
create a subclass of socket that fixes the problem. Ideally, something
like:
class new_socket(socket):
def recv( self, bufsize, flags=0 ):
if bufsize == 0:
return ""
else:
return socket.recv( bufsize, flags )
They only problem is, sockets return socket objects via the accept
call. And the socket returned is of type socket, of course, not
new_socket, as I would like. I could override accept() to return a
new_socket, but I don''t know how to convert the old socket to a new
socket. That is, I''d like to add a method to the class above something
like:
def accept( self ):
conn, addr = socket.accept()
<convert conn, which is type socket to type new_socket>
return ( conn, addr )
Does anyone have any suggestions on how to do the above?
imho:
class new_socket(socket):
def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0,
_sock=None)
socket.__init__(self, family=AF_INET, type=SOCK_STREAM, proto=0,
_sock=None)
def accept( self ):
conn, addr = socket.accept()
return ( new_socket(_sock=conn), addr )
but i think your problem have a more simple way then inheritance
you have to agregate socket and the object must have "fileno" method,
thats gives a possibility to use instanses of your class with "select.select" function
class mySocket:
def __init__(self, ...):
self.__socket = None
...
def fileno(self):
return self.__socket.fileno()
def connect(self, __host, __port):
try:
self.close()
self.__socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__socket.connect((__host, __port))
...
def close(self):
try:
if self.__socket is not None:
self.__socket.close()
finally:
self.__socket = None
...
gr*****************@spamgourmet.com wrote:socket objects have a little quirk. If you try to receive 0 bytes on a
blocking socket, they block. That is, if I call recv(0), it blocks
(until some data arrives).
I think that''s wrong, but I don''t want to argue that. I would like to
create a subclass of socket that fixes the problem. Ideally, something
like:
class new_socket(socket):
def recv( self, bufsize, flags=0 ):
if bufsize == 0:
return ""
else:
return socket.recv( bufsize, flags )
They only problem is, sockets return socket objects via the accept
call. And the socket returned is of type socket, of course, not
new_socket, as I would like. I could override accept() to return a
new_socket, but I don''t know how to convert the old socket to a new
socket. That is, I''d like to add a method to the class above something
like:
def accept( self ):
conn, addr = socket.accept()
<convert conn, which is type socket to type new_socket>
return ( conn, addr )
Does anyone have any suggestions on how to do the above?
--
Best regards,
Maksim Kasimov
mailto: ma************@gmail.com
More simple way? What''s that?
这篇关于子类化套接字的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
