Reset the HTTPServer subdirectories when a new cache directory is created.

[quix0rs-apt-p2p.git] / apt_dht / apt_dht.py

diff --git a/apt_dht/apt_dht.py b/apt_dht/apt_dht.py
index 51ab5825e2e4464c9137bd62f1ae876ab3d2319f..1abeaa5323ec0bf5b690ec2646bc309e7158387f 100644 (file)
--- a/apt_dht/apt_dht.py
+++ b/apt_dht/apt_dht.py
@@ -1,27 +1,55 @@
 
 from binascii import b2a_hex
+from urlparse import urlunparse
+import os, re
 
 from twisted.internet import defer
 from twisted.web2 import server, http, http_headers
 from twisted.python import log
+from twisted.python.filepath import FilePath
 
 from apt_dht_conf import config
 from PeerManager import PeerManager
 from HTTPServer import TopLevel
 from MirrorManager import MirrorManager
+from CacheManager import CacheManager
+from Hash import HashObject
+from db import DB
+from util import findMyIPAddr
+
+download_dir = 'cache'
 
 class AptDHT:
     def __init__(self, dht):
         log.msg('Initializing the main apt_dht application')
+        self.cache_dir = FilePath(config.get('DEFAULT', 'cache_dir'))
+        if not self.cache_dir.child(download_dir).exists():
+            self.cache_dir.child(download_dir).makedirs()
+        self.db = DB(self.cache_dir.child('apt-dht.db'))
         self.dht = dht
-        self.http_server = TopLevel(config.get('DEFAULT', 'cache_dir'), self)
+        self.dht.loadConfig(config, config.get('DEFAULT', 'DHT'))
+        self.dht.join().addCallbacks(self.joinComplete, self.joinError)
+        self.http_server = TopLevel(self.cache_dir.child(download_dir), self)
         self.http_site = server.Site(self.http_server)
         self.peers = PeerManager()
-        self.mirrors = MirrorManager(config.get('DEFAULT', 'cache_dir'))
+        self.mirrors = MirrorManager(self.cache_dir)
+        self.cache = CacheManager(self.cache_dir.child(download_dir), self.db, self)
+        self.my_addr = None
+        self.setDirectories = self.http_server.setDirectories
     
     def getSite(self):
         return self.http_site
     
+    def joinComplete(self, result):
+        self.my_addr = findMyIPAddr(result, config.getint(config.get('DEFAULT', 'DHT'), 'PORT'))
+        if not self.my_addr:
+            raise RuntimeError, "IP address for this machine could not be found"
+
+    def joinError(self, failure):
+        log.msg("joining DHT failed miserably")
+        log.err(failure)
+        raise RuntimeError, "IP address for this machine could not be found"
+    
     def check_freshness(self, path, modtime, resp):
         log.msg('Checking if %s is still fresh' % path)
         d = self.peers.get([path], "HEAD", modtime)
@@ -42,18 +70,19 @@ class AptDHT:
         log.msg('Trying to find hash for %s' % path)
         findDefer = self.mirrors.findHash(path)
         
-        findDefer.addCallback(self.findHash_done, path, d)
-        findDefer.addErrback(self.findHash_error, path, d)
+        findDefer.addCallbacks(self.findHash_done, self.findHash_error, 
+                               callbackArgs=(path, d), errbackArgs=(path, d))
+        findDefer.addErrback(log.err)
         return d
     
     def findHash_error(self, failure, path, d):
         log.err(failure)
-        self.findHash_done((None, None), path, d)
+        self.findHash_done(HashObject(), path, d)
         
     def findHash_done(self, hash, path, d):
         if hash.expected() is None:
             log.msg('Hash for %s was not found' % path)
-            self.download_file([path], hash, path, d)
+            self.lookupHash_done([], hash, path, d)
         else:
             log.msg('Found hash %s for %s' % (hash.hexexpected(), path))
             # Lookup hash from DHT
@@ -64,14 +93,37 @@ class AptDHT:
     def lookupHash_done(self, locations, hash, path, d):
         if not locations:
             log.msg('Peers for %s were not found' % path)
-            self.download_file([path], hash, path, d)
+            getDefer = self.peers.get([path])
+            getDefer.addCallback(self.cache.save_file, hash, path)
+            getDefer.addErrback(self.cache.save_error, path)
+            getDefer.addCallbacks(d.callback, d.errback)
         else:
             log.msg('Found peers for %s: %r' % (path, locations))
             # Download from the found peers
-            self.download_file(locations, hash, path, d)
+            getDefer = self.peers.get(locations)
+            getDefer.addCallback(self.check_response, hash, path)
+            getDefer.addCallback(self.cache.save_file, hash, path)
+            getDefer.addErrback(self.cache.save_error, path)
+            getDefer.addCallbacks(d.callback, d.errback)
             
-    def download_file(self, locations, hash, path, d):
-        getDefer = self.peers.get(locations)
-        getDefer.addCallback(self.mirrors.save_file, hash, path)
-        getDefer.addErrback(self.mirrors.save_error, path)
-        getDefer.addCallbacks(d.callback, d.errback)
+    def check_response(self, response, hash, path):
+        if response.code < 200 or response.code >= 300:
+            log.msg('Download from peers failed, going to direct download: %s' % path)
+            getDefer = self.peers.get([path])
+            return getDefer
+        return response
+        
+    def new_cached_file(self, url, file_path, hash, urlpath):
+        self.mirrors.updatedFile(url, file_path)
+        
+        if self.my_addr and hash:
+            site = self.my_addr + ':' + str(config.getint('DEFAULT', 'PORT'))
+            full_path = urlunparse(('http', site, urlpath, None, None, None))
+            key = hash.norm(bits = config.getint(config.get('DEFAULT', 'DHT'), 'HASH_LENGTH'))
+            storeDefer = self.dht.storeValue(key, full_path)
+            storeDefer.addCallback(self.store_done, full_path)
+            storeDefer.addErrback(log.err)
+
+    def store_done(self, result, path):
+        log.msg('Added %s to the DHT: %r' % (path, result))
+        
\ No newline at end of file