@Test public void testFinish() throws Exception { SourceOperator operator = createExchangeOperator(); operator.addSplit(newRemoteSplit(TASK_1_ID)); operator.addSplit(newRemoteSplit(TASK_2_ID)); operator.addSplit(newRemoteSplit(TASK_3_ID)); operator.noMoreSplits(); // add pages and leave buffers open taskBuffers.getUnchecked(TASK_1_ID).addPages(1, false); taskBuffers.getUnchecked(TASK_2_ID).addPages(1, false); taskBuffers.getUnchecked(TASK_3_ID).addPages(1, false); // read 3 pages waitForPages(operator, 3); // verify state assertEquals(operator.isFinished(), false); assertEquals(operator.needsInput(), false); assertEquals(operator.getOutput(), null); // finish without closing buffers operator.finish(); // wait for finished waitForFinished(operator); }
@Test public void test401ShouldRetry() { HttpCommand command = createMock(HttpCommand.class); HttpRequest request = createMock(HttpRequest.class); HttpResponse response = createMock(HttpResponse.class); @SuppressWarnings("unchecked") LoadingCache<Credentials, Access> cache = createMock(LoadingCache.class); BackoffLimitedRetryHandler backoffHandler = createMock(BackoffLimitedRetryHandler.class); expect(command.getCurrentRequest()).andReturn(request); cache.invalidateAll(); expectLastCall(); expect(response.getPayload()).andReturn(Payloads.newStringPayload("")).anyTimes(); expect(response.getStatusCode()).andReturn(401).atLeastOnce(); replay(command); replay(response); replay(cache); replay(backoffHandler); RetryOnRenew retry = new RetryOnRenew(cache, backoffHandler); assertTrue(retry.shouldRetryRequest(command, response)); verify(command); verify(response); verify(cache); }
@Test public void test401ShouldRetry4Times() { HttpCommand command = createMock(HttpCommand.class); HttpRequest request = createMock(HttpRequest.class); HttpResponse response = createMock(HttpResponse.class); @SuppressWarnings("unchecked") LoadingCache<Credentials, Access> cache = createMock(LoadingCache.class); BackoffLimitedRetryHandler backoffHandler = createMock(BackoffLimitedRetryHandler.class); expect(command.getCurrentRequest()).andReturn(request).anyTimes(); expect(request.getHeaders()).andStubReturn(null); cache.invalidateAll(); expectLastCall().anyTimes(); expect(response.getPayload()).andReturn(Payloads.newStringPayload("")).anyTimes(); expect(response.getStatusCode()).andReturn(401).anyTimes(); replay(command, request, response, cache); RetryOnRenew retry = new RetryOnRenew(cache, backoffHandler); for (int i = 0; i < RetryOnRenew.NUM_RETRIES - 1; ++i) { assertTrue(retry.shouldRetryRequest(command, response), "Expected retry to succeed"); } assertFalse( retry.shouldRetryRequest(command, response), "Expected retry to fail on attempt " + RetryOnRenew.NUM_RETRIES); verify(command, response, cache); }
@Override public void write(E entity) { Preconditions.checkState( state.equals(ReaderWriterState.OPEN), "Attempt to write to a writer in state:%s", state); accessor.keyFor(entity, provided, reusedKey); DatasetWriter<E> writer = cachedWriters.getIfPresent(reusedKey); if (writer == null) { // avoid checking in every whether the entity belongs in the view by only // checking when a new writer is created Preconditions.checkArgument( view.includes(entity), "View %s does not include entity %s", view, entity); // get a new key because it is stored in the cache StorageKey key = StorageKey.copy(reusedKey); try { writer = cachedWriters.getUnchecked(key); } catch (UncheckedExecutionException ex) { throw new IllegalArgumentException( "Problem creating view for entity: " + entity, ex.getCause()); } } writer.write(entity); }
@Test public void testWaitForNoMoreSplits() throws Exception { SourceOperator operator = createExchangeOperator(); // add a buffer location containing one page and close the buffer operator.addSplit(newRemoteSplit(TASK_1_ID)); // add pages and leave buffers open taskBuffers.getUnchecked(TASK_1_ID).addPages(1, true); // read page waitForPages(operator, 1); // verify state assertEquals(operator.isFinished(), false); assertEquals(operator.needsInput(), false); assertEquals(operator.getOutput(), null); // add a buffer location operator.addSplit(newRemoteSplit(TASK_2_ID)); // set no more splits (buffer locations) operator.noMoreSplits(); // add two pages and close the last buffer taskBuffers.getUnchecked(TASK_2_ID).addPages(2, true); // read all pages waitForPages(operator, 2); // wait for finished waitForFinished(operator); }
protected void put( Map<String, InputStream> map, LoadingCache<String, Node> store, String key, String id, String name) { assertEquals(store.size(), 0); assertEquals(map.size(), 0); map.put( key, new ByteArrayInputStream(String.format("id: %s\nname: %s\n", id, name).getBytes())); store.getUnchecked(key); }
@Override public ImmutableMap<K, V> getAll(final Iterable<? extends K> elementKeys) throws ExecutionException { final ImmutableMap.Builder<K, V> builder = ImmutableMap.builder(); for (final K key : elementKeys) { final LoadingCache<K, V> cache = getCache(key); if (cache != null) { final V value = cache.get(key); builder.put(key, value); } } return builder.build(); }
protected void remove( Map<String, InputStream> map, LoadingCache<String, Node> store, String key) { store.invalidate(key); assertEquals(store.size(), 0); map.remove(key); assertEquals(map.size(), 0); try { assertEquals(store.getUnchecked(key), null); fail("should not work as null is invalid"); } catch (UncheckedExecutionException e) { } assertEquals(map.get(key), null); }
@Override public FileObject getFileForOutput( Location location, String packageName, String relativeName, FileObject sibling) throws IOException { URI uri = uriForFileObject(location, packageName, relativeName); return inMemoryFileObjects.getUnchecked(uri); }
public void closeLogFile(String taskId) { try { logStreamCache.invalidate(taskId); } catch (Throwable throwable) { log.warn("Unable to close logfile for {}", taskId, throwable); } }
public void uncache(String identifier) { subjectCache.invalidate(identifier); PermissionsEx manager = plugin.getManager(); if (manager != null) { manager.uncache(getIdentifier(), identifier); } }
private <T> void evaluateBundle( final AppliedPTransform<?, ?, ?> transform, final CommittedBundle<T> bundle, final CompletionCallback onComplete) { TransformExecutorService transformExecutor; if (isKeyed(bundle.getPCollection())) { final StepAndKey stepAndKey = StepAndKey.of(transform, bundle.getKey()); // This executor will remain reachable until it has executed all scheduled transforms. // The TransformExecutors keep a strong reference to the Executor, the ExecutorService keeps // a reference to the scheduled TransformExecutor callable. Follow-up TransformExecutors // (scheduled due to the completion of another TransformExecutor) are provided to the // ExecutorService before the Earlier TransformExecutor callable completes. transformExecutor = executorServices.getUnchecked(stepAndKey); } else { transformExecutor = parallelExecutorService; } Collection<ModelEnforcementFactory> enforcements = MoreObjects.firstNonNull( transformEnforcements.get(transform.getTransform().getClass()), Collections.<ModelEnforcementFactory>emptyList()); TransformExecutor<T> callable = TransformExecutor.create( evaluationContext, registry, enforcements, bundle, transform, onComplete, transformExecutor); outstandingWork.incrementAndGet(); transformExecutor.schedule(callable); }
@Override public void update(final User user) { if (user == null) { throw new IllegalArgumentException("User can't null"); } if (Strings.isNullOrEmpty(user.getUsername())) { throw new IllegalArgumentException("Username of the user can't be null or empty"); } User old = find(user.getUsername()); String newEncryptPassword = generateEncryptPassword(user); if (!old.getPassword().equals(newEncryptPassword)) { user.setPassword(newEncryptPassword); } mongoDBUtil.keepConnect( userCollectionName, new CollectionCallback<Void>() { @Override public Void process(MongoCollection<Document> collection) { collection.updateOne( new Document(usernameKey, user.getUsername()), new Document("$set", new Document(usernameKey, user.getPassword()))); return null; } }); cache.put(user.getUsername(), user); }
public CodeView getCode(String id) { try { return cache.get(id + DELIMITER + CashregisterSession.get().getLocale().getLanguage()); } catch (ExecutionException e) { throw new WicketRuntimeException(e); } }
public void unlock(Object name) { Monitor lock; synchronized (stringLocks) { lock = stringLocks.getUnchecked(name); } lock.leave(); }
public static void updateRates(String type, long rate) { LOGGER.debug("updateRates : type={}, rate={}", type, rate); Iterator<RateLimiterDescriptor> iterator = rateLimiterMap.asMap().keySet().iterator(); while (iterator.hasNext()) { RateLimiterDescriptor oldRateDesc = iterator.next(); if (type.equals(oldRateDesc.getType())) { LOGGER.trace("updateRates : invalidated rate={}", oldRateDesc); rateLimiterMap.invalidate(oldRateDesc); RateLimiterDescriptor newRateDesc = new RateLimiterDescriptor(oldRateDesc.getType(), oldRateDesc.getAppId(), rate); LOGGER.trace("updateRates : updating rate desc={}, rate={}", newRateDesc, rate); rateLimiterMap.put(newRateDesc, RateLimiter.create(rate)); rateLimiterMap.refresh(newRateDesc); } } }
private static <K, V> Map<K, V> getAll(LoadingCache<K, V> cache, Iterable<K> keys) { try { return cache.getAll(keys); } catch (ExecutionException | UncheckedExecutionException | ExecutionError e) { throw Throwables.propagate(e.getCause()); } }
@Override protected List<DynamicProperty> create() { List<DynamicProperty> properties = new ArrayList<DynamicProperty>(); for (ObjectType type : getTypes()) { if (type.getObjectClass() == null) { continue; } String beanProperty = type.getJavaBeanProperty(); if (ObjectUtils.isBlank(beanProperty)) { continue; } try { properties.add( new DynamicProperty(type, beanProperty, beanPropertyIndexes.get(beanProperty))); } catch (Exception error) { // Failed introspection so probably not a valid bean // property. } } return ImmutableList.copyOf(properties); }
private void blockUntilRunningAndAssignElasticIpsToInstancesOrPutIntoBadMap( Set<RunningInstance> input, Map<NodeMetadata, Exception> badNodes) { Map<RegionAndName, RunningInstance> instancesById = Maps.uniqueIndex(input, instanceToRegionAndName); for (Map.Entry<RegionAndName, RunningInstance> entry : instancesById.entrySet()) { RegionAndName id = entry.getKey(); RunningInstance instance = entry.getValue(); try { logger.debug("<< allocating elastic IP instance(%s)", id); String ip = client.getElasticIPAddressServices().allocateAddressInRegion(id.getRegion()); // block until instance is running logger.debug(">> awaiting status running instance(%s)", id); AtomicReference<NodeMetadata> node = newReference(runningInstanceToNodeMetadata.apply(instance)); nodeRunning.apply(node); logger.trace("<< running instance(%s)", id); logger.debug(">> associating elastic IP %s to instance %s", ip, id); client .getElasticIPAddressServices() .associateAddressInRegion(id.getRegion(), ip, id.getName()); logger.trace("<< associated elastic IP %s to instance %s", ip, id); // add mapping of instance to ip into the cache elasticIpCache.put(id, ip); } catch (RuntimeException e) { badNodes.put(runningInstanceToNodeMetadata.apply(instancesById.get(id)), e); } } }
private static <K, V> V get(LoadingCache<K, V> cache, K key) { try { return cache.get(key); } catch (ExecutionException | UncheckedExecutionException | ExecutionError e) { throw Throwables.propagate(e.getCause()); } }
@Override public Response<List<Address>> ancestorOfAddresses(Integer anyId) { Response<List<Address>> result = new Response<List<Address>>(); if (anyId == null) { log.error("id can not be null"); result.setError("params.not.null"); return result; } List<Address> addresses = Lists.newArrayListWithExpectedSize(3); try { Integer id = anyId; while (id > 0) { Address address = addressCache.getUnchecked(id); addresses.add(address); id = address.getParentId(); } result.setResult(addresses); return result; } catch (Exception e) { log.error( "failed find ancestors of address(id={}), cause:{}", anyId, Throwables.getStackTraceAsString(e)); result.setError("ancestor.query.fail"); return result; } }
@VisibleForTesting public Set<String> getSecurityGroupsForTagAndOptions( String region, @Nullable String group, TemplateOptions options) { Builder<String> groups = ImmutableSet.builder(); if (group != null) { String markerGroup = namingConvention.create().sharedNameForGroup(group); groups.add(markerGroup); RegionNameAndIngressRules regionNameAndIngressRulesForMarkerGroup; if (userSpecifiedTheirOwnGroups(options)) { regionNameAndIngressRulesForMarkerGroup = new RegionNameAndIngressRules(region, markerGroup, new int[] {}, false); groups.addAll(EC2TemplateOptions.class.cast(options).getGroups()); } else { regionNameAndIngressRulesForMarkerGroup = new RegionNameAndIngressRules(region, markerGroup, options.getInboundPorts(), true); } // this will create if not yet exists. securityGroupMap.getUnchecked(regionNameAndIngressRulesForMarkerGroup); } return groups.build(); }
@VisibleForTesting public CxxPreprocessAndCompile createPreprocessBuildRule(String name, CxxSource source) { Preconditions.checkArgument(CxxSourceTypes.isPreprocessableType(source.getType())); BuildTarget target = createPreprocessBuildTarget(name, source.getType()); PreprocessorDelegate preprocessorDelegate = preprocessorDelegates.getUnchecked( PreprocessAndCompilePreprocessorDelegateKey.of(source.getType(), source.getFlags())); // Build the CxxCompile rule and add it to our sorted set of build rules. CxxPreprocessAndCompile result = CxxPreprocessAndCompile.preprocess( getParams() .copyWithChanges( target, new DepsBuilder() .addPreprocessDeps() .add(preprocessorDelegate.getPreprocessor()) .add(source), Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())), getPathResolver(), preprocessorDelegate, new CompilerDelegate( getPathResolver(), getCxxPlatform().getDebugPathSanitizer(), getCompiler(source.getType()), computeCompilerFlags(source.getType(), source.getFlags())), getPreprocessOutputPath(target, source.getType(), name), source.getPath(), source.getType(), getCxxPlatform().getDebugPathSanitizer()); getResolver().addToIndex(result); return result; }
public boolean tryLock(Object name) { Monitor lock; synchronized (stringLocks) { lock = stringLocks.getUnchecked(name); } return lock.tryEnter(); }
TopLevelItem get(LazyTopLevelItem.Key key) { try { return cache.get(key); } catch (ExecutionException ex) { Logger.getLogger(TopLevelItemsCache.class.getName()).log(Level.SEVERE, null, ex); return null; } }
public UserInfo loadUserInfo(final PendingOIDCAuthenticationToken token) { try { return cache.get(token); } catch (UncheckedExecutionException | ExecutionException e) { logger.warn("Couldn't load User Info from token: " + e.getMessage()); return null; } }
@NotNull private PackageDetails refreshAndGetPackageDetailsFromPyPI( @NotNull String packageName, boolean alwaysRefresh) throws IOException { if (alwaysRefresh) { myPackageToDetails.invalidate(packageName); } return getCachedValueOrRethrowIO(myPackageToDetails, packageName); }
/** * Implemented as specified in {@link QuantumStrategy}. * * @see QuantumStrategy#quantize(double) */ @Override public int quantize(double value) throws QuantizationException { try { return values.get(getMiddleRange(value)); } catch (ExecutionException e) { throw new QuantizationException(e); } }
/** * Makes sure that name is a valid repository name and creates a new RepositoryName using it. * * @throws LabelSyntaxException if the name is invalid */ public static RepositoryName create(String name) throws LabelSyntaxException { try { return repositoryNameCache.get(name); } catch (ExecutionException e) { Throwables.propagateIfInstanceOf(e.getCause(), LabelSyntaxException.class); throw new IllegalStateException("Failed to create RepositoryName from " + name, e); } }
private Mustache compileIfChanged(String filename, boolean partial) { Mustache template = mustacheCache.getIfPresent(filename); if (template == null) { String desc = partial ? "partial" : "template"; Log.debug("Compiling Mustache " + desc, "name", filename); Res res = getResource(filename, partial); template = customCompile(filename, res); res.onChange( "mustache", new Runnable() { @Override public void run() { invalidateCache(); } }) .trackChanges(); mustacheCache.put(filename, template); } return template; }