private void dumpDescriptorsYaml(File descriptorsFile) throws IOException { try (LockStateYamlWriter writer = LockStateYamlWriter.create(descriptorsFile)) { writer.appendComment(WARNING_LOCK_DESCRIPTORS); writer.dumpObject(lockDescriptorMapper.getReversedMapper()); } } }
private void dumpYaml(List<Map<String, Object>> objects, File file, String prefix) throws IOException { try (LockStateYamlWriter writer = LockStateYamlWriter.create(file)) { writer.appendComment(prefix); for (Map<String, Object> object : objects) { writer.dumpObject(object); } } }
private void dumpYaml(List<Map<String, Object>> objects, File file) throws IOException { try (LockStateYamlWriter writer = LockStateYamlWriter.create(file)) { for (Map<String, Object> object : objects) { writer.dumpObject(object); } } }
public static SimpleLockRequest of(LockRequest request, String lockDescriptor, LockMode lockMode, String clientId) { return ImmutableSimpleLockRequest.builder() .lockDescriptor(lockDescriptor) .lockMode(lockMode) .lockCount(request.getLocks().size()) .lockTimeout(request.getLockTimeout().toMillis()) .lockGroupBehavior(request.getLockGroupBehavior()) .blockingMode(request.getBlockingMode()) .blockingDuration(extractBlockingDurationOrNull(request.getBlockingDuration())) .versionId(request.getVersionId()) .creatingThread(request.getCreatingThreadName()) .clientId(clientId).build(); }
public static SimpleTokenInfo of(HeldLocksToken token, LockMode lockMode) { return ImmutableSimpleTokenInfo.builder() .lockMode(lockMode) .expiresIn(token.getExpirationDateMs() - System.currentTimeMillis()) .createdAtTs(token.getCreationDateMs()) .tokenId(token.getTokenId().toString()) .clientId(Preconditions.checkNotNull(token.getClient()).getClientId()) .requestThread(token.getRequestingThread()) .createAt(new Date(token.getCreationDateMs()).toString()) .versionId(token.getVersionId()) .build(); }
static SanitizedLockRequestProgress create(LockServiceStateDebugger.LockRequestProgress progress, LockDescriptorMapper descriptorMapper, String clientId) { return ImmutableSanitizedLockRequestProgress.builder() .totalNumLocks(progress.getTotalNumLocks()) .numLocksAcquired(progress.getNumLocksAcquired()) .nextLock(progress.getNextLock().map(descriptorMapper::getDescriptorMapping) .orElse(UNKNOWN_NEXT_LOCK_MESSAGE)) .requests( StreamSupport.stream(progress.getRequest().getLockDescriptors().entries().spliterator(), false) .map(descriptor -> SimpleLockRequest.of( progress.getRequest(), descriptorMapper.getDescriptorMapping(descriptor.getKey()), descriptor.getValue(), clientId)) .collect(Collectors.toList())) .build(); } }
private Map<String, Object> generateOutstandingLocksYaml(Map<LockClient, Set<LockRequest>> outstandingLockRequestsMap) { Map<String, SimpleLockRequestsWithSameDescriptor> outstandingRequestMap = Maps.newHashMap(); outstandingLockRequestsMap.forEach((client, requestSet) -> { if (requestSet != null) { ImmutableSet<LockRequest> lockRequests = ImmutableSet.copyOf(requestSet); lockRequests.forEach(lockRequest -> { List<SimpleLockRequest> requestList = getDescriptorSimpleRequestMap(client, lockRequest); requestList.forEach(request -> { outstandingRequestMap.putIfAbsent(request.getLockDescriptor(), new SimpleLockRequestsWithSameDescriptor(request.getLockDescriptor())); outstandingRequestMap.get(request.getLockDescriptor()).addLockRequest(request); }); }); } }); List<SimpleLockRequestsWithSameDescriptor> sortedOutstandingRequests = sortOutstandingRequests(outstandingRequestMap.values()); return nameObjectForYamlConversion(OUTSTANDING_LOCK_REQUESTS_TITLE, sortedOutstandingRequests); }
public void logLocks() throws IOException { Map<String, Object> generatedOutstandingRequests = generateOutstandingLocksYaml(outstandingLockRequests); Map<String, Object> generatedHeldLocks = generateHeldLocks(heldLocks); Map<String, Object> generatedSyncState = generateSyncState(descriptorToLockMap); Map<String, Object> synthesizedRequestState = synthesizeRequestState(outstandingLockRequests, descriptorToLockMap); Path outputDirPath = Paths.get(outputDir); Files.createDirectories(outputDirPath); dumpYamlsInNewFiles( generatedOutstandingRequests, generatedHeldLocks, generatedSyncState, synthesizedRequestState); }
private void logAllHeldAndOutstandingLocks() throws IOException { LockServiceStateLogger lockServiceStateLogger = new LockServiceStateLogger( heldLocksTokenMap, outstandingLockRequestMultimap, descriptorToLockMap.asMap(), lockStateLoggerDir); lockServiceStateLogger.logLocks(); }
private void dumpYamlsInNewFiles( Map<String, Object> generatedOutstandingRequests, Map<String, Object> generatedHeldLocks, Map<String, Object> generatedSyncState, Map<String, Object> synthesizedRequestState) throws IOException { File lockStateFile = createNewFile(LOCKSTATE_FILE_PREFIX); File descriptorsFile = createNewFile(DESCRIPTORS_FILE_PREFIX); File syncStateFile = createNewFile(SYNC_STATE_FILE_PREFIX); File synthesizedRequestStateFile = createNewFile(SYNTHESIZED_REQUEST_STATE_FILE_PREFIX); dumpYaml(ImmutableList.of(generatedOutstandingRequests, generatedHeldLocks), lockStateFile); dumpYaml(ImmutableList.of(generatedSyncState), syncStateFile); dumpYaml(ImmutableList.of(synthesizedRequestState), synthesizedRequestStateFile, WARNING_SYNTHESIZE_ANONYMOUS); dumpDescriptorsYaml(descriptorsFile); }
@Test public void testSynthesizedRequestState() throws Exception { List<File> files = LockServiceTestUtils.logStateDirFiles(); Optional<File> synthesizedRequestStateFile = files.stream().filter( file -> file.getName().startsWith(LockServiceStateLogger.SYNTHESIZED_REQUEST_STATE_FILE_PREFIX)) .findFirst(); assertThat(synthesizedRequestStateFile).isPresent(); assertSynthesizedRequestStateStructureCorrect(synthesizedRequestStateFile.get()); assertDescriptorsNotPresentInFile(synthesizedRequestStateFile.get()); }
private Map<String, Object> generateSyncState(Map<LockDescriptor, ClientAwareReadWriteLock> descriptorToLockMap) { return nameObjectForYamlConversion(SYNC_STATE_TITLE, descriptorToLockMap.entrySet() .stream() .collect(Collectors.toMap( entry -> lockDescriptorMapper.getDescriptorMapping(entry.getKey()), entry -> ((LockServerLock) entry.getValue()).toSanitizedString()))); }
private Map<String, Object> getDescriptorToTokenMap(HeldLocksToken realToken) { Map<String, Object> lockToLockInfo = Maps.newHashMap(); realToken.getLocks().forEach( lock -> lockToLockInfo.put( this.lockDescriptorMapper.getDescriptorMapping(lock.getLockDescriptor()), SimpleTokenInfo.of(realToken, lock.getLockMode())) ); return lockToLockInfo; }
private List<SimpleLockRequest> getDescriptorSimpleRequestMap(LockClient client, LockRequest request) { return request.getLocks().stream() .map(lock -> SimpleLockRequest.of(request, this.lockDescriptorMapper.getDescriptorMapping(lock.getLockDescriptor()), lock.getLockMode(), client.getClientId())) .collect(Collectors.toList()); }
private Set<LockDescriptor> getAllDescriptors() { Set<LockDescriptor> allDescriptors = Sets.newHashSet(); allDescriptors.addAll(getOutstandingDescriptors()); allDescriptors.addAll(getHeldDescriptors()); return allDescriptors; }
LockDescriptorAwareRepresenter() { super(); this.representers.put(LockDescriptor.class, data -> representScalar(Tag.STR, data.toString())); } }
private List<SimpleLockRequestsWithSameDescriptor> sortOutstandingRequests( Collection<SimpleLockRequestsWithSameDescriptor> outstandingRequestsByDescriptor) { List<SimpleLockRequestsWithSameDescriptor> sortedEntries = Lists.newArrayList(outstandingRequestsByDescriptor); sortedEntries.sort( (o1, o2) -> Integer.compare(o2.getLockRequestsCount(), o1.getLockRequestsCount())); return sortedEntries; }
/** * Creates a LockStateYamlWriter for the given file in append mode. */ public static LockStateYamlWriter create(File file) throws IOException { return new LockStateYamlWriter(new BufferedWriter(new FileWriter(file, true))); }
@AfterClass public static void afterClass() throws IOException { LockServiceTestUtils.cleanUpLogStateDir(); }
private static Representer getRepresenter() { Representer representer = new LockDescriptorAwareRepresenter(); representer.addClassTag(ImmutableSimpleTokenInfo.class, Tag.MAP); representer.addClassTag(ImmutableSimpleLockRequest.class, Tag.MAP); representer.addClassTag(ImmutableSanitizedLockRequestProgress.class, Tag.MAP); representer.addClassTag(SimpleLockRequestsWithSameDescriptor.class, Tag.MAP); representer.addClassTag(LockDescriptor.class, Tag.MAP); return representer; }