import dns

class DnsHandler(threading.Thread):
    def __init__(self, msgQueue, tsigKey, nsAddress, ttl, nullIp):
        threading.Thread.__init__(self)
        self.msgQueue = msgQueue
        self.nullIp = nullIp
        self.nsAddress = nsAddress
        self.ttl = ttl
        self.keyring = dns.tsigkeyring.from_text(tsigKey)

    def run(self):
        while(True):
            msg = self.msgQueue.get()
            
            if msg.successFlag:
                # success
                Logger.dbg("DnsManipulator: retrieved positive message")
                if not self.statusMap.has_key(msg.ip) or not self.statusMap[msg.ip]:
                    self.statusMap[msg.ip] = True
                    self.insertARR(msg.ip)
                    
                    self.notifyQueue.put(NotificationMessage("Server returned", "Server %s is back" % msg.ip))
            else:
                # failure
                Logger.dbg("DnsManipulator: retrieved negative message")
                if not self.statusMap.has_key(msg.ip) or self.statusMap[msg.ip]:
                    self.statusMap[msg.ip] = False
                    self.deleteARR(msg.ip)

                    self.notifyQueue.put(NotificationMessage("Server unavailable", "Server %s has gone" % msg.ip))

            failureCnt = 0
            for v in self.statusMap.values():
                if not v:
                    failureCnt += 1
            
            if failureCnt > 0 and not self.exitServerFlag:
                self.insertARR(self.exitServerIp)
                self.exitServerFlag = True
                
            if failureCnt == 0 and self.exitServerFlag:
                self.deleteARR(self.exitServerIp)
                self.exitServerFlag = False

                self.notifyQueue.put(NotificationMessage("All clear", "All clear, exit-server removed from DNS"))
                    
    def insertARR(self, ip):
        # send A-RR insertion for ip to DNS server
        Logger.log("insert ARR %s" % ip)

        rr = dns.rdtypes.IN.A.A(dns.rdataclass.IN, dns.rdatatype.A, ip)
        u = dns.update.Update(self.zone, keyring=self.keyring)
        u.add(self.name, self.ttl, rr)
        r = dns.query.tcp(u, self.nsAddress)

        if r.rcode() != 0:
            # failure
            Logger.log("failure when inserting A-RR for %s" % ip)
        else:
            # success
            pass

    def deleteARR(self, ip):
        # send A-RR deletion for ip to DNS server
        Logger.log("delete ARR %s" % ip)
                
        rr = dns.rdtypes.IN.A.A(dns.rdataclass.IN, dns.rdatatype.A, ip)
        u = dns.update.Update(self.zone, keyring=self.keyring)
        u.delete(self.name, rr)
        r = dns.query.tcp(u, self.nsAddress)

        if r.rcode() != 0:
            # failure
            Logger.log("failure when deleting A-RR for %s" % ip)
        else:
            # success
            pass