def __init__(self, certificate, private_key, token=None): self.client_cache = utils.FastStore(1000) self.token = token super(ServerCommunicator, self).__init__(certificate=certificate, private_key=private_key) self.pub_key_cache = utils.FastStore(max_size=50000) # Our common name as an RDFURN. self.common_name = rdfvalue.RDFURN(self.certificate.GetCN())
def testOpenFilehandlesExpire(self): """Test that file handles expire from cache.""" files.FILE_HANDLE_CACHE = utils.FastStore(max_size=10) current_process = psutil.Process(os.getpid()) num_open_files = len(current_process.open_files()) path = os.path.join(self.base_path, "morenumbers.txt") fd = vfs.VFSOpen( rdf_paths.PathSpec(path=path, pathtype=rdf_paths.PathSpec.PathType.OS)) fds = [] for filename in fd.ListNames(): child_fd = vfs.VFSOpen( rdf_paths.PathSpec(path=os.path.join(path, filename), pathtype=rdf_paths.PathSpec.PathType.OS)) fd.read(20) fds.append(child_fd) # This should not create any new file handles. self.assertTrue(len(current_process.open_files()) - num_open_files < 5) # Make sure we exceeded the size of the cache. self.assertGreater(fds, 20)
def test03Expire(self): """Tests the expire mechanism.""" s = utils.FastStore(max_size=100) key = "test1" s.Put(key, 1) # This should not raise self.assertEqual(s.Get(key), 1) s.ExpireObject(key) self.assertRaises(KeyError, s.Get, key)
def test02StoreRefresh(self): """Test that store keeps recently gotten objects fresh.""" s = utils.FastStore(max_size=5) keys = [] for i in range(0, 5): keys.append(s.Put(i, i)) # This should not raise because keys[0] should be refreshed each time its # gotten for i in range(0, 1000): s.Get(keys[0]) s.Put(i, i)
def test01StoreExpiration(self): """Testing store removes objects when full.""" s = utils.FastStore(max_size=5) keys = [] for i in range(0, 100): keys.append(s.Put(i, i)) # This should not raise s.Get(keys[-1]) # This should raise though self.assertRaises(KeyError, s.Get, keys[0])
def __init__(self, certificate=None, private_key=None): """Creates a communicator. Args: certificate: Our own certificate. private_key: Our own private key. """ self.private_key = private_key self.certificate = certificate self._ClearServerCipherCache() # A cache for encrypted ciphers self.encrypted_cipher_cache = utils.FastStore(max_size=50000)
certificate=cert, first_seen=now, fleetspeak_enabled=False) index = client_index.CreateClientIndex(token=self.token) index.AddClient(client) if data_store.RelationalDBWriteEnabled(): index = client_index.ClientIndex() index.AddClient(data_migration.ConvertVFSGRRClient(client)) # Publish the client enrollment message. self.Publish("ClientEnrollment", self.client_id) self.Log("Enrolled %s successfully", self.client_id) enrolment_cache = utils.FastStore(5000) class Enroler(flow.WellKnownFlow): """Manage enrolment requests.""" well_known_session_id = rdfvalue.SessionID(queue=queues.ENROLLMENT, flow_name="Enrol") def ProcessMessage(self, message): """Begins an enrollment flow for this client. Args: message: The Certificate sent by the client. Note that this message is not authenticated. """
def __init__(self, certificate, private_key): super(RelationalServerCommunicator, self).__init__(certificate=certificate, private_key=private_key) self.pub_key_cache = utils.FastStore(max_size=50000) self.common_name = self.certificate.GetCN()
def __init__(self): self._routing_maps_cache = utils.FastStore()
def __init__(self): super(IPResolver, self).__init__() self.cache = utils.FastStore(max_size=100)