private static Operation prepareOp(Operation op, State currentState) { if (currentState.operationTimeoutMicros != null) { op.setExpiration(Utils.fromNowMicrosUtc(currentState.operationTimeoutMicros)); } return op; }
private void prepareRequest(Operation op, boolean longRunningRequest) { op.forceRemote(); if (op.getExpirationMicrosUtc() == 0L) { long timeout; if (longRunningRequest) { timeout = TimeUnit.SECONDS .toMicros(ClosureProps.DOCKER_IMAGE_REQUEST_TIMEOUT_SECONDS); } else { timeout = ServiceHost.ServiceHostState.DEFAULT_OPERATION_TIMEOUT_MICROS; } op.setExpiration(ServiceUtils.getExpirationTimeFromNowInMicros(timeout)); } }
private void setExpiration(Operation op) { if (op.getExpirationMicrosUtc() != 0) { return; } long expMicros = this.host != null ? this.host.getOperationTimeoutMicros() : ServiceHostState.DEFAULT_OPERATION_TIMEOUT_MICROS; op.setExpiration(Utils.fromNowMicrosUtc(expMicros)); }
public void registerForServiceAvailability(CompletionHandler completion, String nodeSelectorPath, boolean checkReplica, String... servicePaths) { if (servicePaths == null || servicePaths.length == 0) { throw new IllegalArgumentException("selfLinks are required"); } Operation op = Operation.createPost(null) .setCompletion(completion) .setExpiration(Utils.fromNowMicrosUtc(getOperationTimeoutMicros())); registerForServiceAvailability(op, checkReplica, nodeSelectorPath, servicePaths); }
/** * Common settings on all outgoing requests to the docker server */ protected void prepareRequest(Operation op, boolean longRunningRequest) { op.setReferer(host.getPublicUri()) .addRequestHeader(Operation.REQUEST_AUTH_TOKEN_HEADER, "") .forceRemote(); if (op.getExpirationMicrosUtc() == 0) { long timeout = longRunningRequest ? TimeUnit.SECONDS.toMicros(DOCKER_IMAGE_REQUEST_TIMEOUT_SECONDS) : TimeUnit.SECONDS.toMicros(DOCKER_REQUEST_TIMEOUT_SECONDS); op.setExpiration(ServiceUtils.getExpirationTimeFromNowInMicros(timeout)); } }
public void ping(KubernetesContext context, CompletionHandler completionHandler) { URI uri = UriUtils.buildUri(context.host.address + KubernetesHostConstants.KUBERNETES_HOST_HEALTH_PATH); Operation op = Operation .createGet(uri) .setCompletion(completionHandler); prepareRequest(op, context); op.setExpiration(ServiceUtils.getExpirationTimeFromNowInMicros( TimeUnit.SECONDS.toMicros(10))); serviceClient.send(op); }
public static void registerForReplicatedServiceAvailability(ServiceHost host, CompletionHandler completion, AuthorizationContext authorizationContext, String nodeSelectorPath, String... servicePaths) { for (String link : servicePaths) { Operation op = Operation.createPost(host, link) .setCompletion(completion) .setExpiration(Utils.fromNowMicrosUtc(host.getOperationTimeoutMicros())); registerForReplicatedServiceAvailability(host, op, link, nodeSelectorPath, authorizationContext); } }
private void sendSynchRequest(URI parentUri, String documentSelfLink, CompletionHandler ch) { ServiceDocument synchState = new ServiceDocument(); synchState.documentSelfLink = documentSelfLink; Operation synchOp = Operation .createPost(this.host, parentUri.getPath()) .setBody(synchState) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_SYNCH_OWNER) .setReferer(this.host.getUri()) .setExpiration(Utils.fromNowMicrosUtc(NodeGroupService.PEER_REQUEST_TIMEOUT_MICROS)) .setCompletion((o, e) -> ch.handle(o, e)); this.host.handleRequest(null, synchOp); }
private void prepareRequest(Operation op, KubernetesContext context) { String authorizationHeaderValue = AuthUtils.createAuthorizationHeader(context.credentials); if (authorizationHeaderValue != null) { op.addRequestHeader(Operation.AUTHORIZATION_HEADER, authorizationHeaderValue); } createOrUpdateTargetSsl(context); op.setReferer(host.getPublicUri()); op.forceRemote(); setConnectionTag(context.credentials, op); if (op.getExpirationMicrosUtc() == 0) { long timeout = TimeUnit.SECONDS.toMicros(REQUEST_TIMEOUT_SECONDS); op.setExpiration(ServiceUtils.getExpirationTimeFromNowInMicros(timeout)); } }
private void callWebhook(String webHookUriStr, Closure closure) { logInfo("Calling execution container for closure: %s", closure.documentSelfLink); URI webHookUri = UriUtils.buildUri(webHookUriStr); sendRequest(Operation .createPost(webHookUri) .setExpiration(Utils.fromNowMicrosUtc(TimeUnit.SECONDS .toMicros(ClosureProps.DEFAULT_WEB_HOOK_EXPIRATION_TIMEOUT))) .setBody(closure) .setCompletion((op, ex) -> { if (ex != null) { logWarning("Unable to send closure state to: %s. Reason: %s", webHookUriStr, Utils.toString(ex)); } else { logInfo("Successfully sent closure state to: %s", webHookUri); } })); }
static void checkAndUpdateDocumentOwnership(ServiceHost host, Service service, long expirationTimeMicrosUtc, CompletionHandler ch) { Operation selectOwnerOp = Operation.createPost(null) .setExpiration(expirationTimeMicrosUtc); CompletionHandler c = (o, e) -> { if (e != null) { ch.handle(selectOwnerOp, e); return; } SelectOwnerResponse rsp = o.getBody(SelectOwnerResponse.class); service.toggleOption(ServiceOption.DOCUMENT_OWNER, rsp.isLocalHostOwner); ch.handle(selectOwnerOp, null); }; selectOwnerOp.setCompletion(c); host.selectOwner(service.getPeerNodeSelectorPath(), service.getSelfLink(), selectOwnerOp); }
@Test public void registerForServiceAvailabilityTimeout() throws Throwable { setUp(false); int c = 10; this.host.testStart(c); // issue requests to service paths we know do not exist, but induce the automatic // queuing behavior for service availability, by setting targetReplicated = true for (int i = 0; i < c; i++) { this.host.send(Operation .createGet(UriUtils.buildUri(this.host, UUID.randomUUID().toString())) .setExpiration(Utils.fromNowMicrosUtc(TimeUnit.SECONDS.toMicros(1))) .setCompletion(this.host.getExpectedFailureCompletion())); } this.host.testWait(); }
@Test public void registerForServiceAvailabilityTimeout() throws Throwable { setUp(false); int c = 10; this.host.testStart(c); // issue requests to service paths we know do not exist, but induce the automatic // queuing behavior for service availability, by setting targetReplicated = true for (int i = 0; i < c; i++) { this.host.send(Operation .createGet(UriUtils.buildUri(this.host, UUID.randomUUID().toString())) .setExpiration(Utils.fromNowMicrosUtc(TimeUnit.SECONDS.toMicros(1))) .setCompletion(this.host.getExpectedFailureCompletion())); } this.host.testWait(); }
private void sendPatchToBackupService(Operation op, String backupServiceLink, Object body) { Operation patch = Operation.createPatch(this, backupServiceLink) .transferRequestHeadersFrom(op) .transferRefererFrom(op) .setExpiration(op.getExpirationMicrosUtc()) .setBody(body) .setCompletion((o, e) -> { if (e != null) { op.fail(e); return; } op.transferResponseHeadersFrom(o); op.setBodyNoCloning(o.getBodyRaw()); op.complete(); }); sendRequest(patch); }
/** * Executes /stats request to the container state and copy its response to the GET operation. */ private void forwardStatsResponse(Operation op, ContainerState containerState) { sendRequest(Operation .createGet(UriUtils.buildStatsUri(getHost(), containerState.documentSelfLink)) .setExpiration(op.getExpirationMicrosUtc()) .setCompletion((o, e) -> { op.setBodyNoCloning(o.getBodyRaw()); op.setStatusCode(o.getStatusCode()); op.transferResponseHeadersFrom(o); if (e != null) { op.fail(e); } else { op.complete(); } })); }
@Test public void serviceStartExpiration() throws Throwable { setUp(false); long maintenanceIntervalMicros = TimeUnit.MILLISECONDS.toMicros(100); // set a small period so its pretty much guaranteed to execute // maintenance during this test this.host.setMaintenanceIntervalMicros(maintenanceIntervalMicros); // start a service but tell it to not complete the start POST. This will induce a timeout // failure from the host MinimalTestServiceState initialState = new MinimalTestServiceState(); initialState.id = MinimalTestService.STRING_MARKER_TIMEOUT_REQUEST; this.host.testStart(1); Operation startPost = Operation .createPost(UriUtils.buildUri(this.host, UUID.randomUUID().toString())) .setExpiration(Utils.fromNowMicrosUtc(maintenanceIntervalMicros)) .setBody(initialState) .setCompletion(this.host.getExpectedFailureCompletion()); this.host.startService(startPost, new MinimalTestService()); this.host.testWait(); }
@Test public void serviceStartExpiration() throws Throwable { setUp(false); long maintenanceIntervalMicros = TimeUnit.MILLISECONDS.toMicros(100); // set a small period so its pretty much guaranteed to execute // maintenance during this test this.host.setMaintenanceIntervalMicros(maintenanceIntervalMicros); // start a service but tell it to not complete the start POST. This will induce a timeout // failure from the host MinimalTestServiceState initialState = new MinimalTestServiceState(); initialState.id = MinimalTestService.STRING_MARKER_TIMEOUT_REQUEST; this.host.testStart(1); Operation startPost = Operation .createPost(UriUtils.buildUri(this.host, UUID.randomUUID().toString())) .setExpiration(Utils.fromNowMicrosUtc(maintenanceIntervalMicros)) .setBody(initialState) .setCompletion(this.host.getExpectedFailureCompletion()); this.host.startService(startPost, new MinimalTestService()); this.host.testWait(); }
public boolean isOwner(String documentSelfLink, String nodeSelector) { final boolean[] isOwner = new boolean[1]; log("Selecting owner for %s on %s", documentSelfLink, nodeSelector); TestContext ctx = this.testCreate(1); Operation op = Operation .createPost(null) .setExpiration(Utils.fromNowMicrosUtc(TimeUnit.SECONDS.toMicros(10))) .setCompletion((o, e) -> { if (e != null) { ctx.failIteration(e); return; } NodeSelectorService.SelectOwnerResponse rsp = o.getBody(NodeSelectorService.SelectOwnerResponse.class); log("Is owner: %s for %s", rsp.isLocalHostOwner, rsp.key); isOwner[0] = rsp.isLocalHostOwner; ctx.completeIteration(); }); this.selectOwner(nodeSelector, documentSelfLink, op); ctx.await(); return isOwner[0]; }
private void doConnectionLimitWithOperationTimeout(List<Service> services) { this.host.testStart(this.requestCount * services.size()); for (int i = 0; i < this.requestCount; i++) { for (Service service : services) { Operation getOp = Operation.createGet(service.getUri()) .setReferer(this.host.getReferer()) .setConnectionTag(this.host.connectionTag) .forceRemote() .setExpiration(Utils.getNowMicrosUtc() + 10) // Ignore timeout failures .setCompletion((o, e) -> this.host.completeIteration()); this.host.run(() -> this.host.send(getOp)); } } this.host.testWait(); validateTagInfo(this.host, this.host.getClient(), this.host.connectionTag, ServiceClient.DEFAULT_CONNECTION_LIMIT_PER_HOST); }
private void doConnectionLimitWithOperationTimeout(List<Service> services) { this.host.testStart(this.requestCount * services.size()); for (int i = 0; i < this.requestCount; i++) { for (Service service : services) { Operation getOp = Operation.createGet(service.getUri()) .setReferer(this.host.getReferer()) .setConnectionTag(this.host.connectionTag) .forceRemote() .setExpiration(Utils.getNowMicrosUtc() + 10) // Ignore timeout failures .setCompletion((o, e) -> this.host.completeIteration()); this.host.run(() -> this.host.send(getOp)); } } this.host.testWait(); validateTagInfo(this.host, this.host.getClient(), this.host.connectionTag, ServiceClient.DEFAULT_CONNECTION_LIMIT_PER_HOST); }