@Override public void run() { cleanUp(); } }, 5000, 5000);
private List<String> isAddressesAvailable(Collection<String> addresses) { if (addresses.size() == 0) return new ArrayList<>(); List<String> unavailableAddressesCache = nameCache.lockAddressList(addresses); if (unavailableAddressesCache.size() > 0) { return unavailableAddressesCache; } List<String> unavailableAddressesLedger = ledger.isAllAddressesAvailable(addresses); if (unavailableAddressesLedger.size() > 0) { nameCache.unlockAddressList(addresses); return unavailableAddressesLedger; } return new ArrayList<>(); }
private List<String> isNamesAvailable(Collection<String> reducedNames) { if (reducedNames.size() == 0) return new ArrayList<>(); List<String> unavailableNamesCache = nameCache.lockNameList(reducedNames); if (unavailableNamesCache.size() > 0) { return unavailableNamesCache; } List<String> unavailableNamesLedger = ledger.isAllNameRecordsAvailable(reducedNames); if (unavailableNamesLedger.size() > 0) { nameCache.unlockNameList(reducedNames); return unavailableNamesLedger; } return new ArrayList<>(); }
private List<String> lockStringList(String prefix, Collection<String> stringList) { List<String> unavailableStrings = new ArrayList<>(); List<String> lockedByThisCall = new ArrayList<>(); for (String str : stringList) { String strWithPrefix = prefix + str; if (lockStringValue(strWithPrefix)) { lockedByThisCall.add(strWithPrefix); } else { unavailableStrings.add(str); } } if (unavailableStrings.size() > 0) { for (String rn : lockedByThisCall) unlockStringValue(rn); } return unavailableStrings; }
private List<String> isOriginsAvailable(Collection<HashId> origins) { if (origins.size() == 0) return new ArrayList<>(); List<String> unavailableOriginsCache = nameCache.lockOriginList(origins); if (unavailableOriginsCache.size() > 0) { return unavailableOriginsCache; } List<String> unavailableOriginsLedger = ledger.isAllOriginsAvailable(origins); if (unavailableOriginsLedger.size() > 0) { nameCache.unlockOriginList(origins); return unavailableOriginsLedger; } return new ArrayList<>(); }
@Test public void multiLock() throws Exception { NameCache nameCache = new NameCache(Duration.ofMillis(10)); List<HashId> values1hashes = Arrays.asList(HashId.createRandom(), HashId.createRandom(), HashId.createRandom()); List<HashId> values2hashes = Arrays.asList(HashId.createRandom(), HashId.createRandom()); assertTrue(nameCache.lockNameList(values1).isEmpty()); assertFalse(nameCache.lockNameList(valuesEx).isEmpty()); assertTrue(nameCache.lockNameList(values2).isEmpty()); assertTrue(nameCache.lockOriginList(values1hashes).isEmpty()); assertFalse(nameCache.lockOriginList(valuesExhashes).isEmpty()); assertTrue(nameCache.lockOriginList(values2hashes).isEmpty()); assertTrue(nameCache.lockAddressList(values1).isEmpty()); assertFalse(nameCache.lockAddressList(valuesEx).isEmpty()); assertTrue(nameCache.lockAddressList(values2).isEmpty()); nameCache.unlockNameList(values1); nameCache.unlockOriginList(values1hashes); nameCache.unlockAddressList(values1); assertFalse(nameCache.lockNameList(valuesEx).isEmpty()); assertFalse(nameCache.lockOriginList(valuesExhashes).isEmpty()); assertFalse(nameCache.lockAddressList(valuesEx).isEmpty()); nameCache.unlockNameList(values2); nameCache.unlockOriginList(values2hashes); nameCache.unlockAddressList(values2);
@Test public void busyTest() throws Exception { NameCache nameCache = new NameCache(Duration.ofMillis(10)); String testName = "testName"; assertEquals(true, nameCache.lockNameList(Arrays.asList(testName)).isEmpty()); assertEquals(false, nameCache.lockNameList(Arrays.asList(testName)).isEmpty()); Thread.sleep(15); nameCache.cleanUp(); assertEquals(true, nameCache.lockNameList(Arrays.asList(testName)).isEmpty()); nameCache.unlockNameList(Arrays.asList(testName)); assertEquals(true, nameCache.lockNameList(Arrays.asList(testName)).isEmpty()); }
@Override public List<ErrorRecord> tryAllocate(Collection<String> reducedNamesToAllocate, Collection<HashId> originsToAllocate, Collection<String> addressesToAllocate) { List<String> namesErrors = isNamesAvailable(reducedNamesToAllocate); List<String> originsErrors = isOriginsAvailable(originsToAllocate); List<String> addressesErros = isAddressesAvailable(addressesToAllocate); boolean checkResult = namesErrors.isEmpty() && originsErrors.isEmpty() && addressesErros.isEmpty(); if (!checkResult) { if (namesErrors.isEmpty()) nameCache.unlockNameList(reducedNamesToAllocate); if (originsErrors.isEmpty()) nameCache.unlockOriginList(originsToAllocate); if (addressesErros.isEmpty()) nameCache.unlockAddressList(addressesToAllocate); } List<ErrorRecord> res = new ArrayList<>(); for (String s : namesErrors) res.add(new ErrorRecord(Errors.FAILED_CHECK, "names", "name '"+s+"' is not available")); for (String s : originsErrors) res.add(new ErrorRecord(Errors.FAILED_CHECK, "origins", "origin '"+s+"' is not available")); for (String s : addressesErros) res.add(new ErrorRecord(Errors.FAILED_CHECK, "addresses", "address '"+s+"' is not available")); return res; }
parcelCache = new ParcelCache(config.getMaxCacheAge()); envCache = new EnvCache(config.getMaxCacheAge()); nameCache = new NameCache(config.getMaxNameCacheAge()); config.updateConsensusConfig(network.getNodesCount());
public List<String> lockNameList(Collection<String> reducedNameList) { return lockStringList(NAME_PREFIX, reducedNameList); }
nameCache.unlockAddressList(addressList); nameCache.unlockNameList(nameList); nameCache.unlockOriginList(originsList);
public List<String> lockAddressList(Collection<String> addressList) { return lockStringList(ADDRESS_PREFIX, addressList); }
public List<String> lockOriginList(Collection<HashId> originList) { List<String> stringList = new ArrayList<>(); for (HashId origin : originList) stringList.add(origin.toBase64String()); return lockStringList(ORIGIN_PREFIX, stringList); }