beremiz: comparison util/Zeroconf.py

equal deleted inserted replaced

-:6cf16e5bfbf9
+:c52d1460cea8
 def getClazz(self, clazz):
 """Class accessor"""
 try:
 return _CLASSES[clazz]
-except:
+except Exception:
 return "?(%s)" % (clazz)
 def getType(self, type):
 """Type accessor"""
 try:
 return _TYPES[type]
-except:
+except Exception:
 return "?(%s)" % (type)
 def toString(self, hdr, other):
 """String representation with additional information"""
 result = "%s[%s,%s" % (hdr, self.getType(self.type), self.getClazz(self.clazz))
 def __repr__(self):
 """String representation"""
 try:
 return socket.inet_ntoa(self.address)
-except:
+except Exception:
 return self.address
 class DNSHinfo(DNSRecord):
 """A DNS host information record"""
 def add(self, entry):
 """Adds an entry"""
 try:
 list = self.cache[entry.key]
-except:
+except Exception:
 list = self.cache[entry.key] = []
 list.append(entry)
 def remove(self, entry):
 """Removes an entry"""
 try:
 list = self.cache[entry.key]
 list.remove(entry)
-except:
+except Exception:
 pass
 def get(self, entry):
 """Gets an entry by key.  Will return None if there is no
 matching entry."""
 try:
 list = self.cache[entry.key]
 return list[list.index(entry)]
-except:
+except Exception:
 return None
 def getByDetails(self, name, type, clazz):
 """Gets an entry by details.  Will return None if there is
 no matching entry."""
 def entriesWithName(self, name):
 """Returns a list of entries whose key matches the name."""
 try:
 return self.cache[name]
-except:
+except Exception:
 return []
 def entries(self):
 """Returns a list of all entries"""
 def add(x, y): return x+y
 try:
 return reduce(add, self.cache.values())
-except:
+except Exception:
 return []
 class Engine(threading.Thread):
 """An engine wraps read access to sockets, allowing objects that
 try:
 rr, wr, er = select.select(rs, [], [], self.timeout)
 for socket in rr:
 try:
 self.readers[socket].handle_read()
-except:
+except Exception:
 # Ignore errors that occur on shutdown
 pass
-except:
+except Exception:
 pass
 def getReaders(self):
 result = []
 self.condition.acquire()
 def callback(x):
 return self.listener.removeService(x, self.type, record.alias)
 del(self.services[record.alias.lower()])
 self.list.append(callback)
 return
-except:
+except Exception:
 if not expired:
 def callback(x):
 return self.listener.addService(x, self.type, record.alias)
 self.services[record.alias.lower()] = record
 self.list.append(callback)
 # Only update non-existent properties
 if key and result.get(key) is None:
 result[key] = value
 self.properties = result
-except:
+except Exception:
 traceback.print_exc()
 self.properties = None
 def getType(self):
 """Type accessor"""
 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:
+except Exception:
 # 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
 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:
+except Exception:
 # Some versions of linux raise an exception even though
 # the SO_REUSE* options have been set, so ignore it
 #
 pass
 def unregisterService(self, info):
 """Unregister a service."""
 try:
 del(self.services[info.name.lower()])
-except:
+except Exception:
 pass
 now = currentTimeMillis()
 nextTime = now
 i = 0
 while i < 3:
 def removeListener(self, listener):
 """Removes a listener."""
 try:
 self.listeners.remove(listener)
 self.notifyAll()
-except:
+except Exception:
 pass
 def updateRecord(self, now, rec):
 """Used to notify listeners of new information that has updated
 a record."""
 out.addAnswer(msg, DNSService(question.name, _TYPE_SRV, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.priority, service.weight, service.port, service.server))
 if question.type == _TYPE_TXT or question.type == _TYPE_ANY:
 out.addAnswer(msg, DNSText(question.name, _TYPE_TXT, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.text))
 if question.type == _TYPE_SRV:
 out.addAdditionalAnswer(DNSAddress(service.server, _TYPE_A, _CLASS_IN | _CLASS_UNIQUE, _DNS_TTL, service.address))
-except:
+except Exception:
 traceback.print_exc()
 if out is not None and out.answers:
 out.id = msg.id
 self.send(out, addr, 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:
 bytes_sent = self.socket.sendto(out.packet(), 0, (addr, port))
-except:
+except Exception:
 # Ignore this, it may be a temporary loss of network connection
 pass
 def close(self):
 """Ends the background threads, and prevent this instance from

changeset 1780	c52d1460cea8
parent 1762	fcc406143e5b
child 1782	5b6ad7a7fd9d