def __init__(self, path, identity): self.identity = identity self.store = store.STORAGE_BACKENDS[settings.STORAGE_BACKEND](path) self.gizmo_factory = GizmoFactory(self, identity) self.identity_cache = {} self.registry = RequestRegistry() self.iterators = [] self.deferreds = []
class Station(object): def __init__(self, path, identity): self.identity = identity self.store = store.STORAGE_BACKENDS[settings.STORAGE_BACKEND](path) self.gizmo_factory = GizmoFactory(self, identity) self.identity_cache = {} self.registry = RequestRegistry() self.iterators = [] self.deferreds = [] @staticmethod def from_env(identity): if "GROUNDSTATION_HOME" in os.environ: return Station(os.getenv("GROUNDSTATION_HOME"), identity) else: station_path = os.path.expanduser("~/.groundstation") return Station(station_path, identity) def get_crypto_adaptor(self): return RSAAdaptor(self.store.get_public_keys()) def get_private_crypto_adaptor(self, keyname): return RSAPrivateAdaptor(self.store.get_private_key(keyname)) def get_request(self, request_id): return self.registry[request_id] def register_request(self, request): log.debug("Registering request %s" % (str(request.id))) self.registry.register(request) def free_request(self, request): log.debug("Freeing request %s" % (str(request.id))) return self.registry.free(request) def register_iter(self, iterator): log.info("Registering iterator %s" % (repr(iterator))) self.iterators.append(iterator()) def register_deferred(self, deferred): log.info("Registering deferred %s" % (repr(deferred))) self.deferreds.append(deferred) def has_ready_iterators(self): return len(self.iterators) > 0 def has_ready_deferreds(self): now = time.time() for i in self.deferreds: if i.at < now: return True return False def handle_iters(self): for i in self.iterators: try: i.next() except StopIteration: self.iterators.remove(i) def handle_deferreds(self): now = time.time() new_deferreds = [] while self.deferreds: i = self.deferreds.pop(0) if i.at < now: i.run() else: new_deferreds.append(i) [self.deferreds.append(i) for i in new_deferreds] def channels(self): return os.listdir(self.store.gref_path()) # channels = {} # for channel in os.listdir(self.store.gref_path()): # channels["channel"] = Channel(self.store, channel) def create_channel(self, channel_name): try: os.mkdir(os.path.join(self.store.gref_path(), channel_name)) return True except OSError: return False def grefs(self, channel): channel_path = os.path.join(self.store.gref_path(), channel) if not groundstation.utils.is_dir(channel_path): raise NonExistantChannel() grefs = [] for id in groundstation.utils.find_leaf_dirs(channel_path, True): grefs.append(Gref(self.store, channel, id)) return grefs # Delegate some methods to the store def write(self, obj): log.info("Writing object to db") oid = self.store.create_blob(obj) log.info("Wrote object %s" % oid) return oid def objects(self): return self.store.objects() def __getitem__(self, key): return self.store.__getitem__(key) def __contains__(self, item): return self.store.__contains__(item) # End delegates to store def update_gref(self, gref, tips, parents=[]): log.debug("updating %s - %s => %s" % (gref.channel, gref.identifier, tips)) node_path = gref.node_path() tip_oids = [] for tip in tips: gref.write_tip(tip.tip, tip.signature) tip_oids.append(tip.tip) if parents is True: parents = gref.parents(tip_oids) for parent in parents: gref.remove_tip(parent, True) def recently_queried(self, identity): """CAS the cache status of a given identity. Returns False if you should query them.""" val = str(identity) if val not in self.identity_cache: self.mark_queried(identity) return False else: if self.identity_cache[val] + settings.DEFAULT_CACHE_LIFETIME > time.time(): return True else: self.mark_queried(identity) return False def mark_queried(self, identity): val = str(identity) self.identity_cache[val] = time.time() def get_hash(self, prefix): # TODO This depends heavily on the order that objects() returns sha = hashlib.sha1() for oid in sorted(self.objects()): name = groundstation.utils.oid2hex(oid) if name.startswith(prefix): sha.update(name) return sha.digest()
class Station(object): def __init__(self, path, identity): self.identity = identity self.store = store.STORAGE_BACKENDS[settings.STORAGE_BACKEND](path) self.gizmo_factory = GizmoFactory(self, identity) self.identity_cache = {} self.registry = RequestRegistry() self.iterators = [] self.deferreds = [] def get_request(self, request_id): return self.registry[request_id] def register_request(self, request): log.debug("Registering request %s" % (str(request.id))) self.registry.register(request) def free_request(self, request): log.debug("Freeing request %s" % (str(request.id))) return self.registry.free(request) def register_iter(self, iterator): log.info("Registering iterator %s" % (repr(iterator))) self.iterators.append(iterator()) def register_deferred(self, deferred): log.info("Registering deferred %s" % (repr(deferred))) self.deferreds.append(deferred) def has_ready_iterators(self): return len(self.iterators) > 0 def has_ready_deferreds(self): now = time.time() for i in self.deferreds: if i.at < now: return True return False def handle_iters(self): for i in self.iterators: try: i.next() except StopIteration: self.iterators.remove(i) def handle_deferreds(self): now = time.time() new_deferreds = [] while self.deferreds: i = self.deferreds.pop(0) if i.at < now: i.run() else: new_deferreds.append(i) [self.deferreds.append(i) for i in new_deferreds] def channels(self): return os.listdir(self.store.gref_path()) # channels = {} # for channel in os.listdir(self.store.gref_path()): # channels["channel"] = Channel(self.store, channel) def grefs(self, channel): channel_path = os.path.join(self.store.gref_path(), channel) if not groundstation.utils.is_dir(channel_path): raise NonExistantChannel() grefs = [] for id in groundstation.utils.find_leaf_dirs(channel_path, True): grefs.append(Gref(self.store, channel, id)) return grefs # Delegate some methods to the store def write(self, obj): log.info("Writing object to db") oid = self.store.create_blob(obj) log.info("Wrote object %s" % oid) return oid def objects(self): return self.store.objects() def __getitem__(self, key): return self.store.__getitem__(key) def __contains__(self, item): return self.store.__contains__(item) # End delegates to store def update_gref(self, gref, tips, parents=[]): log.debug("updating %s - %s => %s" % (gref.channel, gref.identifier, tips)) node_path = gref.node_path() for tip in tips: gref.write_tip(tip, "") if parents is True: parents = gref.parents(tips) for parent in parents: gref.remove_tip(parent, True) def get_user(self, name): return User(name, self) def get_keys(self, user): """Fetch the keys from an object pointed to by $db/users/_name_/keys""" try: ref = self.store.lookup_reference(user.keys_ref) assert ref.oid in self.store, "Invalid user keys ref" return PackedKeys(self.store[ref.oid].read_raw()) except KeyError: raise NoKeysRef(user.name) def set_keys(self, user, keys): """Serialize the keys, then write them out to the db and update the ref""" ref = self.store.create_blob(keys.pack()) try: self.store.lookup_reference(user.keys_ref).oid = ref except KeyError: self.store.create_reference(user.keys_ref, ref) def recently_queried(self, identity): """CAS the cache status of a given identity. Returns False if you should query them.""" val = str(identity) if val not in self.identity_cache: self.mark_queried(identity) return False else: if self.identity_cache[val] + settings.DEFAULT_CACHE_LIFETIME > time.time(): return True else: self.mark_queried(identity) return False def mark_queried(self, identity): val = str(identity) self.identity_cache[val] = time.time()