Java ConcurrentUtils.constantFuture方法代码示例

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public <T> Future<T> execute(final Controller controller, final BackgroundActionRegistry registry, final BackgroundAction<T> action) {
    if(log.isDebugEnabled()) {
        log.debug(String.format("Run action %s in background", action));
    }
    registry.add(action);
    action.init();
    // Start background task
    final Callable<T> command = new BackgroundCallable<T>(action, controller, registry);
    try {
        final Future<T> task = concurrentExecutor.execute(command);
        if(log.isInfoEnabled()) {
            log.info(String.format("Scheduled background runnable %s for execution", action));
        }
        return task;
    }
    catch(RejectedExecutionException e) {
        log.error(String.format("Error scheduling background task %s for execution. %s", action, e.getMessage()));
        action.cleanup();
        return ConcurrentUtils.constantFuture(null);
    }
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Before
public void setUp() {
	config = Configuration.buildFromConfig("config-mock.properties");
	when(connectionStrategy.getHttpClient()).thenReturn(asyncHttpClient);
	HttpResponse response = mock(HttpResponse.class);
	Future<HttpResponse> future = ConcurrentUtils.constantFuture(response);
	when(asyncHttpClient.execute(any(HttpUriRequest.class),any(FutureCallback.class))).thenReturn(future, null);
	HttpEntity httpEntity = mock(HttpEntity.class);
	when(response.getEntity()).thenReturn(httpEntity);
	StatusLine statusLine = mock(StatusLine.class);
	when(response.getStatusLine()).thenReturn(statusLine);
	when(statusLine.getStatusCode()).thenReturn(200);
	try {
		InputStream inputStream = IOUtils.toInputStream(SERVER_RESPONSE_EXPECTED, "UTF-8");
		when(httpEntity.getContent()).thenReturn(inputStream);
		client = new LogInsightClient(config, connectionStrategy);
		// client.connect(user, password);
		assertEquals("Invalid session id!!",
				"qyOLWEe7f/GjdM1WnczrCeQure97B/NpTbWTeqqYPBd1AYMf9cMNfQYqltITI4ffPMx822Sz9i/X47t8VwsDb0oGckclJUdn83cyIPk6WlsOpI4Yjw6WpurAnv9RhDsYSzKhAMzskzhTOJKfDHZjWR5v576WwtJA71wqI7igFrG91LG5c/3GfzMb68sUHF6hV+meYtGS4A1y/lUItvfkqTTAxBtTCZNoKrvCJZ4R+b6vuAAYoBNSWL7ycIy2LsALrVFxftAkA8n9DBAZYA9T5A==",
				client.getSessionId());
	} catch (Exception e) {
		logger.error("Exception raised " + ExceptionUtils.getStackTrace(e));
	}
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
/**
 * Reads LogValue from LogMap.
 * <p>
 * It will use the cached value if it exist, if not it will
 * get the value from distributed store.
 *
 * @param key log sequence number
 * @return Future containing log value
 */
public Future<LogValue> getLogValue(final SeqNum key) {
    try {
        return cache.get(key, new Callable<Future<LogValue>>() {

            @Override
            public Future<LogValue> call() throws Exception {
                return logMap.getAsync(key);
            }
        });
    } catch (ExecutionException e) {
        log.error("Reading from Log Map failed.", e);
        // should never happen?
        return ConcurrentUtils.constantFuture(null);
    }
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
public Future<Boolean> run(String...args) {
    String[] argA = new String[2 + args.length];
    argA[0] = DEFAULT_SHELL;
    argA[1] = scriptFile;
    for (int i = 0; i < args.length; i++) {
        argA[2+i] = args[i];
    }
    ProcessBuilder scriptPB = new ProcessBuilder(argA);
    scriptPB.redirectErrorStream(true);
    
    try {
        Process scriptProcess = scriptPB.start();
        Future<Boolean> scriptStatus = TimerManager.get().submit( new TrackShell(scriptProcess) );
        return scriptStatus;
    } catch (IOException e) {
        log.error("Error invoking script: " + scriptFile, e);
        return ConcurrentUtils.constantFuture(false);
    }
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
/**
 * Will queue up the <code>BackgroundAction</code> to be run in a background thread
 *
 * @param action The runnable to execute in a secondary thread
 */
@Override
public <T> Future<T> background(final BackgroundAction<T> action) {
    if(registry.contains(action)) {
        log.warn(String.format("Skip duplicate background action %s found in registry", action));
        return ConcurrentUtils.constantFuture(null);
    }
    return DefaultBackgroundExecutor.get().execute(this, registry, action);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public Future<Response> getJsonObject(
        SuccessCallback success,
        HttpErrorCallback error,
        FailureCallback failure,
        String resourcePath
) {
    LOG.info("Invoking test druid webservice: {}", this);

    // Store the most recent query sent through
    lastUrl = resourcePath;

    // Invoke failure callback if we have a throwable to give it
    if (throwable != null) {
        failure.invoke(throwable);
        return CompletedFuture.throwing(throwable);
    }

     try {
         if (statusCode == 200) {
            success.invoke(mapper.readTree(jsonResponse.call()));
        } else {
            error.invoke(statusCode, reasonPhrase, jsonResponse.call());
        }
    } catch (IOException e) {
        failure.invoke(e);
         return CompletedFuture.throwing(throwable);
    }

    return ConcurrentUtils.constantFuture(null);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T> FutureObject<T> saveAsync(Object object) {
    ObjectHolder objectHolder = new ObjectHolder(object);

    setIdIfNecessary(objectHolder);

    MockStore.put(objectHolder.getId(), object, tx());

    Future<?> futureId = ConcurrentUtils.constantFuture(objectHolder.getId());
    return new FutureObject<T>(r, (Future<IdRef<?>>) futureId, (T) object);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
public Future<TransferStatus> submit(final TransferCallable runnable) throws BackgroundException {
    return ConcurrentUtils.constantFuture(runnable.call());
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
/**
 * If TestDruidWebService#throwable is set, invokes the failure callback.  Otherwise invokes success or failure
 * dependent on whether TestDruidWebService#statusCode equals 200.
 * Note that since this doesn't send requests to druid all the responses will be null or {@link CompletedFuture}.
 */
@Override
@SuppressWarnings("checkstyle:cyclomaticcomplexity")
public Future<Response> postDruidQuery(
        RequestContext context,
        SuccessCallback success,
        HttpErrorCallback error,
        FailureCallback failure,
        DruidQuery<?> query
) {
    LOG.info("Invoking test druid webservice: {}", this);

    // Store the most recent query sent through
    lastQuery = query;

    // Convert the query to json
    try {
        jsonQuery = writer.withDefaultPrettyPrinter().writeValueAsString(query);
    } catch (JsonProcessingException ignored) {
        // Ignore
    }

    // Invoke failure callback if we have a throwable to give it
    if (throwable != null) {
        failure.invoke(throwable);
        return CompletedFuture.throwing(throwable);
    }

    if (lastQuery.getQueryType() instanceof DefaultQueryType) {
        // For known response types, create a default response provider

        // Set the response to use based on the type of the query we're processing
        DefaultQueryType defaultQueryType = (DefaultQueryType) lastQuery.getQueryType();
        switch (defaultQueryType) {
            case GROUP_BY:
            case TOP_N:
            case TIMESERIES:
            case LOOKBACK:
                // default response is groupBy response
                break;
            case SEGMENT_METADATA:
                jsonResponse = () -> segmentMetadataResponse;
                break;
            case TIME_BOUNDARY:
                jsonResponse = () -> timeBoundaryResponse;
                break;
            default:
                throw new IllegalArgumentException("Illegal query type : " + lastQuery.getQueryType());
        }

    } else {
        // Otherwise extended query types will have to set up their own responses
    }

    try {
        if (query instanceof WeightEvaluationQuery) {
            success.invoke(mapper.readTree(weightResponse));
        } else if (statusCode == 200) {
            success.invoke(mapper.readTree(jsonResponse.call()));
        } else {
            error.invoke(statusCode, reasonPhrase, jsonResponse.call());
        }
    } catch (IOException e) {
        failure.invoke(e);
        return CompletedFuture.throwing(e);
    }

    return ConcurrentUtils.constantFuture(null);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public Future<RecordMetadata> send(ProducerRecord record) {
  // Fake result: only for testing purpose
  return ConcurrentUtils.constantFuture(new RecordMetadata(null, 0, 0, 0, 0, 0, 0));
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public <T> FutureObject<T> fetchAsync(IdRef<T> id) {
    T object = fetch(id);
    Future<?> futureObject = ConcurrentUtils.constantFuture(object);
    return new FutureObject<>(r, futureObject);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public FutureObject<Void> destroyAsync(IdRef<?> id) {
    destroy(id);
    Future<Void> future = ConcurrentUtils.constantFuture(null);
    return new FutureObject<>(r, future);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <T> FutureObject<T> saveEntityAsync(ObjectHolder objectHolder, Entity entity) {
    Key key = datastore.put(entity);
    Future<?> futureId = ConcurrentUtils.constantFuture(IdRefToKey.toIdRef(r, key, objectHolder.getModel()));
    return new FutureObject<>(r, (Future<IdRef<?>>) futureId, (T) objectHolder.getObject());
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public <T> FutureObject<T> fetchAsync(IdRef<T> id) {
    T object = fetch(id);
    Future<?> futureObject = ConcurrentUtils.constantFuture(object);
    return new FutureObject<T>(r, futureObject);
}
 

import org.apache.commons.lang3.concurrent.ConcurrentUtils; //导入方法依赖的package包/类
@Override
public FutureObject<Void> destroyAsync(IdRef<?> id) {
    destroy(id);
    Future<Void> future = ConcurrentUtils.constantFuture(null);
    return new FutureObject<Void>(r, future);
}