() {
36 | @Override
37 | protected Chunk initialValue() {
38 | return claim();
39 | };
40 | };
41 |
42 | private static Chunk claim() {
43 | long newMax = _nextFreeId.addAndGet(CHUNK_SIZE);
44 | return new Chunk(newMax - CHUNK_SIZE, newMax);
45 | }
46 |
47 | public static long getNextId() {
48 | Chunk chunk = CHUNK.get();
49 | if (chunk.isEmpty()) {
50 | chunk = claim();
51 | CHUNK.set(chunk);
52 | }
53 | return chunk.next();
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/PlanBasedRateLimiter.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 |
6 | /**
7 | * Rate limiter that can apply throttling on plan class.
8 | *
9 | * @author Min Chen (mnchen@linkedin.com)
10 | */
11 | public interface PlanBasedRateLimiter {
12 | /**
13 | * Try acquire a rate limit permit for the given plan class.
14 | * @param planClass plan class name.
15 | * @return true if a permit is granted, false otherwise.
16 | */
17 | boolean tryAcquire(String planClass);
18 |
19 | /**
20 | * Try acquire a rate limit permit for the given plan class within the specified
21 | * time window.
22 | * @param planClass plan class name.
23 | * @param timeout timeout window
24 | * @param unit timeout unit.
25 | * @return true if a permit is granted within the time window, false otherwise.
26 | * @throws InterruptedException
27 | */
28 | boolean tryAcquire(String planClass, long timeout, TimeUnit unit) throws InterruptedException;
29 |
30 | /**
31 | * Acquire a rate limit permit, blocking until the permit is granted.
32 | * @param planClass plan class name.
33 | * @throws InterruptedException
34 | */
35 | void acquire(String planClass) throws InterruptedException;
36 |
37 | /**
38 | * Release a rate limit permit for the given plan class.
39 | * @param planClass plan class name
40 | */
41 | void release(String planClass);
42 | }
43 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/PlanCompletionListener.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | /**
4 | * @author Ang Xu
5 | */
6 | public interface PlanCompletionListener {
7 |
8 | void onPlanCompleted(PlanContext planContext);
9 |
10 | }
11 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/PlanDeactivationListener.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import com.linkedin.parseq.EngineBuilder;
4 |
5 | /**
6 | * This listener interface allows receiving notifications about plan deactivation.
7 | * It can be used for monitoring and to optimize task implementation e.g. to implement batching.
8 | * @see EngineBuilder#setPlanDeactivationListener(PlanDeactivationListener) for details
9 | *
10 | * @author Jaroslaw Odzga (jodzga@linkedin.com)
11 | *
12 | */
13 | public interface PlanDeactivationListener {
14 |
15 | void onPlanDeactivated(PlanContext planContext);
16 |
17 | }
18 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/PlatformClock.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 | /**
6 | * Default implementation of Clock interface that delegates to default Java platform's nano timer.
7 | *
8 | * @author Jaroslaw Odzga (jodzga@linkedin.com)
9 | *
10 | */
11 | public class PlatformClock implements Clock {
12 |
13 | @Override
14 | public long nanoTime() {
15 | return System.nanoTime();
16 | }
17 |
18 | @Override
19 | public void sleepNano(long nano) throws InterruptedException {
20 | TimeUnit.NANOSECONDS.sleep(nano);
21 | }
22 |
23 | }
24 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/Prioritizable.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.internal;
18 |
19 | /**
20 | * @author Chris Pettitt (cpettitt@linkedin.com)
21 | */
22 | public interface Prioritizable {
23 | int getPriority();
24 | }
25 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/PrioritizableRunnable.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.internal;
18 |
19 | import com.linkedin.parseq.Priority;
20 |
21 |
22 | /**
23 | * @author Chris Pettitt (cpettitt@linkedin.com)
24 | */
25 | public interface PrioritizableRunnable extends Runnable, Prioritizable {
26 |
27 | @Override
28 | default int getPriority() {
29 | return Priority.DEFAULT_PRIORITY;
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/SerialExecutionException.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | public class SerialExecutionException extends Exception {
4 | private static final long serialVersionUID = 0L;
5 |
6 | public SerialExecutionException(String msg, Throwable error) {
7 | super(msg, error);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/SystemHiddenTask.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import com.linkedin.parseq.BaseTask;
4 | import com.linkedin.parseq.function.Function1;
5 |
6 |
7 | /**
8 | * Base class for system hidden tasks. It has exactly the same behavior as {@link BaseTask}
9 | * except the visibility of a trace created by this class is system hidden.
10 | *
11 | * Instead of extending this class consider using
12 | *
13 | * {@link com.linkedin.parseq.Task#async(String, Function1)}.
14 | * @see com.linkedin.parseq.Task#async(String, Function1)
15 | */
16 | public abstract class SystemHiddenTask extends BaseTask {
17 | protected SystemHiddenTask(String name) {
18 | super(name);
19 | _shallowTraceBuilder.setSystemHidden(true);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/TimeUnitHelper.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 |
6 | public class TimeUnitHelper {
7 |
8 | private static final String[] names = new String[] { "ns", "us", "ms", "s", "min", "h", "d" };
9 |
10 | public static String toString(TimeUnit unit) {
11 | return names[unit.ordinal()];
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/internal/UncaughtExceptionHandler.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | /**
4 | * A handler that is invoked whenever the {@link SerialExecutor}'s execution loop
5 | * throws an uncaught exception.
6 | */
7 | public interface UncaughtExceptionHandler {
8 | /**
9 | * This method is invoked whenever a {@link SerialExecutor}'s execution loop throws
10 | * an uncaught exception
11 | *
12 | * @param error the error that was raised by the underlying executor.
13 | */
14 | void uncaughtException(Throwable error);
15 | }
16 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Core ParSeq classes.
3 | * See {@link com.linkedin.parseq.Task} for methods to create common types of Tasks.
4 | */
5 | package com.linkedin.parseq;
6 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/PromiseException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.promise;
18 |
19 | /**
20 | * A general exception indicating that there was a {@link Promise} related
21 | * error.
22 | *
23 | * @author Chris Pettitt (cpettitt@linkedin.com)
24 | */
25 | public class PromiseException extends RuntimeException {
26 | private static final long serialVersionUID = 1L;
27 |
28 | public PromiseException(final String message) {
29 | super(message);
30 | }
31 |
32 | public PromiseException(final Throwable cause) {
33 | super(cause);
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/PromisePropagator.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.promise;
2 |
3 | import java.util.function.BiConsumer;
4 |
5 |
6 | public interface PromisePropagator extends BiConsumer, Settable> {
7 |
8 | default PromisePropagator compose(final PromisePropagator propagator) {
9 | final PromisePropagator that = this;
10 | return (src, dst) -> {
11 | that.accept(src, new Settable() {
12 | @Override
13 | public void done(T value) throws PromiseResolvedException {
14 | propagator.accept(Promises.value(value), dst);
15 | }
16 |
17 | @Override
18 | public void fail(Throwable error) throws PromiseResolvedException {
19 | propagator.accept(Promises.error(error), dst);
20 | }
21 | });
22 | };
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/PromiseResolvedException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.promise;
18 |
19 | /**
20 | * This exception is thrown when attempting to set a value or error on a promise
21 | * that is already resolved (i.e. already has a value or error). A promise can
22 | * only be resolved once.
23 | *
24 | * @author Chris Pettitt (cpettitt@linkedin.com)
25 | */
26 | public class PromiseResolvedException extends PromiseException {
27 | private static final long serialVersionUID = 1L;
28 |
29 | public PromiseResolvedException(final String message) {
30 | super(message);
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/PromiseUnresolvedException.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.promise;
18 |
19 | /**
20 | * This exception is thrown when attempting to get a value from a promise
21 | * that has not yet finished. Use {@link Promise#addListener(PromiseListener)}
22 | * or {@link com.linkedin.parseq.promise.Promise#await()} to wait for the
23 | * completion of the promise before getting it's value.
24 | *
25 | * @author Chris Pettitt (cpettitt@linkedin.com)
26 | */
27 | public class PromiseUnresolvedException extends PromiseException {
28 | private static final long serialVersionUID = 1L;
29 |
30 | public PromiseUnresolvedException(final String message) {
31 | super(message);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/ResolvedError.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.promise;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 |
6 | public class ResolvedError implements Promise {
7 |
8 | private final Throwable _error;
9 |
10 | public ResolvedError(Throwable error) {
11 | _error = error;
12 | }
13 |
14 | @Override
15 | public T get() throws PromiseException {
16 | throw new PromiseException(_error);
17 | }
18 |
19 | @Override
20 | public Throwable getError() throws PromiseUnresolvedException {
21 | return _error;
22 | }
23 |
24 | @Override
25 | public T getOrDefault(T defaultValue) throws PromiseUnresolvedException {
26 | return defaultValue;
27 | }
28 |
29 | @Override
30 | public void await() throws InterruptedException {
31 | }
32 |
33 | @Override
34 | public boolean await(long time, TimeUnit unit) throws InterruptedException {
35 | return true;
36 | }
37 |
38 | @Override
39 | public void addListener(PromiseListener listener) {
40 | listener.onResolved(this);
41 | }
42 |
43 | @Override
44 | public boolean isDone() {
45 | return true;
46 | }
47 |
48 | @Override
49 | public boolean isFailed() {
50 | return true;
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/ResolvedValue.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.promise;
2 |
3 | import java.util.concurrent.TimeUnit;
4 |
5 | import org.slf4j.Logger;
6 | import org.slf4j.LoggerFactory;
7 |
8 |
9 | public class ResolvedValue implements Promise {
10 |
11 | private static final Logger LOGGER = LoggerFactory.getLogger(ResolvedValue.class);
12 |
13 | private final T _value;
14 |
15 | public ResolvedValue(T value) {
16 | _value = value;
17 | }
18 |
19 | @Override
20 | public T get() throws PromiseException {
21 | return _value;
22 | }
23 |
24 | @Override
25 | public Throwable getError() throws PromiseUnresolvedException {
26 | return null;
27 | }
28 |
29 | @Override
30 | public T getOrDefault(T defaultValue) throws PromiseUnresolvedException {
31 | return _value;
32 | }
33 |
34 | @Override
35 | public void await() throws InterruptedException {
36 | }
37 |
38 | @Override
39 | public boolean await(long time, TimeUnit unit) throws InterruptedException {
40 | return true;
41 | }
42 |
43 | @Override
44 | public void addListener(PromiseListener listener) {
45 | try {
46 | listener.onResolved(this);
47 | } catch (Throwable e) {
48 | LOGGER.warn("An exception was thrown by listener: " + listener.getClass(), e);
49 | }
50 | }
51 |
52 | @Override
53 | public boolean isDone() {
54 | return true;
55 | }
56 |
57 | @Override
58 | public boolean isFailed() {
59 | return false;
60 | }
61 |
62 | }
63 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/Settable.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.promise;
2 |
3 | public interface Settable {
4 | /**
5 | * Sets the value for this promise to the given value.
6 | *
7 | * The guarantee is that after this method is finished the promise
8 | * has been completed but it is not guaranteed that all listeners have been
9 | * called. Listeners can be notified shortly after this method returns.
10 | *
11 | * @param value the value to set on this promise.
12 | * @throws PromiseResolvedException if the promise already has a value set.
13 | */
14 | void done(P value) throws PromiseResolvedException;
15 |
16 | /**
17 | * Sets an error on this promise.
18 | *
19 | * The guarantee is that after this method is finished the promise
20 | * has been completed but it is not guaranteed that all listeners have been
21 | * called. Listeners can be notified shortly after this method returns.
22 | *
23 | * @param error the error to set on this promise
24 | * @throws PromiseResolvedException if the promise already has a value set.
25 | */
26 | void fail(Throwable error) throws PromiseResolvedException;
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/SettablePromise.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.promise;
18 |
19 | /**
20 | * A {@link Promise} that can have its value set.
21 | *
22 | * @author Chris Pettitt (cpettitt@linkedin.com)
23 | */
24 | public interface SettablePromise
extends Promise
, Settable
{
25 | }
26 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/TransformingPromiseListener.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.promise;
18 |
19 | public class TransformingPromiseListener implements PromiseListener {
20 | private final Settable _dest;
21 | private final PromisePropagator _propagator;
22 |
23 | public TransformingPromiseListener(final Settable dest, final PromisePropagator propagator) {
24 | _dest = dest;
25 | _propagator = propagator;
26 | }
27 |
28 | @Override
29 | public void onResolved(final Promise resolvedPromise) {
30 | _propagator.accept(resolvedPromise, _dest);
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/promise/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Promises are like {@link java.util.concurrent.Future}s, but they provide
3 | * a listener mechanism to wait for completion asynchronously.
4 | *
5 | * @see com.linkedin.parseq.promise.Promise for details about the Promise
6 | * API.
7 | * @see com.linkedin.parseq.promise.Promises for convenience methods to create Promises.
8 | */
9 | package com.linkedin.parseq.promise;
10 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/ErrorClassification.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry;
2 |
3 | import java.util.concurrent.CancellationException;
4 | import java.util.function.Function;
5 |
6 |
7 | /**
8 | * Definitions of the supported error classifications and the default classification function.
9 | *
10 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
11 | */
12 | public enum ErrorClassification {
13 | /** The classification of errors that will interrupt the retry operation. */
14 | UNRECOVERABLE,
15 |
16 | /** The classification of errors that will not interrupt the retry operation. */
17 | RECOVERABLE;
18 |
19 | /** Default error classification: non-fatal errors are recoverable, and fatal errors are not recoverable. */
20 | public static final Function DEFAULT = throwable ->
21 | nonFatal(throwable) ? ErrorClassification.RECOVERABLE : ErrorClassification.UNRECOVERABLE;
22 |
23 | protected static boolean nonFatal(Throwable throwable) {
24 | return throwable instanceof StackOverflowError || !(throwable instanceof VirtualMachineError || throwable instanceof ThreadDeath
25 | || throwable instanceof InterruptedException || throwable instanceof LinkageError || throwable instanceof CancellationException);
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/backoff/ConstantBackoff.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.backoff;
2 |
3 |
4 | /**
5 | * A policy that uses the same backoff after every retry.
6 | *
7 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
8 | */
9 | public class ConstantBackoff implements BackoffPolicy {
10 | protected final long _backoff;
11 |
12 | /**
13 | * A policy that uses the same backoff after every retry.
14 | *
15 | * @param backoff The backoff used for every retry.
16 | */
17 | public ConstantBackoff(final long backoff) {
18 | _backoff = backoff;
19 | }
20 |
21 | /**
22 | * {@inheritDoc}
23 | */
24 | @Override
25 | public long nextBackoff(int attempts, Throwable error) {
26 | return _backoff;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/backoff/ExponentialBackoff.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.backoff;
2 |
3 |
4 | /**
5 | * A policy that doubles the backoff duration after every attempt.
6 | *
7 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
8 | */
9 | public class ExponentialBackoff implements BackoffPolicy {
10 | protected final long _backoff;
11 |
12 | /**
13 | * A policy that doubles the backoff duration after every attempt.
14 | *
15 | * @param backoff The backoff used for the first retry as well as the base for all subsequent attempts.
16 | */
17 | public ExponentialBackoff(final long backoff) {
18 | _backoff = backoff;
19 | }
20 |
21 | /**
22 | * {@inheritDoc}
23 | */
24 | @Override
25 | public long nextBackoff(int attempts, Throwable error) {
26 | return (1L << attempts - 1) * _backoff;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/backoff/FibonacciBackoff.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.backoff;
2 |
3 |
4 | /**
5 | * A policy that increases the initial backoff duration by repeatedly multiplying by an approximation of the golden
6 | * ratio (8 / 5, the sixth and fifth fibonacci numbers).
7 | *
8 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
9 | */
10 | public class FibonacciBackoff implements BackoffPolicy {
11 | protected final long _backoff;
12 |
13 | /**
14 | * A policy that increases the initial backoff duration by repeatedly multiplying by an approximation of the golden
15 | * ratio (8 / 5, the sixth and fifth fibonacci numbers).
16 | *
17 | * @param backoff The backoff used for the first retry as well as the base for all subsequent attempts.
18 | */
19 | public FibonacciBackoff(final long backoff) {
20 | _backoff = backoff;
21 | }
22 |
23 | /**
24 | * {@inheritDoc}
25 | */
26 | @Override
27 | public long nextBackoff(int attempts, Throwable error) {
28 | return Math.round(Math.pow(1.6, attempts - 1) * _backoff);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/backoff/LinearBackoff.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.backoff;
2 |
3 |
4 | /**
5 | * A policy that increases the backoff duration by the same amount after every retry.
6 | *
7 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
8 | */
9 | public class LinearBackoff implements BackoffPolicy {
10 | protected final long _backoff;
11 |
12 | /**
13 | * A policy that increases the backoff duration by the same amount after every retry.
14 | *
15 | * @param backoff The backoff used for the first retry as well as the base for all subsequent attempts.
16 | */
17 | public LinearBackoff(final long backoff) {
18 | _backoff = backoff;
19 | }
20 |
21 | /**
22 | * {@inheritDoc}
23 | */
24 | @Override
25 | public long nextBackoff(int attempts, Throwable error) {
26 | return attempts * _backoff;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/backoff/SelectedBackoff.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.backoff;
2 |
3 | import java.util.function.Function;
4 |
5 |
6 | /**
7 | * A policy that delegates to another policy that is selected based on the most recent error.
8 | *
9 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
10 | */
11 | public class SelectedBackoff implements BackoffPolicy {
12 | protected final Function _policyFunction;
13 |
14 | /**
15 | * A policy that delegates to another policy that is selected based on the most recent error.
16 | *
17 | * @param policyFunction The function that maps from errors to backoff policies.
18 | */
19 | public SelectedBackoff(Function policyFunction) {
20 | _policyFunction = policyFunction;
21 | }
22 |
23 | /**
24 | * {@inheritDoc}
25 | */
26 | @Override
27 | public long nextBackoff(int attempts, Throwable error) {
28 | return _policyFunction.apply(error).nextBackoff(attempts, error);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/GuavaRateLimiter.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 | /**
4 | * A RateLimiter implementation based on the guava RateLimiter.
5 | * Guava RateLimiter uses the token bucket algorithm and this
6 | * rate limiter allows bursts.
7 | *
8 | * @author Mohamed Isoukrane (isoukrane.mohamed@gmail.com)
9 | */
10 | public class GuavaRateLimiter implements RateLimiter {
11 | private final com.google.common.util.concurrent.RateLimiter _rateLimiter;
12 |
13 | public GuavaRateLimiter(double permitsPerSecond) {
14 | _rateLimiter = com.google.common.util.concurrent.RateLimiter.create(permitsPerSecond);
15 | }
16 |
17 | /**
18 | * {@inheritDoc}
19 | */
20 | @Override
21 | public boolean tryAcquire() {
22 | return _rateLimiter.tryAcquire();
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/LimitAttempts.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 | import com.linkedin.parseq.internal.ArgumentUtil;
4 |
5 |
6 | /**
7 | * A termination policy that limits the number of attempts made.
8 | *
9 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
10 | */
11 | public class LimitAttempts implements TerminationPolicy {
12 | protected final int _maxAttempts;
13 |
14 | /**
15 | * A termination policy that limits the number of attempts made.
16 | *
17 | * @param maxAttempts The maximum number of attempts that can be performed.
18 | */
19 | public LimitAttempts(int maxAttempts) {
20 | ArgumentUtil.requirePositive(maxAttempts, "maxAttempts");
21 | _maxAttempts = maxAttempts;
22 | }
23 |
24 | /**
25 | * {@inheritDoc}
26 | */
27 | @Override
28 | public boolean shouldTerminate(int attempts, long nextAttemptAt) {
29 | return attempts >= _maxAttempts;
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/LimitDuration.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 |
4 | /**
5 | * A termination policy that limits the amount of time spent retrying.
6 | *
7 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
8 | */
9 | public class LimitDuration implements TerminationPolicy {
10 | protected final long _maxDuration;
11 |
12 | /**
13 | * A termination policy that limits the amount of time spent retrying.
14 | *
15 | * @param maxDuration The maximum duration that a retry operation should not exceed.
16 | */
17 | public LimitDuration(long maxDuration) {
18 | _maxDuration = maxDuration;
19 | }
20 |
21 | /**
22 | * {@inheritDoc}
23 | */
24 | @Override
25 | public boolean shouldTerminate(int attempts, long nextAttemptAt) {
26 | return nextAttemptAt >= _maxDuration;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/LimitRate.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 | /**
4 | * A termination policy that limits the rate of retries.
5 | *
6 | * @author Mohamed Isoukrane (isoukrane.mohamed@gmail.com)
7 | */
8 | public class LimitRate implements TerminationPolicy {
9 | protected final RateLimiter _rateLimiter;
10 |
11 | /**
12 | * A termination policy that limits the rate of retries.
13 | *
14 | * @param rateLimiter The rate limiter implementation that will rate the retries qps.
15 | */
16 | public LimitRate(RateLimiter rateLimiter) {
17 | _rateLimiter = rateLimiter;
18 | }
19 |
20 | /**
21 | * {@inheritDoc}
22 | */
23 | @Override
24 | public boolean shouldTerminate(int attempts, long nextAttemptAt) {
25 | return !_rateLimiter.tryAcquire();
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/RateLimiter.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 | /**
4 | * A rate limiter that allows a certain number of retries per second.
5 | *
6 | * @author Mohamed Isoukrane (isoukrane.mohamed@gmail.com)
7 | */
8 | public interface RateLimiter {
9 |
10 | /**
11 | * Acquires a permit to process a retry request if it can be acquired immediately without delay.
12 | * It needs ot be thread safe and nonblocking.
13 | */
14 | boolean tryAcquire();
15 | }
16 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/RequireAny.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 | /**
4 | * A termination policy that signals for termination after any of the specified policies terminate.
5 | *
6 | * @author Mohamed Isoukrane (isoukrane.mohamed@gmail.com)
7 | */
8 | public class RequireAny implements TerminationPolicy {
9 |
10 | private final TerminationPolicy[] _policies;
11 |
12 | /**
13 | * A termination policy that signals for termination after any of the specified policies terminate.
14 | *
15 | * @param policies The list of policies that may signal for termination.
16 | */
17 | public RequireAny(TerminationPolicy... policies) {
18 | _policies = policies;
19 | }
20 |
21 | /**
22 | * {@inheritDoc}
23 | */
24 | @Override
25 | public boolean shouldTerminate(int attempts, long nextAttemptAt) {
26 | for (TerminationPolicy policy : _policies) {
27 | if (policy.shouldTerminate(attempts, nextAttemptAt)) {
28 | return true;
29 | }
30 | }
31 | return false;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/RequireBoth.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 |
4 | /**
5 | * A termination policy that signals for termination after both of the specified policies terminate.
6 | *
7 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
8 | */
9 | public class RequireBoth implements TerminationPolicy {
10 | protected final TerminationPolicy _first;
11 | protected final TerminationPolicy _second;
12 |
13 | /**
14 | * A termination policy that signals for termination after both of the specified policies terminate.
15 | *
16 | * @param first The first of the two policies that must signal for termination.
17 | * @param second The second of the two policies that must signal for termination.
18 | */
19 | public RequireBoth(TerminationPolicy first, TerminationPolicy second) {
20 | _first = first;
21 | _second = second;
22 | }
23 |
24 | /**
25 | * {@inheritDoc}
26 | */
27 | @Override
28 | public boolean shouldTerminate(int attempts, long nextAttemptAt) {
29 | return _first.shouldTerminate(attempts, nextAttemptAt) && _second.shouldTerminate(attempts, nextAttemptAt);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/retry/termination/RequireEither.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.retry.termination;
2 |
3 |
4 | /**
5 | * A termination policy that signals for termination after either of the specified policies terminate.
6 | *
7 | * @author Oleg Anashkin (oleg.anashkin@gmail.com)
8 | */
9 | public class RequireEither implements TerminationPolicy {
10 | protected final TerminationPolicy _first;
11 | protected final TerminationPolicy _second;
12 |
13 | /**
14 | * A termination policy that signals for termination after either of the specified policies terminate.
15 | *
16 | * @param first The first of the two policies that may signal for termination.
17 | * @param second The second of the two policies that may signal for termination.
18 | */
19 | public RequireEither(TerminationPolicy first, TerminationPolicy second) {
20 | _first = first;
21 | _second = second;
22 | }
23 |
24 | /**
25 | * {@inheritDoc}
26 | */
27 | @Override
28 | public boolean shouldTerminate(int attempts, long nextAttemptAt) {
29 | return _first.shouldTerminate(attempts, nextAttemptAt) || _second.shouldTerminate(attempts, nextAttemptAt);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/trace/Relationship.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq.trace;
18 |
19 | /**
20 | * A list of relationship types used by the trace system.
21 | *
22 | * @author Chris Pettitt (cpettitt@linkedin.com)
23 | * @author Chi Chan (ckchan@linkedin.com)
24 | */
25 | public enum Relationship {
26 | PARENT_OF,
27 | SUCCESSOR_OF,
28 | POSSIBLE_SUCCESSOR_OF,
29 | CHILD_OF,
30 | POTENTIAL_CHILD_OF,
31 | POTENTIAL_PARENT_OF,
32 | }
33 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/trace/TraceUtil.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.trace;
2 |
3 | import java.io.IOException;
4 |
5 | import com.linkedin.parseq.Task;
6 | import com.linkedin.parseq.trace.codec.json.JsonTraceCodec;
7 |
8 | /**
9 | * @author Jaroslaw Odzga (jodzga@linkedin.com)
10 | */
11 | public class TraceUtil {
12 |
13 | private static final JsonTraceCodec JSON_CODEC = new JsonTraceCodec();
14 |
15 | /**
16 | * Returns trace of a task serialized to a JSON string.
17 | * @param task task to get trace from
18 | * @return JSON representation of the trace
19 | * @throws IOException
20 | */
21 | public static String getJsonTrace(final Task task) throws IOException {
22 | return JSON_CODEC.encode(task.getTrace());
23 | }
24 |
25 | /**
26 | * Returns trace serialized to a JSON string.
27 | * @param trace trace to serialize to JSON
28 | * @return JSON representation of the trace
29 | * @throws IOException
30 | */
31 | public static String getJsonTrace(final Trace trace) throws IOException {
32 | return JSON_CODEC.encode(trace);
33 | }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/trace/codec/json/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * {@link com.linkedin.parseq.trace.Trace} codec specific to the
3 | * JSON format.
4 | */
5 | package com.linkedin.parseq.trace.codec.json;
6 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/trace/codec/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * {@link com.linkedin.parseq.trace.Trace} codec API.
3 | *
4 | * @see com.linkedin.parseq.trace.codec.TraceCodec
5 | */
6 | package com.linkedin.parseq.trace.codec;
7 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/main/java/com/linkedin/parseq/trace/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Tracing related APIs and functionality.
3 | *
4 | * To get a {@link com.linkedin.parseq.trace.Trace} use
5 | * {@link com.linkedin.parseq.Task#getTrace()}. Use
6 | * {@link com.linkedin.parseq.trace.codec.json.JsonTraceCodec} to serialize a
7 | * Trace to a String.
8 | */
9 | package com.linkedin.parseq.trace;
10 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/test/java/com/linkedin/parseq/TestCancellingPlanExceptionHandler.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq;
2 |
3 |
4 | import com.linkedin.parseq.internal.PrioritizableRunnable;
5 | import com.linkedin.parseq.internal.SerialExecutor;
6 | import java.util.concurrent.TimeUnit;
7 | import org.testng.annotations.Test;
8 |
9 |
10 | public class TestCancellingPlanExceptionHandler extends BaseEngineTest {
11 |
12 | @Override
13 | protected void customizeEngine(EngineBuilder engineBuilder) {
14 | engineBuilder.setTaskQueueFactory(ThrowingTaskQueue::new);
15 | }
16 |
17 | @Test
18 | public void testThrowingTaskQueue() {
19 | Task task = Task.value(1);
20 |
21 | runAndWaitException(task, CancellationException.class, 5, TimeUnit.SECONDS);
22 | }
23 |
24 | private static class ThrowingTaskQueue implements SerialExecutor.TaskQueue {
25 |
26 | @Override
27 | public void add(PrioritizableRunnable value) {
28 | }
29 |
30 | @Override
31 | public PrioritizableRunnable poll() {
32 | return () -> { throw new RuntimeException(); };
33 | }
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/test/java/com/linkedin/parseq/TestWithTry.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq;
2 |
3 | import static org.testng.Assert.*;
4 |
5 | import org.testng.annotations.Test;
6 |
7 | import com.linkedin.parseq.function.Try;
8 |
9 |
10 | /**
11 | * @author Jaroslaw Odzga (jodzga@linkedin.com)
12 | */
13 | public class TestWithTry extends BaseEngineTest {
14 |
15 | @Test
16 | public void testHappyPath() throws InterruptedException {
17 | final Task> task = Task.callable("test", () -> "hello").toTry();
18 |
19 | runAndWait("TestWithTry.testHappyPath", task);
20 |
21 | assertFalse(task.get().isFailed());
22 | assertEquals("hello", task.get().get());
23 | }
24 |
25 | @Test
26 | public void testError() throws InterruptedException {
27 | @SuppressWarnings("unused")
28 | final Task> task = Task.callable("test", () -> {
29 | if (true) {
30 | throw new RuntimeException("boom");
31 | }
32 | return "hello";
33 | } ).toTry();
34 |
35 | runAndWait("TestWithTry.testError", task);
36 |
37 | assertTrue(task.get().isFailed());
38 | assertTrue(task.get().getError() instanceof RuntimeException);
39 | assertEquals(task.get().getError().getMessage(), "boom");
40 | }
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/test/java/com/linkedin/parseq/ThrowingRunnable.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2012 LinkedIn, Inc
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 | * use this file except in compliance with the License. You may obtain a copy of
6 | * the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 | * License for the specific language governing permissions and limitations under
14 | * the License.
15 | */
16 |
17 | package com.linkedin.parseq;
18 |
19 | /**
20 | * @author Chris Pettitt (cpettitt@linkedin.com)
21 | */
22 | public interface ThrowingRunnable {
23 | void run() throws Exception;
24 | }
25 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/test/java/com/linkedin/parseq/internal/TestArgumentUtil.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import org.testng.annotations.Test;
4 |
5 |
6 | public class TestArgumentUtil {
7 | @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = ".*foo.*")
8 | public void testNotNullWithNull() {
9 | ArgumentUtil.requireNotNull(null, "foo");
10 | }
11 |
12 | @Test
13 | public void testNotNullWithNotNull() {
14 | // This should not throw
15 | ArgumentUtil.requireNotNull(new Object(), "foo");
16 | }
17 |
18 | @Test(expectedExceptions = NullPointerException.class, expectedExceptionsMessageRegExp = ".*foo.*")
19 | public void testNotEmptyWithNull() {
20 | ArgumentUtil.requireNotEmpty(null, "foo");
21 | }
22 |
23 | @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = ".*foo.*")
24 | public void testNotEmptyWithEmptyString() {
25 | ArgumentUtil.requireNotEmpty("", "foo");
26 | }
27 |
28 | @Test
29 | public void testNotEmptyWithNotEmptyString() {
30 | // This should not throw
31 | ArgumentUtil.requireNotEmpty("not empty string", "foo");
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/test/java/com/linkedin/parseq/internal/TestClock.java:
--------------------------------------------------------------------------------
1 | package com.linkedin.parseq.internal;
2 |
3 | import com.linkedin.parseq.function.Consumer1;
4 | import java.util.concurrent.Callable;
5 |
6 |
7 | public class TestClock implements Clock {
8 |
9 | private final Callable _timer;
10 |
11 | private final Consumer1 _sleeper;
12 |
13 | public TestClock(Callable timer, Consumer1 sleeper) {
14 | _timer = timer;
15 | _sleeper = sleeper;
16 | }
17 |
18 | @Override
19 | public long nanoTime() {
20 | try {
21 | return _timer.call();
22 | } catch (Exception e) {
23 | throw new RuntimeException(e);
24 | }
25 | }
26 |
27 | @Override
28 | public void sleepNano(long nano) throws InterruptedException {
29 | try {
30 | _sleeper.accept(nano);
31 | } catch (Exception e) {
32 | throw new RuntimeException(e);
33 | }
34 | }
35 |
36 |
37 | }
38 |
--------------------------------------------------------------------------------
/subprojects/parseq/src/test/java/log4j.properties:
--------------------------------------------------------------------------------
1 | log4j.rootLogger=INFO, stdout
2 | log4j.appender.stdout=org.apache.log4j.ConsoleAppender
3 | log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
4 | log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p %c: %m%n
5 |
--------------------------------------------------------------------------------