def getUPnP():
"Returns a deferred, which returns a UPnP object"
attempt = 0
while True:
try:
server = UPnPClientServer(("", 1900+attempt), UPnPProtocol)
i = socket.inet_aton(getLocalIPAddress())
server.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, i)
#mcast = reactor.listenMulticast(1900+attempt, self)
break
except socket.error:
attempt = random.randint(0,500)
log.msg("couldn't listen on UPnP port, trying %d"%(
attempt+1900), system='UPnP')
if attempt != 0:
log.msg("warning: couldn't listen on std upnp port", system='UPnP')
#mcast.joinGroup('239.255.255.250', socket.INADDR_ANY)
grpaddr = struct.unpack("I", socket.inet_aton(UPNP_MCAST))[0]
mreq = struct.pack('II', socket.htonl(grpaddr), socket.htonl(socket.INADDR_ANY))
try:
server.socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
except socket.error:
dsunittest.traceException("Failed doing IP_ADD_MEMBERSHIP for mreq %r" % mreq)
# apparently on win32, even though this call fails, UPnP works just fine
# so I'm commenting out this raise statement --eries
# raise NoUPnPFound()
return server.discoverUPnP()
def lf():
try:
d2 = self._deferredLookup(name=name, cls=cls, type=type, timeout=timeout)
d2.chainDeferred(d)
except:
dsunittest.traceException("error during _deferredLookup for name %s" % name)
d.errback()
def do_GET(self):
host = self.headers["Host"]
realHost = host.replace(kwebSuffix, "")
# fixme: remove once we're running as *.kweb.kenosisp2p.org
if hostOverride:
realHost = hostOverride
self.headers["Host"] = realHost
self.headers["Connection"] = "close"
realUrl = "http://%s" % (realHost + self.path)
addr = kenosis.randomNodeAddress()
nodes = self.node_.findNearestNodes(nodeAddress=addr, serviceName="kweb")
if not nodes:
nodes = [(self.node_.nodeAddress(), "")]
headersToSend = dict(self.headers.items())
for nodeAddr, netAddr in nodes:
try:
response_code, headers, data = self.node_.rpc(nodeAddress=nodeAddr).kweb.fetchUrl(realUrl, headersToSend, 0)
except kenosis.KenosisError, e:
dsunittest.traceException("error with nodeAddress %s, netAddress %s" % (nodeAddr, netAddr))
lastError = e
else:
break
def removeListener(self, listener):
"""Removes a listener."""
try:
self.listeners.remove(listener)
self.notifyAll()
except:
dsunittest.traceException("uncaught error")
pass
def notifyNewStreamService(self, name, streamPort, streamType):
try:
publicNetAddress = self.mapper_.map(port=("", streamPort, streamType, "kenosis-%s" % name))
print "upnp_plugin mapped internal stream port %s to public address %s" % (streamPort, publicNetAddress)
return publicNetAddress[1]
except upnp.NoUPnPFound:
dsunittest.traceException(text="UpnpPlugin.notifyNewStreamService: no upnp found")
return streamPort
def __onListeningOnInternalPort(self, internalPort):
try:
publicNetAddress = self.mapper_.map(port=("", internalPort, "TCP", "kenosis"))
except upnp.UPnPError:
dsunittest.traceException(text="UPnP not supported")
return
print "upnp_plugin mapped internal port %s to public address %s" % (internalPort, publicNetAddress)
self.__portMappingDone(publicNetAddress=publicNetAddress)
def readwriteWrapper(obj, flags):
global __somethingHappened
__somethingHappened = True
if __returnLiveSockets:
__liveSockets.append(obj)
#dsunittest.trace("%r is ready to readwrite" % obj)
try:
originalReadwrite(obj, flags)
except:
dsunittest.traceException("exception while reading or writing socket")
def writeWrapper(obj):
global __somethingHappened
__somethingHappened = True
if __returnLiveSockets:
__liveSockets.append(obj)
#dsunittest.trace("%r is ready to write" % obj)
try:
originalWrite(obj)
except:
dsunittest.traceException("exception while writing to socket")
def readWrapper(obj):
global __somethingHappened
__somethingHappened = True
if __returnLiveSockets:
__liveSockets.append(obj)
#dsunittest.trace("%r is ready to read" % obj)
try:
originalRead(obj)
except:
dsunittest.traceException("exception while reading from socket")
def send(self, out, addr = _MDNS_ADDR, port = _MDNS_PORT):
"""Sends an outgoing packet."""
# This is a quick test to see if we can parse the packets we generate
#temp = DNSIncoming(out.packet())
try:
printVerbose("sending data to %s,%s" % (addr, port))
bytes_sent = self.socket.sendto(out.packet(), 0, (addr, port))
except:
dsunittest.traceException("uncaught error")
# Ignore this, it may be a temporary loss of network connection
pass
def __init__(self, bindaddress=None):
"""Creates an instance of the Zeroconf class, establishing
multicast communications, listening and reaping threads."""
globals()['_GLOBAL_DONE'] = 0
if bindaddress is None:
#print "gethostname: %s" % socket.gethostname()
try:
self.intf = socket.gethostbyname(socket.gethostname())
except socket.error:
self.intf = "127.0.0.1"
else:
self.intf = bindaddress
self.group = ('', _MDNS_PORT)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
except:
# SO_REUSEADDR should be equivalent to SO_REUSEPORT for
# multicast UDP sockets (p 731, "TCP/IP Illustrated,
# Volume 2"), but some BSD-derived systems require
# SO_REUSEPORT to be specified explicity. Also, not all
# versions of Python have SO_REUSEPORT available. So
# if you're on a BSD-based system, and haven't upgraded
# to Python 2.3 yet, you may find this library doesn't
# work as expected.
#
dsunittest.traceException("uncaught error")
pass
self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_TTL, 255)
self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_LOOP, 1)
try:
self.socket.bind(self.group)
except:
# Some versions of linux raise an exception even though
# the SO_REUSE* options have been set, so ignore it
#
dsunittest.traceException("uncaught error")
pass
self.socket.setsockopt(socket.SOL_IP, socket.IP_MULTICAST_IF, socket.inet_aton(self.intf) + socket.inet_aton('0.0.0.0'))
self.socket.setsockopt(socket.SOL_IP, socket.IP_ADD_MEMBERSHIP, socket.inet_aton(_MDNS_ADDR) + socket.inet_aton('0.0.0.0'))
self.listeners = []
self.browsers = []
self.services = {}
self.cache = DNSCache()
self.condition = threading.Condition()
self.engine = Engine(self)
self.listener = Listener(self)
self.reaper = Reaper(self)
def readQuestions(self):
"""Reads questions section of packet"""
format = '!HH'
length = struct.calcsize(format)
for i in range(0, self.numQuestions):
name = self.readName()
info = struct.unpack(format, self.data[self.offset:self.offset+length])
self.offset += length
try:
question = DNSQuestion(name, info[0], info[1])
except NonLocalNameException:
dsunittest.traceException(text=name)
continue
self.questions.append(question)
def addService(self, server, type, name):
# print "Service %r added" % name
# Request more information about the service
info = server.getServiceInfo(type, name)
# print 'Additional info: %s' % info
if not info:
return
# print 'pinging: %s' % info
netAddress = "%s:%s" % (socket.inet_ntoa(info.getAddress()), info.port)
if netAddress != self.advertizedNetAddress_:
# print("my address is %s, his address is %s" % (self.advertizedNetAddress_, netAddress))
try:
self.node_.nodeKernel_.bootstrap(netAddress=netAddress, serviceName="kenosis")
except NetworkErrorClasses:
dsunittest.traceException("Failed pinging node found via Zeroconf: %s" % netAddress)
return
def run(self):
while not globals()['_GLOBAL_DONE']:
rs = self.getReaders()
if len(rs) == 0:
# No sockets to manage, but we wait for the timeout
# or addition of a socket
#
self.condition.acquire()
self.condition.wait(self.timeout)
self.condition.release()
else:
try:
rr, wr, er = select.select(rs, [], [], self.timeout)
for socket in rr:
try:
self.readers[socket].handle_read()
except:
traceback.print_exc()
except:
dsunittest.traceException("uncaught error")
pass
def err(self, text, system):
dsunittest.traceException("err: %s" % text)
def _worker(self):
try:
#Enable this for super tracing
#sys.settrace(self.__traceFunc)
threading.currentThread().task_taskList = weakref.ref(self)
while 1:
self.tasksSemaphore_.acquire()
if self is None:
return
self.tasksLock_.acquire()
try:
if self.waiting_ and len(self.waitingTasks_) == 0:
return
if self.stopping_:
return
assert not len(self.waitingTasks_) == 0
(t,) = self.waitingTasks_[:1]
del self.waitingTasks_[:1]
assert self.taskInfosById_[t.id()]["active"] == 0
self.taskInfosById_[t.id()]["active"] = 1
self.activeTasks_ += 1
numReallyActive = 0
for (id, info) in self.taskInfosById_.items():
if info["active"]:
numReallyActive += 1
assert numReallyActive == self.activeTasks_
self._print(status="started", task=t)
finally:
self.tasksLock_.release()
t.taskThread_ = threading.currentThread()
t.taskThread_.setName(str(t.id()))
returnValueShouldBeSet = 0
sleepTime = 0
if not self.stopping_:
try:
t.taskThread_.task_startTime = time.time()
returnValue = t.run()
sleepTime = self._sleepTime(startTime=t.taskThread_.task_startTime)
returnValueShouldBeSet = 1
except dsthread.ThreadStoppingError:
pass
except:
type, value, traceback = sys.exc_info()
self.exceptionThreadPairs_.append(((type, value, traceback), t.taskThread_))
if self.waiting_:
self._stop()
else:
# If someone is waiting then I know that they will get the execptions
# so I don't need to log them here.
dsunittest.traceException(text="Execption while handling task %s" % repr(t))
t.taskThread_ = None
self.tasksLock_.acquire()
try:
if returnValueShouldBeSet:
self.returnValues_.append(returnValue)
self.activeTasks_ -= 1
self.numTasksCompleted_ += 1
del self.taskInfosById_[t.id()]
self._print(status="finished", task=t)
self.anyComplete_.set()
if self.activeTasks_ == 0 and len(self.waitingTasks_) == 0:
if self.waiting_:
self._stop()
return
# This is an attempt to make the task list
# stop automatically when there are no
# outstanding references to it but it is
# flawed: we cannot call stop when
# self.waiting_ is false.
#elif len(gc.get_referrers(self)) == len(self.threads_):
# self._stop()
# return
else:
#print("num refs on inactive is: %s" % len(gc.get_referrers(self)))
pass
finally:
if self.activeTasks_ == 0 and len(self.waitingTasks_) == 0:
self.allComplete_.set()
self.tasksLock_.release()
self._sleep(sleepTime=sleepTime)
except:
dsunittest.traceException(text="Exception from task._worker")
def handleErrorWrapper(self):
dsunittest.traceException("exception while reading or writing socket")
return origHandleError(self)
