index int64 0 0 | repo_id stringlengths 26 205 | file_path stringlengths 51 246 | content stringlengths 8 433k | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3 | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/internal/ContentMetadataDecodingStrategy.java | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package software.amazon.encryption.s3.internal;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
@FunctionalInterface
public interface ContentMetadataDecodingStrategy {
ContentMetadata decodeMetadata(GetObjectRequest request, GetObjectResponse response);
}
| 2,300 |
0 | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/legacy | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/legacy/internal/AesCtrUtils.java | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package software.amazon.encryption.s3.legacy.internal;
import software.amazon.encryption.s3.algorithms.AlgorithmSuite;
import java.nio.ByteBuffer;
/**
* Utilities for processing AES GCM encrypted data with AES CTR.
* This is useful in scenarios such as ranged gets and when
* re-reading the encrypted input stream.
*/
public class AesCtrUtils {
public static final long MAX_GCM_BLOCKS = AlgorithmSuite.ALG_AES_256_GCM_IV12_TAG16_NO_KDF.cipherMaxContentLengthBits() >> 7; // 2^32 - 2
public static final int CIPHER_BLOCK_SIZE = AlgorithmSuite.ALG_AES_256_GCM_IV12_TAG16_NO_KDF.cipherBlockSizeBytes();
public static byte[] adjustIV(byte[] iv, long byteOffset) {
// Currently only support iv of length 12 for AES/GCM.
// Anything else is quite a bit complicated.
if (iv.length != 12) {
throw new UnsupportedOperationException();
}
final int blockSizeBytes = CIPHER_BLOCK_SIZE;
final long blockOffset = byteOffset / blockSizeBytes;
if (blockOffset * blockSizeBytes != byteOffset) {
throw new IllegalArgumentException("Expecting byteOffset to be multiple of 16, but got blockOffset=" +
blockOffset + ", blockSize=" + blockSizeBytes + ", byteOffset=" + byteOffset);
}
byte[] J0 = computeJ0(iv);
return incrementBlocks(J0, blockOffset);
}
/**
* See <a href=
* "http://csrc.nist.gov/publications/nistpubs/800-38D/SP-800-38D.pdf">
* NIST Special Publication 800-38D.</a> for the definition of J0, the
* "pre-counter block".
* <p>
* Reference: <a href=
* "https://github.com/bcgit/bc-java/blob/master/core/src/main/java/org/bouncycastle/crypto/modes/GCMBlockCipher.java"
* >GCMBlockCipher.java</a>
*/
private static byte[] computeJ0(byte[] iv) {
final int blockSizeBytes = CIPHER_BLOCK_SIZE;
byte[] J0 = new byte[blockSizeBytes];
System.arraycopy(iv, 0, J0, 0, iv.length);
J0[blockSizeBytes - 1] = 0x01;
return incrementBlocks(J0, 1);
}
/**
* Increment the rightmost 32 bits of a 16-byte counter by the specified
* delta. Both the specified delta and the resultant value must stay within
* the capacity of 32 bits.
*
* @param counter a 16-byte counter used in AES/CTR
* @param blockDelta the number of blocks (16-byte) to increment
*/
private static byte[] incrementBlocks(byte[] counter, long blockDelta) {
if (blockDelta == 0) {
return counter;
}
if (counter == null || counter.length != 16) {
throw new IllegalArgumentException();
}
if (blockDelta > MAX_GCM_BLOCKS) {
throw new IllegalStateException();
}
// Allocate 8 bytes for a long
ByteBuffer bb = ByteBuffer.allocate(8);
// Copy the right-most 32 bits from the counter
for (int i = 12; i <= 15; i++) {
bb.put(i - 8, counter[i]);
}
// increment by delta
long val = bb.getLong() + blockDelta;
if (val > MAX_GCM_BLOCKS) {
throw new IllegalStateException(); // overflow 2^32-2
}
// This cast is necessary to ensure compatibility with Java 1.8/8
// when compiling with a newer Java version than 8
((java.nio.Buffer) bb).rewind();
// Get the incremented value (result) as an 8-byte array
byte[] result = bb.putLong(val).array();
// Copy the rightmost 32 bits from the resultant array to the input counter;
System.arraycopy(result, 4, counter, 12, 4);
return counter;
}
}
| 2,301 |
0 | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/legacy | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/legacy/internal/RangedGetUtils.java | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package software.amazon.encryption.s3.legacy.internal;
import org.reactivestreams.Subscriber;
import software.amazon.encryption.s3.S3EncryptionClientException;
import software.amazon.encryption.s3.algorithms.AlgorithmSuite;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Utilities for processing Ranged Get functions.
*/
public class RangedGetUtils {
public static long[] getRange(String range) {
if (range == null) {
return null;
}
if (!range.matches("bytes=[0-9]+-[0-9]+")) {
return null;
}
String[] rangeSplit = range.split("[-=]");
long[] adjustedRange = new long[2];
adjustedRange[0] = Integer.parseInt(rangeSplit[1]);
adjustedRange[1] = Integer.parseInt(rangeSplit[2]);
return adjustedRange;
}
public static String getCryptoRangeAsString(String desiredRange) {
long[] cryptoRange = RangedGetUtils.getCryptoRange(desiredRange);
return cryptoRange == null ? null : "bytes=" + cryptoRange[0] + "-" + cryptoRange[1];
}
public static long[] getCryptoRange(String desiredRange) {
long[] range = getRange(desiredRange);
// If range is invalid, then return null.
if (range == null || range[0] > range[1]) {
return null;
}
long[] adjustedCryptoRange = new long[2];
adjustedCryptoRange[0] = getCipherBlockLowerBound(range[0]);
adjustedCryptoRange[1] = getCipherBlockUpperBound(range[1]);
return adjustedCryptoRange;
}
private static long getCipherBlockLowerBound(long leftmostBytePosition) {
long cipherBlockSize = AlgorithmSuite.ALG_AES_256_GCM_IV12_TAG16_NO_KDF.cipherBlockSizeBytes();
long offset = leftmostBytePosition % cipherBlockSize;
long lowerBound = leftmostBytePosition - offset - cipherBlockSize;
return lowerBound < 0 ? 0 : lowerBound;
}
private static long getCipherBlockUpperBound(final long rightmostBytePosition) {
long cipherBlockSize = AlgorithmSuite.ALG_AES_256_GCM_IV12_TAG16_NO_KDF.cipherBlockSizeBytes();
long offset = cipherBlockSize - (rightmostBytePosition % cipherBlockSize);
long upperBound = rightmostBytePosition + offset + cipherBlockSize;
return upperBound < 0 ? Long.MAX_VALUE : upperBound;
}
private static long calculateMaxOffset(String contentRange, int cipherTagLengthBits) {
final long instanceLength;
int pos = contentRange.lastIndexOf("/");
instanceLength = Long.parseLong(contentRange.substring(pos + 1));
return instanceLength - (cipherTagLengthBits / 8) - 1;
}
public static Subscriber<? super ByteBuffer> adjustToDesiredRange(Subscriber<? super ByteBuffer> subscriber, long[] cryptoRange, String contentRange, int cipherTagLengthBits) {
if (cryptoRange == null || contentRange == null) {
return subscriber;
}
final long maxOffset = calculateMaxOffset(contentRange, cipherTagLengthBits);
if (cryptoRange[1] > maxOffset) {
cryptoRange[1] = maxOffset;
if (cryptoRange[0] > cryptoRange[1]) {
// When the beginning of the crypto range is after the max offset,
// there is no data to read. The current implementation of
// AdjustedRangeSubscriber handles this case itself,
// but this might as well be a Null/Noop Subscriber
try {
return new AdjustedRangeSubscriber(subscriber, cryptoRange[0], cryptoRange[1]);
} catch (IOException e) {
throw new S3EncryptionClientException(e.getMessage());
}
}
}
if (cryptoRange[0] > cryptoRange[1]) {
// Make no modifications if range is invalid.
return subscriber;
}
try {
return new AdjustedRangeSubscriber(subscriber, cryptoRange[0], cryptoRange[1]);
} catch (IOException e) {
throw new S3EncryptionClientException("Error adjusting output to desired byte range: " + e.getMessage());
}
}
}
| 2,302 |
0 | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/legacy | Create_ds/amazon-s3-encryption-client-java/src/main/java/software/amazon/encryption/s3/legacy/internal/AdjustedRangeSubscriber.java | // Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package software.amazon.encryption.s3.legacy.internal;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import software.amazon.encryption.s3.algorithms.AlgorithmSuite;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;
public class AdjustedRangeSubscriber implements Subscriber<ByteBuffer> {
private final int SYMMETRIC_CIPHER_BLOCK_SIZE_BYTES = AlgorithmSuite.ALG_AES_256_GCM_IV12_TAG16_NO_KDF.cipherBlockSizeBytes();
private final Subscriber<? super ByteBuffer> wrappedSubscriber;
private byte[] outputBuffer;
private long virtualAvailable;
private int numBytesToSkip = 0;
public AdjustedRangeSubscriber(Subscriber<? super ByteBuffer> wrappedSubscriber, Long rangeBeginning, Long rangeEnd) throws IOException {
this.wrappedSubscriber = wrappedSubscriber;
initializeForRead(rangeBeginning, rangeEnd);
}
private void initializeForRead(long rangeBeginning, long rangeEnd) {
// To get to the left-most byte desired by a user, we must skip over the 16 bytes of the
// preliminary cipher block, and then possibly skip a few more bytes into the next block
// to where the left-most byte is located.
if (rangeBeginning < SYMMETRIC_CIPHER_BLOCK_SIZE_BYTES) {
numBytesToSkip = (int) rangeBeginning;
} else {
int offsetIntoBlock = (int) (rangeBeginning % SYMMETRIC_CIPHER_BLOCK_SIZE_BYTES);
numBytesToSkip = SYMMETRIC_CIPHER_BLOCK_SIZE_BYTES + offsetIntoBlock;
}
// The number of bytes the user may read is equal to the number of the bytes in the range.
// Note that the range includes the endpoints.
this.virtualAvailable = (rangeEnd - rangeBeginning) + 1;
}
@Override
public void onSubscribe(Subscription s) {
wrappedSubscriber.onSubscribe(s);
}
@Override
public void onNext(ByteBuffer byteBuffer) {
// In edge cases where the beginning index exceeds the offset,
// there is never valid data to read, so signal completion immediately.
if (virtualAvailable <= 0) {
wrappedSubscriber.onComplete();
}
if (numBytesToSkip != 0) {
byte[] buf = byteBuffer.array();
if (numBytesToSkip > buf.length) {
// If we need to skip past the available data,
// we are returning nothing, so signal completion
numBytesToSkip -= buf.length;
wrappedSubscriber.onComplete();
} else {
outputBuffer = Arrays.copyOfRange(buf, numBytesToSkip, buf.length);
numBytesToSkip = 0;
}
} else {
outputBuffer = byteBuffer.array();
}
if (virtualAvailable > 0) {
long bytesToRead = Math.min(virtualAvailable, outputBuffer.length);
virtualAvailable -= bytesToRead;
wrappedSubscriber.onNext(ByteBuffer.wrap(outputBuffer, 0, Math.toIntExact(bytesToRead)));
}
// Since we are skipping some bytes, we may need to signal onComplete
// from within onNext to prevent the subscriber from waiting for more
// data indefinitely
if (virtualAvailable <= 0) {
wrappedSubscriber.onComplete();
}
}
@Override
public void onError(Throwable t) {
wrappedSubscriber.onError(t);
}
@Override
public void onComplete() {
wrappedSubscriber.onComplete();
}
} | 2,303 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/test/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/test/java/io/reactivex/lab/services/impls/MockResponseTest.java | package io.reactivex.lab.services.impls;
import static org.junit.Assert.assertTrue;
import io.reactivex.lab.services.impls.MockResponse;
import org.junit.Test;
import rx.Observable;
public class MockResponseTest {
@Test
public void testJson() throws Exception {
Observable<String> jsonObservable = MockResponse.generateJson(736L, 1, 1000, 5);
String json = jsonObservable.toBlocking().single();
System.out.println(json);
assertTrue(json.startsWith("{\"responseKey\":" + MockResponse.getResponseKey(736L) + ",\"delay\":1,\"itemSize\":1000,\"numItems\":5,\"items\""));
System.out.println("json: " + json);
}
}
| 2,304 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/StartTurbineServer.java | package io.reactivex.lab.services;
import com.netflix.eureka2.client.Eureka;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.client.resolver.ServerResolvers;
import com.netflix.turbine.Turbine;
import com.netflix.turbine.discovery.eureka.EurekaStreamDiscovery;
public class StartTurbineServer {
public static void main(String... args) {
try {
EurekaClient eurekaClient = Eureka.newClient(ServerResolvers.just(StartEurekaServer.EUREKA_SERVER_HOST, StartEurekaServer.EUREKA_SERVER_READ_PORT), null);
Turbine.startServerSentEventServer(4444, EurekaStreamDiscovery.create("reactive-lab", "http://{HOSTNAME}/hystrix.stream", eurekaClient));
} catch (Throwable e) {
e.printStackTrace();
}
}
}
| 2,305 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/StartEurekaServer.java | package io.reactivex.lab.services;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.server.file.ClassPathFileRequestHandler;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.stream.Collectors;
import rx.Observable;
import rx.schedulers.Schedulers;
import com.netflix.eureka2.client.Eureka;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.client.resolver.ServerResolver;
import com.netflix.eureka2.client.resolver.ServerResolvers;
import com.netflix.eureka2.interests.Interests;
import com.netflix.eureka2.registry.NetworkAddress.ProtocolType;
import com.netflix.eureka2.registry.ServicePort;
import com.netflix.eureka2.registry.datacenter.LocalDataCenterInfo;
import com.netflix.eureka2.server.EurekaWriteServer;
import com.netflix.eureka2.server.WriteServerConfig;
import com.netflix.eureka2.transport.EurekaTransports.Codec;
/**
* Eureka discovery server for services and gateway to use for instance discovery.
*/
public class StartEurekaServer {
/* properties for overriding config */
public static final String EUREKA_SERVER_HOST = System.getProperty("reactivelab.eureka.server.host", "127.0.0.1");
public static final Integer EUREKA_SERVER_READ_PORT = Integer.getInteger("reactivelab.eureka.server.read.port", 7001);
public static final Integer EUREKA_SERVER_WRITE_PORT = Integer.getInteger("reactivelab.eureka.server.write.port", 7002);
public static void main(String[] args) throws Exception {
/* configure read/write Eureka server */
System.setProperty("eureka2.eviction.allowedPercentage", "100"); // turn off eviction protection so during demos we don't hold on to hosts
System.setProperty("eureka2.eviction.timeoutMillis", "4000"); // set far lower than normal for demo/playground purposes
System.setProperty("eureka2.registration.heartbeat.intervalMillis", "3000"); // set lower for demo/playground purposes
WriteServerConfig.WriteServerConfigBuilder builder = new WriteServerConfig.WriteServerConfigBuilder();
builder.withReadServerPort(EUREKA_SERVER_READ_PORT).withWriteServerPort(EUREKA_SERVER_WRITE_PORT)
.withWriteClusterAddresses(new String[] { EUREKA_SERVER_HOST })
.withCodec(Codec.Avro)
.withDataCenterType(LocalDataCenterInfo.DataCenterType.Basic);
EurekaWriteServer eurekaWriteServer = new EurekaWriteServer(builder.build());
/* start the server */
eurekaWriteServer.start();
EurekaClient client = Eureka.newClientBuilder(ServerResolvers.from(new ServerResolver.Server(EUREKA_SERVER_HOST, EUREKA_SERVER_READ_PORT))).build();
/**
* Background query for logging all events.
*/
client.forInterest(Interests.forFullRegistry())
.subscribeOn(Schedulers.computation())
.forEach(n -> {
String vip = n.getData().getVipAddress();
String app = n.getData().getApp();
if (app == null) {
app = "none";
}
String name = n.getData().getDataCenterInfo().getName();
String id = n.getData().getId();
String ipAddress = n.getData().getDataCenterInfo()
.getAddresses().stream()
.filter(na -> na.getProtocolType() == ProtocolType.IPv4)
.collect(Collectors.toList()).get(0).getIpAddress();
HashSet<ServicePort> servicePorts = n.getData().getPorts();
int port = servicePorts.iterator().next().getPort();
System.out.println("Eureka => " + n.getKind() + " => App: " + app + " VIP: " + vip + " Name: " + name + " IP: " + ipAddress + " Port: " + port + " ID: " + id);
});
startEurekaDashboard(8888, client);
eurekaWriteServer.waitTillShutdown();
}
public static class StaticFileHandler extends ClassPathFileRequestHandler {
public StaticFileHandler() {
super(".");
}
}
private static void startEurekaDashboard(final int port, EurekaClient client) {
final StaticFileHandler staticFileHandler = new StaticFileHandler();
RxNetty.createHttpServer(port, (request, response) -> {
if (request.getUri().startsWith("/dashboard")) {
return staticFileHandler.handle(request, response);
} else if (request.getUri().startsWith("/data")) {
response.getHeaders().set(HttpHeaders.Names.CONTENT_TYPE, "text/event-stream");
response.getHeaders().set(HttpHeaders.Names.CACHE_CONTROL, "no-cache");
return client.forInterest(Interests.forFullRegistry())
.flatMap(notification -> {
ByteBuf data = response.getAllocator().buffer();
data.writeBytes("data: ".getBytes());
Map<String, String> dataAttributes = new HashMap<>();
dataAttributes.put("type", notification.getKind().toString());
dataAttributes.put("instance-id", notification.getData().getId());
dataAttributes.put("vip", notification.getData().getVipAddress());
if (notification.getData().getStatus() != null) {
dataAttributes.put("status", notification.getData().getStatus().name());
}
HashSet<ServicePort> servicePorts = notification.getData().getPorts();
int port1 = servicePorts.iterator().next().getPort();
dataAttributes.put("port", String.valueOf(port1));
String jsonData = SimpleJson.mapToJson(dataAttributes);
data.writeBytes(jsonData.getBytes());
data.writeBytes("\n\n".getBytes());
return response.writeBytesAndFlush(data);
});
} else {
response.setStatus(HttpResponseStatus.NOT_FOUND);
return Observable.empty();
}
}).start();
}
}
| 2,306 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/StartMiddleTierServices.java | package io.reactivex.lab.services;
import io.reactivex.lab.services.impls.BookmarksService;
import io.reactivex.lab.services.impls.GeoService;
import io.reactivex.lab.services.impls.MockService;
import io.reactivex.lab.services.impls.PersonalizedCatalogService;
import io.reactivex.lab.services.impls.RatingsService;
import io.reactivex.lab.services.impls.SocialService;
import io.reactivex.lab.services.impls.UserService;
import io.reactivex.lab.services.impls.VideoMetadataService;
import rx.Observable;
import com.netflix.eureka2.client.Eureka;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.client.resolver.ServerResolver;
import com.netflix.eureka2.client.resolver.ServerResolvers;
public class StartMiddleTierServices {
public static void main(String... args) {
/* Eureka Server Config */
System.setProperty("reactivelab.eureka.server.host", StartEurekaServer.EUREKA_SERVER_HOST);
System.setProperty("reactivelab.eureka.server.read.port", String.valueOf(StartEurekaServer.EUREKA_SERVER_READ_PORT));
System.setProperty("reactivelab.eureka.server.write.port", String.valueOf(StartEurekaServer.EUREKA_SERVER_WRITE_PORT));
System.setProperty("eureka2.registration.heartbeat.intervalMillis", "3000"); // set lower for demo/playground purposes
/* Create a EurekaClient to be used by the services for registering for discovery */
ServerResolver.Server discoveryServer = new ServerResolver.Server(StartEurekaServer.EUREKA_SERVER_HOST, StartEurekaServer.EUREKA_SERVER_READ_PORT);
ServerResolver.Server registrationServer = new ServerResolver.Server(StartEurekaServer.EUREKA_SERVER_HOST, StartEurekaServer.EUREKA_SERVER_WRITE_PORT);
EurekaClient eurekaClient = Eureka.newClientBuilder(ServerResolvers.from(discoveryServer), ServerResolvers.from(registrationServer)).build();
/* what port we want to begin at for launching the services */
int startingPort = 9190;
if (args.length > 0) {
startingPort = Integer.parseInt(args[0]);
}
System.out.println("Starting services ...");
new MockService(eurekaClient).start(startingPort);
new BookmarksService(eurekaClient).start(++startingPort);
new GeoService(eurekaClient).start(++startingPort);
new PersonalizedCatalogService(eurekaClient).start(++startingPort);
new RatingsService(eurekaClient).start(++startingPort);
new SocialService(eurekaClient).start(++startingPort);
new UserService(eurekaClient).start(++startingPort);
new VideoMetadataService(eurekaClient).start(++startingPort);
// block forever
Observable.never().toBlocking().single();
}
}
| 2,307 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/metrics/HystrixMetricsStreamHandler.java | package io.reactivex.lab.services.metrics;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.UnpooledByteBufAllocator;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.server.RequestHandler;
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import rx.Observable;
import rx.Subscription;
import rx.functions.Action1;
import rx.schedulers.Schedulers;
import rx.subjects.PublishSubject;
import rx.subjects.Subject;
import rx.subscriptions.MultipleAssignmentSubscription;
/**
* Streams Hystrix metrics in Server Sent Event (SSE) format. RxNetty application handlers shall
* be wrapped by this handler. It transparently intercepts HTTP requests at a configurable path
* (default "/hystrix.stream"), and sends unbounded SSE streams back to the client. All other requests
* are transparently forwarded to the application handlers.
* <p/>
* For RxNetty client tapping into SSE stream: remember to use unpooled HTTP connections. If not, the pooled HTTP
* connection will not be closed on unsubscribe event and the event stream will continue to flow towards the client
* (unless the client is shutdown).
*/
public class HystrixMetricsStreamHandler<I, O> implements RequestHandler<I, O> {
public static final String DEFAULT_HYSTRIX_PREFIX = "/hystrix.stream";
public static final int DEFAULT_INTERVAL = 2000;
private static final byte[] HEADER = "data: ".getBytes(Charset.defaultCharset());
private static final byte[] FOOTER = { 10, 10 };
private static final int EXTRA_SPACE = HEADER.length + FOOTER.length;
private final String hystrixPrefix;
private final long interval;
private final RequestHandler<I, O> appHandler;
private Metrics metrics;
public HystrixMetricsStreamHandler(Metrics metrics, String hystrixPrefix, long interval, RequestHandler<I, O> appHandler) {
this.metrics = metrics;
this.hystrixPrefix = hystrixPrefix;
this.interval = interval;
this.appHandler = appHandler;
}
@Override
public Observable<Void> handle(HttpServerRequest<I> request, HttpServerResponse<O> response) {
if (request.getPath().endsWith(hystrixPrefix)) {
return handleHystrixRequest(response);
}
return appHandler.handle(request, response);
}
private Observable<Void> handleHystrixRequest(final HttpServerResponse<O> response) {
writeHeaders(response);
final Subject<Void, Void> subject = PublishSubject.create();
final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
Subscription actionSubscription = Observable.timer(0, interval, TimeUnit.MILLISECONDS, Schedulers.computation())
.subscribe(new Action1<Long>() {
@Override
public void call(Long tick) {
if (!response.getChannel().isOpen()) {
subscription.unsubscribe();
return;
}
try {
writeMetric(JsonMapper.toJson(metrics), response);
} catch (Exception e) {
subject.onError(e);
}
}
});
subscription.set(actionSubscription);
return subject;
}
private void writeHeaders(HttpServerResponse<O> response) {
response.getHeaders().add("Content-Type", "text/event-stream;charset=UTF-8");
response.getHeaders().add("Cache-Control", "no-cache, no-store, max-age=0, must-revalidate");
response.getHeaders().add("Pragma", "no-cache");
}
@SuppressWarnings("unchecked")
private void writeMetric(String json, HttpServerResponse<O> response) {
byte[] bytes = json.getBytes(Charset.defaultCharset());
ByteBuf byteBuf = UnpooledByteBufAllocator.DEFAULT.buffer(bytes.length + EXTRA_SPACE);
byteBuf.writeBytes(HEADER);
byteBuf.writeBytes(bytes);
byteBuf.writeBytes(FOOTER);
response.writeAndFlush((O) byteBuf);
}
} | 2,308 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/metrics/JsonMapper.java | package io.reactivex.lab.services.metrics;
import java.io.IOException;
import java.io.StringWriter;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerator;
/**
* This code is taken from hystrix-metrics-event-stream module's HystrixMetricsPoller class.
*/
public final class JsonMapper {
private static final JsonFactory jsonFactory = new JsonFactory();
private JsonMapper() {
}
static String toJson(Metrics commandMetrics) throws IOException {
StringWriter jsonString = new StringWriter();
JsonGenerator json = jsonFactory.createJsonGenerator(jsonString);
json.writeStartObject();
json.writeStringField("type", "HystrixCommand"); // act as this as we are hijacking Hystrix for the dashboard
json.writeStringField("name", commandMetrics.getName());
json.writeStringField("group", "");
json.writeNumberField("currentTime", System.currentTimeMillis());
json.writeBooleanField("isCircuitBreakerOpen", false);
long errors = commandMetrics.getRollingNumber().getRollingSum(Metrics.EventType.FAILURE);
long success = commandMetrics.getRollingNumber().getRollingSum(Metrics.EventType.SUCCESS);
long requests = success + errors;
int errorPercentage = (int) ((double) errors / requests * 100);
json.writeNumberField("errorPercentage", errorPercentage);
json.writeNumberField("errorCount", errors);
json.writeNumberField("requestCount", requests);
// rolling counters
json.writeNumberField("rollingCountCollapsedRequests", 0);
json.writeNumberField("rollingCountExceptionsThrown", commandMetrics.getRollingNumber().getRollingSum(Metrics.EventType.EXCEPTION_THROWN));
json.writeNumberField("rollingCountFailure", errors);
json.writeNumberField("rollingCountFallbackFailure", 0);
json.writeNumberField("rollingCountFallbackRejection", 0);
json.writeNumberField("rollingCountFallbackSuccess", 0);
json.writeNumberField("rollingCountResponsesFromCache", 0);
json.writeNumberField("rollingCountSemaphoreRejected", 0);
json.writeNumberField("rollingCountShortCircuited", 0);
json.writeNumberField("rollingCountSuccess", success);
json.writeNumberField("rollingCountThreadPoolRejected", 0);
json.writeNumberField("rollingCountTimeout", 0);
json.writeNumberField("currentConcurrentExecutionCount", commandMetrics.getRollingNumber().getRollingMaxValue(Metrics.EventType.CONCURRENCY_MAX_ACTIVE));
// latency percentiles
json.writeNumberField("latencyExecute_mean", commandMetrics.getRollingPercentile().getMean());
json.writeObjectFieldStart("latencyExecute");
json.writeNumberField("0", commandMetrics.getRollingPercentile().getPercentile(0));
json.writeNumberField("25", commandMetrics.getRollingPercentile().getPercentile(25));
json.writeNumberField("50", commandMetrics.getRollingPercentile().getPercentile(50));
json.writeNumberField("75", commandMetrics.getRollingPercentile().getPercentile(75));
json.writeNumberField("90", commandMetrics.getRollingPercentile().getPercentile(90));
json.writeNumberField("95", commandMetrics.getRollingPercentile().getPercentile(95));
json.writeNumberField("99", commandMetrics.getRollingPercentile().getPercentile(99));
json.writeNumberField("99.5", commandMetrics.getRollingPercentile().getPercentile(99.5));
json.writeNumberField("100", commandMetrics.getRollingPercentile().getPercentile(100));
json.writeEndObject();
json.writeNumberField("latencyTotal_mean", commandMetrics.getRollingPercentile().getMean());
json.writeObjectFieldStart("latencyTotal");
json.writeNumberField("0", commandMetrics.getRollingPercentile().getPercentile(0));
json.writeNumberField("25", commandMetrics.getRollingPercentile().getPercentile(25));
json.writeNumberField("50", commandMetrics.getRollingPercentile().getPercentile(50));
json.writeNumberField("75", commandMetrics.getRollingPercentile().getPercentile(75));
json.writeNumberField("90", commandMetrics.getRollingPercentile().getPercentile(90));
json.writeNumberField("95", commandMetrics.getRollingPercentile().getPercentile(95));
json.writeNumberField("99", commandMetrics.getRollingPercentile().getPercentile(99));
json.writeNumberField("99.5", commandMetrics.getRollingPercentile().getPercentile(99.5));
json.writeNumberField("100", commandMetrics.getRollingPercentile().getPercentile(100));
json.writeEndObject();
json.writeNumberField("propertyValue_circuitBreakerRequestVolumeThreshold", 0);
json.writeNumberField("propertyValue_circuitBreakerSleepWindowInMilliseconds", 0);
json.writeNumberField("propertyValue_circuitBreakerErrorThresholdPercentage", 0);
json.writeBooleanField("propertyValue_circuitBreakerForceOpen", false);
json.writeBooleanField("propertyValue_circuitBreakerForceClosed", false);
json.writeBooleanField("propertyValue_circuitBreakerEnabled", false);
json.writeStringField("propertyValue_executionIsolationStrategy", "");
json.writeNumberField("propertyValue_executionIsolationThreadTimeoutInMilliseconds", 0);
json.writeBooleanField("propertyValue_executionIsolationThreadInterruptOnTimeout", false);
json.writeStringField("propertyValue_executionIsolationThreadPoolKeyOverride", "");
json.writeNumberField("propertyValue_executionIsolationSemaphoreMaxConcurrentRequests", 0);
json.writeNumberField("propertyValue_fallbackIsolationSemaphoreMaxConcurrentRequests", 0);
json.writeNumberField("propertyValue_metricsRollingStatisticalWindowInMilliseconds", 10000);
json.writeBooleanField("propertyValue_requestCacheEnabled", false);
json.writeBooleanField("propertyValue_requestLogEnabled", false);
json.writeNumberField("reportingHosts", 1); // this will get summed across all instances in a cluster
json.writeEndObject();
json.close();
return jsonString.getBuffer().toString();
}
} | 2,309 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/metrics/Metrics.java | package io.reactivex.lab.services.metrics;
import com.netflix.numerus.NumerusProperty;
import com.netflix.numerus.NumerusRollingNumber;
import com.netflix.numerus.NumerusRollingNumberEvent;
import com.netflix.numerus.NumerusRollingPercentile;
public class Metrics {
private static final NumerusProperty<Integer> latency_timeInMilliseconds = NumerusProperty.Factory.asProperty(60000);
private static final NumerusProperty<Integer> latency_numberOfBuckets = NumerusProperty.Factory.asProperty(12); // 12 buckets at 5000ms each
private static final NumerusProperty<Integer> latency_bucketDataLength = NumerusProperty.Factory.asProperty(1000);
private static final NumerusProperty<Boolean> latency_enabled = NumerusProperty.Factory.asProperty(true);
private static final NumerusProperty<Integer> count_timeInMilliseconds = NumerusProperty.Factory.asProperty(10000);
private static final NumerusProperty<Integer> count_numberOfBuckets = NumerusProperty.Factory.asProperty(10); // 11 buckets at 1000ms each
private final NumerusRollingPercentile p = new NumerusRollingPercentile(latency_timeInMilliseconds, latency_numberOfBuckets, latency_bucketDataLength, latency_enabled);
private final NumerusRollingNumber n = new NumerusRollingNumber(EventType.BOOTSTRAP, count_timeInMilliseconds, count_numberOfBuckets);
private final String name;
public Metrics(String name) {
this.name = name;
}
public NumerusRollingPercentile getRollingPercentile() {
return p;
}
public NumerusRollingNumber getRollingNumber() {
return n;
}
public String getName() {
return name;
}
public static enum EventType implements NumerusRollingNumberEvent {
BOOTSTRAP(1),
SUCCESS(1), FAILURE(1), EXCEPTION_THROWN(1),
CONCURRENCY_MAX_ACTIVE(2);
private final int type;
EventType(int type) {
this.type = type;
}
public boolean isCounter() {
return type == 1;
}
public boolean isMaxUpdater() {
return type == 2;
}
@Override
public EventType[] getValues() {
return values();
}
}
}
| 2,310 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/PersonalizedCatalogService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class PersonalizedCatalogService extends AbstractMiddleTierService {
public PersonalizedCatalogService(EurekaClient client) {
super("reactive-lab-personalized-catalog-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
return Observable.from(request.getQueryParameters().get("userId")).map(userId -> {
Map<String, Object> userData = new HashMap<>();
userData.put("user_id", userId);
userData.put("list_title", "Really quirky and over detailed list title!");
userData.put("other_data", "goes_here");
userData.put("videos", Arrays.asList(12345, 23456, 34567, 45678, 56789, 67890));
return userData;
}).flatMap(list -> response.writeStringAndFlush("data: " + SimpleJson.mapToJson(list) + "\n"))
.delay(((long) (Math.random() * 100) + 20), TimeUnit.MILLISECONDS)
.doOnCompleted(response::close); // simulate latency
}
}
| 2,311 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/UserService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class UserService extends AbstractMiddleTierService {
public UserService(EurekaClient client) {
super("reactive-lab-user-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
List<String> userIds = request.getQueryParameters().get("userId");
if (userIds == null || userIds.size() == 0) {
return writeError(request, response, "At least one parameter of 'userId' must be included.");
}
return Observable.from(userIds).map(userId -> {
Map<String, Object> user = new HashMap<>();
user.put("userId", userId);
user.put("name", "Name Here");
user.put("other_data", "goes_here");
return user;
}).flatMap(user -> response.writeStringAndFlush("data: " + SimpleJson.mapToJson(user) + "\n")
.doOnCompleted(response::close))
.delay(((long) (Math.random() * 500) + 500), TimeUnit.MILLISECONDS); // simulate latency
}
}
| 2,312 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/SocialService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class SocialService extends AbstractMiddleTierService {
public SocialService(EurekaClient client) {
super("reactive-lab-social-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
return Observable.from(request.getQueryParameters().get("userId")).map(userId -> {
Map<String, Object> user = new HashMap<>();
user.put("userId", userId);
user.put("friends", Arrays.asList(randomUser(), randomUser(), randomUser(), randomUser()));
return user;
}).flatMap(list -> response.writeStringAndFlush("data: " + SimpleJson.mapToJson(list) + "\n"))
.delay(((long) (Math.random() * 100) + 20), TimeUnit.MILLISECONDS).doOnCompleted(response::close); // simulate latency
}
private static int randomUser() {
return ((int) (Math.random() * 10000));
}
}
| 2,313 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/AbstractMiddleTierService.java | package io.reactivex.lab.services.impls;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.lab.services.metrics.HystrixMetricsStreamHandler;
import io.reactivex.lab.services.metrics.Metrics;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.pipeline.PipelineConfigurators;
import io.reactivex.netty.protocol.http.server.HttpServer;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.UUID;
import rx.Observable;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.registry.InstanceInfo;
import com.netflix.eureka2.registry.ServicePort;
import com.netflix.eureka2.registry.datacenter.BasicDataCenterInfo;
/**
* Common base for the service impls
*/
public abstract class AbstractMiddleTierService {
private EurekaClient client;
private HttpServer<ByteBuf, ServerSentEvent> server;
protected final String eurekaVipAddress;
private final Metrics metrics;
protected AbstractMiddleTierService(String eurekaVipAddress, EurekaClient client) {
this.eurekaVipAddress = eurekaVipAddress;
this.client = client;
this.metrics = new Metrics(eurekaVipAddress);
}
public HttpServer<ByteBuf, ServerSentEvent> createServer(int port) {
System.out.println("Start " + getClass().getSimpleName() + " on port: " + port);
// declare handler chain (wrapped in Hystrix)
// TODO create a better way of chaining these (related https://github.com/ReactiveX/RxNetty/issues/232 and https://github.com/ReactiveX/RxNetty/issues/202)
HystrixMetricsStreamHandler<ByteBuf, ServerSentEvent> handlerChain
= new HystrixMetricsStreamHandler<>(metrics, "/hystrix.stream", 1000, (request, response) -> {
try {
long startTime = System.currentTimeMillis();
return handleRequest(request, response)
.doOnCompleted(() -> System.out.println("Response => " + request.getPath() + " Time => " + (int) (System.currentTimeMillis() - startTime) + "ms"))
.doOnCompleted(() -> metrics.getRollingPercentile().addValue((int) (System.currentTimeMillis() - startTime)))
.doOnCompleted(() -> metrics.getRollingNumber().add(Metrics.EventType.SUCCESS, 1))
.doOnError(t -> metrics.getRollingNumber().add(Metrics.EventType.FAILURE, 1));
} catch (Throwable e) {
e.printStackTrace();
System.err.println("Server => Error [" + request.getPath() + "] => " + e);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("data: Error 500: Bad Request\n" + e.getMessage() + "\n");
}
});
return RxNetty.createHttpServer(port, (request, response) -> {
// System.out.println("Server => Request: " + request.getPath());
return handlerChain.handle(request, response);
}, PipelineConfigurators.<ByteBuf> serveSseConfigurator());
}
public void start(int port) {
server = createServer(port);
server.start();
client.register(createInstanceInfo(port)).toBlocking().lastOrDefault(null);
}
public void startAndWait(int port) {
start(port);
try {
server.waitTillShutdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void stop() {
client.unregister(createInstanceInfo(server.getServerPort())).doOnError(Throwable::printStackTrace).subscribe();
if (null != server) {
try {
server.shutdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
protected abstract Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response);
protected InstanceInfo createInstanceInfo(int port) {
final HashSet<ServicePort> ports = new HashSet<>(Arrays.asList(new ServicePort(port, false)));
String hostAddress = "unknown";
try {
hostAddress = InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
e.printStackTrace();
hostAddress = "unknown-" + UUID.randomUUID();
}
return new InstanceInfo.Builder()
.withId(hostAddress + "-" + port)
.withApp("reactive-lab")
.withStatus(InstanceInfo.Status.UP)
.withVipAddress(eurekaVipAddress)
.withPorts(ports)
.withDataCenterInfo(BasicDataCenterInfo.fromSystemData())
.build();
}
protected static Observable<Void> writeError(HttpServerRequest<?> request, HttpServerResponse<?> response, String message) {
System.err.println("Server => Error [" + request.getPath() + "] => " + message);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("Error 500: " + message + "\n");
}
protected static int getParameter(HttpServerRequest<?> request, String key, int defaultValue) {
List<String> v = request.getQueryParameters().get(key);
if (v == null || v.size() != 1) {
return defaultValue;
} else {
return Integer.parseInt(String.valueOf(v.get(0)));
}
}
public Metrics getMetrics() {
return metrics;
}
}
| 2,314 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/VideoMetadataService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class VideoMetadataService extends AbstractMiddleTierService {
public VideoMetadataService(EurekaClient client) {
super("reactive-lab-vms-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
List<String> videoIds = request.getQueryParameters().get("videoId");
return Observable.from(videoIds).map(videoId -> {
Map<String, Object> video = new HashMap<>();
video.put("videoId", videoId);
video.put("title", "Video Title");
video.put("other_data", "goes_here");
return video;
}).flatMap(video -> response.writeStringAndFlush("data: " + SimpleJson.mapToJson(video) + "\n")
.doOnCompleted(response::close))
.delay(((long) (Math.random() * 20) + 20), TimeUnit.MILLISECONDS); // simulate latency
}
}
| 2,315 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/GeoService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class GeoService extends AbstractMiddleTierService {
public GeoService(EurekaClient client) {
super("reactive-lab-geo-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
return request.getContent().flatMap(i -> {
List<String> ips = request.getQueryParameters().get("ip");
Map<String, Object> data = new HashMap<>();
for (String ip : ips) {
Map<String, Object> ip_data = new HashMap<>();
ip_data.put("country_code", "GB");
ip_data.put("longitude", "-0.13");
ip_data.put("latitude", "51.5");
data.put(ip, ip_data);
}
return response.writeStringAndFlush("data: " + SimpleJson.mapToJson(data) + "\n")
.doOnCompleted(response::close);
}).delay(10, TimeUnit.MILLISECONDS);
}
}
| 2,316 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/BookmarksService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.Random;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class BookmarksService extends AbstractMiddleTierService {
public BookmarksService(EurekaClient client) {
super("reactive-lab-bookmark-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
List<String> videoIds = request.getQueryParameters().get("videoId");
int latency = 1;
if (Random.randomIntFrom0to100() > 80) {
latency = 10;
}
return Observable.from(videoIds).map(videoId -> {
Map<String, Object> video = new HashMap<>();
video.put("videoId", videoId);
video.put("position", (int) (Math.random() * 5000));
return video;
}).flatMap(video -> response.writeStringAndFlush("data: " + SimpleJson.mapToJson(video) + "\n"))
.delay(latency, TimeUnit.MILLISECONDS).doOnCompleted(response::close); // simulate latency
}
}
| 2,317 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/MockService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.List;
public class MockService extends AbstractMiddleTierService {
public MockService(EurekaClient client) {
super("reactive-lab-mock-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
List<String> _id = request.getQueryParameters().get("id");
if (_id == null || _id.size() != 1) {
return writeError(request, response, "Please provide a numerical 'id' value. It can be a random number (uuid). Received => " + _id);
}
long id = Long.parseLong(String.valueOf(_id.get(0)));
int delay = getParameter(request, "delay", 50); // default to 50ms server-side delay
int itemSize = getParameter(request, "itemSize", 128); // default to 128 bytes item size (assuming ascii text)
int numItems = getParameter(request, "numItems", 10); // default to 10 items in a list
// no more than 100 items
if (numItems < 1 || numItems > 100) {
return writeError(request, response, "Please choose a 'numItems' value from 1 to 100.");
}
// no larger than 50KB per item
if (itemSize < 1 || itemSize > 1024 * 50) {
return writeError(request, response, "Please choose an 'itemSize' value from 1 to 1024*50 (50KB).");
}
// no larger than 60 second delay
if (delay < 0 || delay > 60000) {
return writeError(request, response, "Please choose a 'delay' value from 0 to 60000 (60 seconds).");
}
response.setStatus(HttpResponseStatus.OK);
return MockResponse.generateJson(id, delay, itemSize, numItems)
.flatMap(json -> response.writeStringAndFlush("data:" + json + "\n"))
.doOnCompleted(response::close);
}
}
| 2,318 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/RatingsService.java | package io.reactivex.lab.services.impls;
import com.netflix.eureka2.client.EurekaClient;
import io.reactivex.lab.services.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import rx.Observable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class RatingsService extends AbstractMiddleTierService {
public RatingsService(EurekaClient client) {
super("reactive-lab-ratings-service", client);
}
@Override
protected Observable<Void> handleRequest(HttpServerRequest<?> request, HttpServerResponse<ServerSentEvent> response) {
List<String> videoIds = request.getQueryParameters().get("videoId");
return Observable.from(videoIds).map(videoId -> {
Map<String, Object> video = new HashMap<>();
video.put("videoId", videoId);
video.put("estimated_user_rating", 3.5);
video.put("actual_user_rating", 4);
video.put("average_user_rating", 3.1);
return video;
}).flatMap(video -> response.writeStringAndFlush("data: " + SimpleJson.mapToJson(video) + "\n"))
.delay(20, TimeUnit.MILLISECONDS).doOnCompleted(response::close); // simulate latenc
}
}
| 2,319 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/impls/MockResponse.java | package io.reactivex.lab.services.impls;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerator;
import rx.Observable;
import rx.Scheduler.Worker;
import rx.Subscriber;
import rx.schedulers.Schedulers;
import java.io.StringWriter;
import java.util.concurrent.TimeUnit;
/**
* Generate responses with varying types of payloads depending on request arguments.
* <p>
* <ul>
* <li><b>delay</b> - time in milliseconds to delay response to simulate server-side latency</li>
* <li><b>itemSize</b> - size in characters desired for each item</li>
* <li><b>numItems</b> - number of items in a list to return to make the client parse</li>
* </ul>
*/
public class MockResponse {
private final static JsonFactory jsonFactory = new JsonFactory();
private static String RAW_ITEM_LONG;
private static int MAX_ITEM_LENGTH = 1024 * 50;
static {
StringBuilder builder = new StringBuilder(MAX_ITEM_LENGTH);
String LOREM = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
int length = 0;
while (length < MAX_ITEM_LENGTH) {
builder.append(LOREM);
length += LOREM.length();
}
RAW_ITEM_LONG = builder.toString();
}
/**
*
* @param id
* ID from client used to assert correct client/server interaction
* @param delay
* How long to delay delivery to simulate server-side latency
* @param itemSize
* Length of each item String.
* @param numItems
* Number of items in response.
*
* @return String json
*/
public static Observable<String> generateJson(long id, int delay, int itemSize, int numItems) {
return Observable.create((Subscriber<? super String> subscriber) -> {
Worker worker = Schedulers.computation().createWorker();
subscriber.add(worker);
worker.schedule(() -> {
try {
StringWriter jsonString = new StringWriter();
JsonGenerator json = jsonFactory.createJsonGenerator(jsonString);
json.writeStartObject();
// manipulate the ID such that we can know the response is from the server (client will know the logic)
long responseKey = getResponseKey(id);
json.writeNumberField("responseKey", responseKey);
json.writeNumberField("delay", delay);
if (itemSize > MAX_ITEM_LENGTH) {
throw new IllegalArgumentException("itemSize can not be larger than: " + MAX_ITEM_LENGTH);
}
json.writeNumberField("itemSize", itemSize);
json.writeNumberField("numItems", numItems);
json.writeArrayFieldStart("items");
for (int i = 0; i < numItems; i++) {
json.writeString(RAW_ITEM_LONG.substring(0, itemSize));
}
json.writeEndArray();
json.writeEndObject();
json.close();
subscriber.onNext(jsonString.toString());
subscriber.onCompleted();
} catch (Exception e) {
subscriber.onError(e);
}
}, delay, TimeUnit.MILLISECONDS);
});
}
/* package */static long getResponseKey(long id) {
return ((id / 37) + 5739375) * 7;
}
}
| 2,320 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/common/Random.java | package io.reactivex.lab.services.common;
public class Random {
public static int randomIntFrom0to100() {
// XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
// benjchristensen => also ... I've personally experienced Math.random() giving bad performance in certain environments when called alot
long x = System.nanoTime();
x ^= (x << 21);
x ^= (x >>> 35);
x ^= (x << 4);
return Math.abs((int) x % 100);
}
}
| 2,321 |
0 | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services | Create_ds/ReactiveLab/reactive-lab-services/src/main/java/io/reactivex/lab/services/common/SimpleJson.java | package io.reactivex.lab.services.common;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectReader;
import org.codehaus.jackson.map.ObjectWriter;
import java.io.IOException;
import java.util.Map;
public class SimpleJson {
private static final SimpleJson INSTANCE = new SimpleJson();
private SimpleJson() {
}
public static Map<String, Object> jsonToMap(String jsonString) {
return INSTANCE._jsonToMap(jsonString);
}
public static String mapToJson(Map<String, ?> map) {
return INSTANCE._mapToJson(map);
}
private final ObjectMapper objectMapper = new ObjectMapper();
private final ObjectReader objectReader = objectMapper.reader(Map.class);
private Map<String, Object> _jsonToMap(String jsonString) {
try {
return objectReader.readValue(jsonString);
} catch (IOException e) {
throw new RuntimeException("Unable to parse JSON", e);
}
}
private final ObjectWriter objectWriter = objectMapper.writerWithType(Map.class);
private String _mapToJson(Map<String, ?> map) {
try {
return objectWriter.writeValueAsString(map);
} catch (IOException e) {
throw new RuntimeException("Unable to write JSON", e);
}
}
}
| 2,322 |
0 | Create_ds/ReactiveLab/reactive-lab-dashboard/src/main/java/com/netflix/hystrix/dashboard | Create_ds/ReactiveLab/reactive-lab-dashboard/src/main/java/com/netflix/hystrix/dashboard/stream/MockStreamServlet.java | package com.netflix.hystrix.dashboard.stream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.nio.charset.Charset;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Simulate an event stream URL by retrieving pre-canned data instead of going to live servers.
*/
public class MockStreamServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final Logger logger = LoggerFactory.getLogger(MockStreamServlet.class);
public MockStreamServlet() {
super();
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String filename = request.getParameter("file");
if (filename == null) {
// default to using hystrix.stream
filename = "hystrix.stream";
} else {
// strip any .. / characters to avoid security problems
filename = filename.replaceAll("\\.\\.", "");
filename = filename.replaceAll("/", "");
}
int delay = 500;
String delayArg = request.getParameter("delay");
if (delayArg != null) {
delay = Integer.parseInt(delayArg);
}
int batch = 1;
String batchArg = request.getParameter("batch");
if (batchArg != null) {
batch = Integer.parseInt(batchArg);
}
String data = getFileFromPackage(filename);
String lines[] = data.split("\n");
response.setContentType("text/event-stream");
response.setCharacterEncoding("UTF-8");
int batchCount = 0;
// loop forever unless the user closes the connection
for (;;) {
for (String s : lines) {
s = s.trim();
if (s.length() > 0) {
try {
response.getWriter().println(s);
response.getWriter().println(""); // a newline is needed after each line for the events to trigger
response.getWriter().flush();
batchCount++;
} catch (Exception e) {
logger.warn("Exception writing mock data to output.", e);
// most likely the user closed the connection
return;
}
if (batchCount == batch) {
// we insert the delay whenever we finish a batch
try {
// simulate the delays we get from the real feed
Thread.sleep(delay);
} catch (InterruptedException e) {
// ignore
}
// reset
batchCount = 0;
}
}
}
}
}
private String getFileFromPackage(String filename) {
try {
String file = "/" + this.getClass().getPackage().getName().replace('.', '/') + "/" + filename;
InputStream is = this.getClass().getResourceAsStream(file);
try {
/* this is FAR too much work just to get a string from a file */
BufferedReader in = new BufferedReader(new InputStreamReader(is, Charset.forName("UTF-8")));
StringWriter s = new StringWriter();
int c = -1;
while ((c = in.read()) > -1) {
s.write(c);
}
return s.toString();
} finally {
is.close();
}
} catch (Exception e) {
throw new RuntimeException("Could not find file: " + filename, e);
}
}
}
| 2,323 |
0 | Create_ds/ReactiveLab/reactive-lab-dashboard/src/main/java/com/netflix/hystrix/dashboard | Create_ds/ReactiveLab/reactive-lab-dashboard/src/main/java/com/netflix/hystrix/dashboard/stream/ProxyStreamServlet.java | package com.netflix.hystrix.dashboard.stream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.PoolingClientConnectionManager;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Proxy an EventStream request (data.stream via proxy.stream) since EventStream does not yet support CORS (https://bugs.webkit.org/show_bug.cgi?id=61862)
* so that a UI can request a stream from a different server.
*/
public class ProxyStreamServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final Logger logger = LoggerFactory.getLogger(ProxyStreamServlet.class);
public ProxyStreamServlet() {
super();
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String origin = request.getParameter("origin");
if (origin == null) {
response.setStatus(500);
response.getWriter().println("Required parameter 'origin' missing. Example: 107.20.175.135:7001");
}
origin = origin.trim();
HttpGet httpget = null;
InputStream is = null;
boolean hasFirstParameter = false;
StringBuilder url = new StringBuilder();
if (!origin.startsWith("http")) {
url.append("http://");
}
url.append(origin);
if (origin.contains("?")) {
hasFirstParameter = true;
}
@SuppressWarnings("unchecked")
Map<String, String[]> params = request.getParameterMap();
for (String key : params.keySet()) {
if (!key.equals("origin")) {
String[] values = params.get(key);
String value = values[0].trim();
if (hasFirstParameter) {
url.append("&");
} else {
url.append("?");
hasFirstParameter = true;
}
url.append(key).append("=").append(value);
}
}
String proxyUrl = url.toString();
logger.info("\n\nProxy opening connection to: " + proxyUrl + "\n\n");
try {
httpget = new HttpGet(proxyUrl);
HttpClient client = ProxyConnectionManager.httpClient;
HttpResponse httpResponse = client.execute(httpget);
int statusCode = httpResponse.getStatusLine().getStatusCode();
if (statusCode == HttpStatus.SC_OK) {
// writeTo swallows exceptions and never quits even if outputstream is throwing IOExceptions (such as broken pipe) ... since the inputstream is infinite
// httpResponse.getEntity().writeTo(new OutputStreamWrapper(response.getOutputStream()));
// so I copy it manually ...
is = httpResponse.getEntity().getContent();
// set headers
for (Header header : httpResponse.getAllHeaders()) {
response.addHeader(header.getName(), header.getValue());
}
// copy data from source to response
OutputStream os = response.getOutputStream();
int b = -1;
while ((b = is.read()) != -1) {
try {
os.write(b);
if (b == 10 /** flush buffer on line feed */) {
os.flush();
}
} catch (Exception e) {
if (e.getClass().getSimpleName().equalsIgnoreCase("ClientAbortException")) {
// don't throw an exception as this means the user closed the connection
logger.debug("Connection closed by client. Will stop proxying ...");
// break out of the while loop
break;
} else {
// received unknown error while writing so throw an exception
throw new RuntimeException(e);
}
}
}
}
} catch (Exception e) {
logger.error("Error proxying request: " + url, e);
} finally {
if (httpget != null) {
try {
httpget.abort();
} catch (Exception e) {
logger.error("failed aborting proxy connection.", e);
}
}
// httpget.abort() MUST be called first otherwise is.close() hangs (because data is still streaming?)
if (is != null) {
// this should already be closed by httpget.abort() above
try {
is.close();
} catch (Exception e) {
// e.printStackTrace();
}
}
}
}
private static class ProxyConnectionManager {
private final static PoolingClientConnectionManager threadSafeConnectionManager = new PoolingClientConnectionManager();
private final static HttpClient httpClient = new DefaultHttpClient(threadSafeConnectionManager);
static {
logger.debug("Initialize ProxyConnectionManager");
/* common settings */
HttpParams httpParams = httpClient.getParams();
HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
HttpConnectionParams.setSoTimeout(httpParams, 10000);
/* number of connections to allow */
threadSafeConnectionManager.setDefaultMaxPerRoute(400);
threadSafeConnectionManager.setMaxTotal(400);
}
}
}
| 2,324 |
0 | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab/tutorial/ClientServer.java | package io.reactivex.lab.tutorial;
import io.netty.buffer.ByteBuf;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.server.HttpServer;
import rx.Observable;
import java.nio.charset.Charset;
import java.util.Map;
/**
* This example starts a simple HTTP server and client to demonstrate how to use RxNetty HTTP protocol.
*/
public class ClientServer {
public static void main(String[] args) {
/**
* Start our HTTP server.
*/
HttpServer<ByteBuf, ByteBuf> server = startServer(8088);
/**
* Submit the request.
*/
createRequest("localhost", server.getServerPort())
/* Block till you get the response. In a real world application, one should not be blocked but chained
* into a response to the caller. */
.toBlocking()
/**
* Print each content of the response.
*/
.forEach(System.out::println);
}
public static HttpServer<ByteBuf, ByteBuf> startServer(int port) {
/**
* Creates an HTTP server which returns "Hello World!" responses.
*/
return RxNetty.createHttpServer(port,
/*
* HTTP Request handler for RxNetty where you control what you write as the
* response for each and every request the server receives.
*/
(request, response) -> {
/**
* In a real server, you would be writing different responses based on the
* URI of the request.
* This example just returns a "Hello World!!" string unconditionally.
*/
return response.writeStringAndFlush("Hello World!!");
})
.start();
}
public static Observable<String> createRequest(String host, int port) {
/**
* Creates an HTTP client bound to the provided host and port.
*/
return RxNetty.createHttpClient(host, port)
/* Submit an HTTP GET request with uri "/hello" */
.submit(HttpClientRequest.createGet("/hello"))
/* Print the HTTP initial line and headers. Return the content.*/
.flatMap(response -> {
/**
* Printing the HTTP initial line.
*/
System.out.println(response.getHttpVersion().text() + ' ' + response.getStatus().code()
+ ' ' + response.getStatus().reasonPhrase());
/**
* Printing HTTP headers.
*/
for (Map.Entry<String, String> header : response.getHeaders().entries()) {
System.out.println(header.getKey() + ": " + header.getValue());
}
// Line break after the headers.
System.out.println();
return response.getContent();
})
/* Convert the ByteBuf for each content chunk into a string. */
.map(byteBuf -> byteBuf.toString(Charset.defaultCharset()));
}
}
| 2,325 |
0 | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab/tutorial/ClientServerWithLoadBalancer.java | package io.reactivex.lab.tutorial;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.interests.Interests;
import com.netflix.eureka2.registry.NetworkAddress;
import com.netflix.eureka2.registry.ServicePort;
import io.netty.buffer.ByteBuf;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.client.HttpClient;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.client.HttpClientResponse;
import io.reactivex.netty.protocol.http.server.HttpServer;
import netflix.ocelli.Host;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.LoadBalancers;
import netflix.ocelli.MembershipEvent;
import netflix.ocelli.eureka.EurekaMembershipSource;
import rx.Observable;
import rx.functions.Func1;
import java.nio.charset.Charset;
import java.util.HashSet;
import java.util.Map;
import java.util.stream.Collectors;
/**
* This example builds over the {@link ClientServerWithDiscovery} example by adding the load balancer Ocelli.
* So, in comparison to {@link ClientServerWithDiscovery} which directly fetches the server instance information from
* eureka, this example chooses an optimal host from the load balancer.
*
* In order to be a standalone example, this also starts an embedded eureka server.
*/
public class ClientServerWithLoadBalancer {
public static void main(String[] args) throws Exception {
final int eurekaReadServerPort = 7007;
final int eurekaWriteServerPort = 7008;
/**
* Starts an embedded eureka server with the defined read and write ports.
*/
ClientServerWithDiscovery.startEurekaServer(eurekaReadServerPort, eurekaWriteServerPort);
/**
* Create eureka client with the same read and write ports for the embedded eureka server.
*/
EurekaClient eurekaClient = ClientServerWithDiscovery.createEurekaClient(eurekaReadServerPort,
eurekaWriteServerPort);
/**
* Reuse {@link ClientServer} example to start an RxNetty server on the passed port.
*/
HttpServer<ByteBuf, ByteBuf> server = ClientServer.startServer(8089);
/**
* Register the server started above with eureka using a unique virtual IP address (VIP).
* Eureka uses VIPs to group homogeneous instances of a service together, so that they can be used by clients,
* interchangeably.
*/
String vipAddress = "mock_server-" + server.getServerPort();
ClientServerWithDiscovery.registerWithEureka(server.getServerPort(), eurekaClient, vipAddress);
/**
* Using the eureka client, create an Ocelli Host event stream.
* Ocelli, uses this host stream to know about the available hosts.
*/
Observable<MembershipEvent<Host>> eurekaHostSource = createEurekaHostStream(eurekaClient, vipAddress);
/**
* Instead of directly using the host and port from eureka as in example {@link ClientServerWithDiscovery},
* choose a host from the load balancer.
*/
createRequestFromLB(eurekaHostSource)
/* Block till you get the response. In a real world application, one should not be blocked but chained
* into a response to the caller. */
.toBlocking()
/**
* Print each content of the response.
*/
.forEach(System.out::println);
}
public static Observable<String> createRequestFromLB(Observable<MembershipEvent<Host>> eurekaHostSource) {
/**
* Create a LoadBalancer instance from eureka's host stream.
*/
return LoadBalancers.fromHostSource(
/**
* Map over the host event and create a RxNetty HTTP client.
* This enable Ocelli to directly manage the client instance and hence reduce a map lookup to get a
* client instance for a host for every request processing.
* If you prefer Ocelli to manage the host instances, that is possible too by omitting this map function
* and transforming the retrieved host via {@link LoadBalancer#choose()} to a client of
* your choice.
*/
eurekaHostSource.map(
hostEvent -> {
Host host = hostEvent.getClient();
/**
* Typically, you will use a pool of clients, so that for the same host, you do not end up creating a
* new client instance.
* This example creates a new client to reduce verbosity.
*/
HttpClient<ByteBuf, ByteBuf> client = RxNetty.createHttpClient(host.getHostName(),
host.getPort());
/**
* Since, Ocelli expects a {@link netflix.ocelli.MembershipEvent} instance, wrap the client
* into that event.
*/
return new MembershipEvent<>(hostEvent.getType(), client);
}))
.choose() /* Chooses the best possible host for the next request*/
/**
* Submit the request to the returned client.
*/
.flatMap(client ->
client.submit(HttpClientRequest.createGet("/"))
/* Print the HTTP initial line and headers. Return the content.*/
.flatMap((Func1<HttpClientResponse<ByteBuf>, Observable<ByteBuf>>) response -> {
/**
* Printing the HTTP initial line.
*/
System.out.println( response.getHttpVersion().text() + ' '
+ response.getStatus().code() + ' '
+ response .getStatus().reasonPhrase());
/**
* Printing HTTP headers.
*/
for (Map.Entry<String, String> header : response.getHeaders().entries()) {
System.out.println(header.getKey() + ": " + header.getValue());
}
// Line break after the headers.
System.out.println();
return response.getContent();
})
/* Convert the ByteBuf for each content chunk into a string. */
.map(byteBuf -> byteBuf.toString(Charset.defaultCharset())));
}
public static Observable<MembershipEvent<Host>> createEurekaHostStream(EurekaClient eurekaClient,
String vipAddress) {
EurekaMembershipSource membershipSource = new EurekaMembershipSource(eurekaClient);
/**
* Eureka client caches data streams from the server to decouple users from blips in connection between client
* & server. The below call makes sure that the data is fetched by the client and hence it is guaranteed to be
* available when the load balancer queries for the same.
*
* This is just to make sure that the demo runs without inducing artificial delays in the code.
* A real application should not advertise itself healthy in eureka till it has all the information it requires
* in order to run gracefully. In this case, the list of target servers from eureka.
*/
eurekaClient.forInterest(Interests.forFullRegistry()).take(1).toBlocking().first();// Warm up eureka data
return membershipSource.forInterest(Interests.forVips(vipAddress), instanceInfo -> {
/**
* Filtering out all non-IPv4 addresses.
*/
String ipAddress = instanceInfo.getDataCenterInfo()
.getAddresses().stream()
.filter(na -> na.getProtocolType() == NetworkAddress.ProtocolType.IPv4)
.collect(Collectors.toList()).get(0).getIpAddress();
HashSet<ServicePort> servicePorts = instanceInfo.getPorts();
ServicePort portToUse = servicePorts.iterator().next();
return new Host(ipAddress, portToUse.getPort());
});
}
}
| 2,326 |
0 | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab/tutorial/ClientServerWithDiscovery.java | package io.reactivex.lab.tutorial;
import com.netflix.eureka2.client.Eureka;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.client.resolver.ServerResolver;
import com.netflix.eureka2.client.resolver.ServerResolvers;
import com.netflix.eureka2.interests.ChangeNotification;
import com.netflix.eureka2.registry.InstanceInfo;
import com.netflix.eureka2.registry.NetworkAddress;
import com.netflix.eureka2.registry.ServicePort;
import com.netflix.eureka2.registry.datacenter.BasicDataCenterInfo;
import com.netflix.eureka2.registry.datacenter.LocalDataCenterInfo;
import com.netflix.eureka2.server.EurekaWriteServer;
import com.netflix.eureka2.server.WriteServerConfig;
import com.netflix.eureka2.transport.EurekaTransports;
import io.netty.buffer.ByteBuf;
import io.reactivex.netty.protocol.http.server.HttpServer;
import java.util.Arrays;
import java.util.HashSet;
import java.util.stream.Collectors;
/**
* This example builds over the basic {@link ClientServer} example by adding registration to eureka server.
*
* In order to be a standalone example, this also starts an embedded eureka server.
*/
public class ClientServerWithDiscovery {
public static class Host {
private String ipAddress;
private int port;
public Host(String ipAddress, int port) {
this.ipAddress = ipAddress;
this.port = port;
}
public String getIpAddress() {
return ipAddress;
}
public int getPort() {
return port;
}
}
public static void main(String[] args) throws Exception {
final int eurekaReadServerPort = 7005;
final int eurekaWriteServerPort = 7006;
/**
* Starts an embedded eureka server with the defined read and write ports.
*/
startEurekaServer(eurekaReadServerPort, eurekaWriteServerPort);
/**
* Create eureka client with the same read and write ports for the embedded eureka server.
*/
EurekaClient eurekaClient = createEurekaClient(eurekaReadServerPort, eurekaWriteServerPort);
/**
* Reuse {@link ClientServer} example to start an RxNetty server on the passed port.
*/
HttpServer<ByteBuf, ByteBuf> server = ClientServer.startServer(8089);
/**
* Register the server started above with eureka using a unique virtual IP address (VIP).
* Eureka uses VIPs to group homogeneous instances of a service together, so that they can be used by clients,
* interchangeably.
*/
String vipAddress = "mock_server-" + server.getServerPort();
registerWithEureka(server.getServerPort(), eurekaClient, vipAddress);
/**
* Retrieve the instance information of the registered server from eureka.
* This is to demonstrate how to use eureka to fetch information about any server in your deployment.
* In order to fetch information from eureka, one MUST know the VIP address of the server before hand.
*/
InstanceInfo serverInfo = getServerInfo(eurekaClient, vipAddress);
/**
* Retrieve IPAddress and port information from the instance information returned from eureka.
*/
Host host = getServerHostAndPort(serverInfo);
/**
* Reuse {@link ClientServer} example to create an HTTP request to the server retrieved from eureka.
*/
ClientServer.createRequest(host.getIpAddress(), host.getPort())
/* Block till you get the response. In a real world application, one should not be blocked but chained
* into a response to the caller. */
.toBlocking()
/**
* Print each content of the response.
*/
.forEach(System.out::println);
}
public static Host getServerHostAndPort(InstanceInfo serverInfo) {
String ipAddress = serverInfo.getDataCenterInfo()
.getAddresses().stream()
.filter(na -> na.getProtocolType() == NetworkAddress.ProtocolType.IPv4)
.collect(Collectors.toList()).get(0).getIpAddress();
Integer port = serverInfo.getPorts().iterator().next().getPort();
return new Host(ipAddress, port);
}
public static InstanceInfo getServerInfo(EurekaClient eurekaClient, String vipAddress) {
return eurekaClient.forVips(vipAddress)
.map(notification -> {
System.out.println(notification);
return notification;
})
.filter(notification -> notification.getKind() == ChangeNotification.Kind.Add) /* Filter all notifications which are not add */
.map(ChangeNotification::getData) /*Retrieve only the data*/
.toBlocking()
.first();
}
public static EurekaWriteServer startEurekaServer(int eurekaReadServerPort, int eurekaWriteServerPort)
throws Exception {
WriteServerConfig.WriteServerConfigBuilder builder = new WriteServerConfig.WriteServerConfigBuilder();
builder.withReadServerPort(eurekaReadServerPort)
.withWriteServerPort(eurekaWriteServerPort)
.withReplicationPort(8888)
.withWriteClusterAddresses(new String[] { "127.0.01"})
.withCodec(EurekaTransports.Codec.Avro)
.withDataCenterType(LocalDataCenterInfo.DataCenterType.Basic);
EurekaWriteServer eurekaWriteServer = new EurekaWriteServer(builder.build());
/* start the server */
eurekaWriteServer.start();
System.out.println("Started eureka server....");
return eurekaWriteServer;
}
public static void registerWithEureka(int serverPort, EurekaClient client, String vipAddress) {
final HashSet<ServicePort> ports = new HashSet<>(Arrays.asList(new ServicePort(serverPort, false)));
InstanceInfo instance = new InstanceInfo.Builder()
.withId(String.valueOf(serverPort))
.withApp("mock_server")
.withStatus(InstanceInfo.Status.UP)
.withVipAddress(vipAddress)
.withPorts(ports)
.withDataCenterInfo(BasicDataCenterInfo.fromSystemData())
.build();
client.register(instance).toBlocking().lastOrDefault(null); // Wait till the registration is successful.
}
public static EurekaClient createEurekaClient(int eurekaReadServerPort, int eurekaWriteServerPort) {
ServerResolver.Server discoveryServer = new ServerResolver.Server("127.0.0.1", eurekaReadServerPort);
ServerResolver.Server registrationServer = new ServerResolver.Server("127.0.0.1", eurekaWriteServerPort);
return Eureka.newClientBuilder(ServerResolvers.from(discoveryServer),
ServerResolvers.from(registrationServer))
.build();
}
}
| 2,327 |
0 | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-tutorial/src/main/java/io/reactivex/lab/tutorial/ClientServerWithResiliencePatterns.java | package io.reactivex.lab.tutorial;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.netty.protocol.http.server.HttpServer;
import netflix.ocelli.Host;
import netflix.ocelli.MembershipEvent;
import rx.Observable;
import java.util.concurrent.TimeUnit;
/**
* This example builds over the {@link ClientServerWithLoadBalancer} example by adding hystrix.
* So, in comparison to {@link ClientServerWithLoadBalancer} which directly invokes the load balancer, this example
* wraps the invocation and request execution with a hystrix command.
*
* In order to be a standalone example, this also starts an embedded eureka server.
*/
public class ClientServerWithResiliencePatterns {
public static void main(String[] args) throws Exception {
final int eurekaReadServerPort = 7008;
final int eurekaWriteServerPort = 7010;
/**
* Starts an embedded eureka server with the defined read and write ports.
*/
ClientServerWithDiscovery.startEurekaServer(eurekaReadServerPort, eurekaWriteServerPort);
/**
* Create eureka client with the same read and write ports for the embedded eureka server.
*/
EurekaClient eurekaClient = ClientServerWithDiscovery.createEurekaClient(eurekaReadServerPort,
eurekaWriteServerPort);
/**
* Reuse {@link ClientServer} example to start an RxNetty server on the passed port.
*/
HttpServer<ByteBuf, ByteBuf> server = ClientServer.startServer(8089);
/**
* Register the server started above with eureka using a unique virtual IP address (VIP).
* Eureka uses VIPs to group homogeneous instances of a service together, so that they can be used by clients,
* interchangeably.
*/
String vipAddress = "mock_server-" + server.getServerPort();
ClientServerWithDiscovery.registerWithEureka(server.getServerPort(), eurekaClient, vipAddress);
/**
* Using the eureka client, create an Ocelli Host event stream.
* Ocelli, uses this host stream to know about the available hosts.
*/
Observable<MembershipEvent<Host>> eurekaHostSource = ClientServerWithLoadBalancer.createEurekaHostStream(
eurekaClient, vipAddress);
MyCommand myCommand = new MyCommand(eurekaHostSource);
/**
* This executes the request on the client (just as {@link ClientServerWithLoadBalancer} but using hystrix.
*/
myCommand.toObservable()
/* Block till you get the response. In a real world application, one should not be blocked but chained
* into a response to the caller. */
.toBlocking()
/**
* Print each content of the response.
*/
.forEach(System.out::println);
}
public static class MyCommand extends HystrixObservableCommand<String> {
private final Observable<MembershipEvent<Host>> eurekaHostSource;
public MyCommand(Observable<MembershipEvent<Host>> eurekaHostSource) {
super(HystrixCommandGroupKey.Factory.asKey("MyCommand"));
this.eurekaHostSource = eurekaHostSource;
}
@Override
protected Observable<String> construct() {
return ClientServerWithLoadBalancer.createRequestFromLB(eurekaHostSource)
/**
* Artificial delay to demonstrate hystrix timeouts and fallbacks.
* Hystrix default timeout is 1 second.
*/
.delay(1, TimeUnit.SECONDS);
}
@Override
protected Observable<String> resumeWithFallback() {
return Observable.just("Fallback from Hystrix.");
}
}
}
| 2,328 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/test/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/test/java/io/reactivex/lab/gateway/mock/BackendResponseTest.java | package io.reactivex.lab.gateway.mock;
import static junit.framework.Assert.assertEquals;
import io.reactivex.lab.gateway.routes.mock.BackendResponse;
import org.junit.Test;
public class BackendResponseTest {
@Test
public void testJsonParse() throws Exception {
BackendResponse r = BackendResponse.fromJson("{ \"responseKey\": 9999, \"delay\": 50, \"itemSize\": 128, \"numItems\": 2, \"items\": [ \"Lorem\", \"Ipsum\" ]}");
assertEquals(9999, r.getResponseKey());
assertEquals(50, r.getDelay());
assertEquals(128, r.getItemSize());
assertEquals(2, r.getNumItems());
String[] items = r.getItems();
assertEquals(2, items.length);
assertEquals("Lorem", items[0]);
assertEquals("Ipsum", items[1]);
}
}
| 2,329 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/StartGatewayServer.java | package io.reactivex.lab.gateway;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.lab.gateway.hystrix.HystrixMetricsStreamHandler;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.lab.gateway.routes.RouteForDeviceHome;
import io.reactivex.lab.gateway.routes.mock.TestRouteBasic;
import io.reactivex.lab.gateway.routes.mock.TestRouteWithHystrix;
import io.reactivex.lab.gateway.routes.mock.TestRouteWithSimpleFaultTolerance;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import rx.Observable;
import com.netflix.hystrix.HystrixRequestLog;
import com.netflix.hystrix.strategy.concurrency.HystrixRequestContext;
public class StartGatewayServer {
static {
// discovery config
System.setProperty("reactivelab.eureka.server.host", "127.0.0.1");
System.setProperty("reactivelab.eureka.server.read.port", "7001");
System.setProperty("reactivelab.eureka.server.write.port", "7002");
}
public static void main(String... args) {
// initialize
DiscoveryAndLoadBalancer.getFactory();
// hystrix stream => http://localhost:9999
startHystrixMetricsStream();
System.out.println("Server => Starting at http://localhost:8080/");
System.out.println(" Sample URLs: ");
System.out.println(" - http://localhost:8080/device/home?userId=123");
System.out.println("----------------------------------------------------------------");
// start web services => http://localhost:8080
RxNetty.createHttpServer(8080, (request, response) -> {
if (request.getPath().contains("favicon.ico")) {
return Observable.empty();
}
// System.out.println("Server => Request: " + request.getPath());
return Observable.defer(() -> {
HystrixRequestContext.initializeContext();
try {
return handleRoutes(request, response);
} catch (Throwable e) {
System.err.println("Server => Error [" + request.getPath() + "] => " + e);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("Error 500: Bad Request\n" + e.getMessage() + "\n");
}
}).onErrorResumeNext(error -> {
System.err.println("Server => Error: " + error.getMessage());
error.printStackTrace();
return writeError(request, response, "Failed: " + error.getMessage());
}).doOnTerminate(() -> {
if (HystrixRequestContext.isCurrentThreadInitialized()) {
System.out.println("Server => Request [" + request.getPath() + "] => " + HystrixRequestLog.getCurrentRequest().getExecutedCommandsAsString());
HystrixRequestContext.getContextForCurrentThread().shutdown();
} else {
System.err.println("HystrixRequestContext not initialized for thread: " + Thread.currentThread());
}
response.close();
});
}).startAndWait();
}
/**
* Hard-coded route handling.
*/
private static Observable<Void> handleRoutes(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
if (request.getPath().equals("/device/home")) {
return new RouteForDeviceHome().handle(request, response);
} else if (request.getPath().equals("/testBasic")) {
return TestRouteBasic.handle(request, response);
} else if (request.getPath().equals("/testWithSimpleFaultTolerance")) {
return TestRouteWithSimpleFaultTolerance.handle(request, response);
} else if (request.getPath().equals("/testWithHystrix")) {
return TestRouteWithHystrix.handle(request, response);
} else {
return writeError(request, response, "Unknown path: " + request.getPath());
}
}
private static void startHystrixMetricsStream() {
HystrixMetricsStreamHandler<ByteBuf, ByteBuf> hystrixMetricsStreamHandler = new HystrixMetricsStreamHandler<>("/", 1000);
RxNetty.createHttpServer(9999, (request, response) -> {
System.out.println("Server => Start Hystrix Stream at http://localhost:9999");
return hystrixMetricsStreamHandler.handle(request, response);
}).start();
}
public static Observable<Void> writeError(HttpServerRequest<?> request, HttpServerResponse<ByteBuf> response, String message) {
System.err.println("Server => Error [" + request.getPath() + "] => " + message);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("Error 500: " + message);
}
}
| 2,330 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/ID.java | package io.reactivex.lab.gateway.clients;
public interface ID {
public int getId();
}
| 2,331 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/UrlGenerator.java | package io.reactivex.lab.gateway.clients;
import java.util.List;
public class UrlGenerator {
public static String generate(String paramName, List<?> list) {
StringBuffer url = new StringBuffer();
for (Object o : list) {
if (url.length() > 0) {
url.append("&");
}
url.append(paramName).append("=");
if (o instanceof ID) {
url.append(((ID) o).getId());
} else {
url.append(o);
}
}
return url.toString();
}
}
| 2,332 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/GeoCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.GeoCommand.GeoIP;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.List;
import java.util.Map;
public class GeoCommand extends HystrixObservableCommand<GeoIP> {
private final List<String> ips;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-geo-service");
public GeoCommand(List<String> ips) {
super(HystrixCommandGroupKey.Factory.asKey("GeoIP"));
this.ips = ips;
}
@Override
protected Observable<GeoIP> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/geo?" + UrlGenerator.generate("ip", ips));
return loadBalancer.choose()
.map(holder -> holder.getClient())
.<GeoIP>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent()
.map((ServerSentEvent sse) -> GeoIP.fromJson(sse.contentAsString()))))
.retry(1);
}
public static class GeoIP {
private final Map<String, Object> data;
private GeoIP(Map<String, Object> data) {
this.data = data;
}
public static GeoIP fromJson(String json) {
return new GeoIP(SimpleJson.jsonToMap(json));
}
}
}
| 2,333 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/BookmarksCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.BookmarksCommand.Bookmark;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand.Video;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class BookmarksCommand extends HystrixObservableCommand<Bookmark> {
final List<Video> videos;
private final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer;
final String cacheKey;
public BookmarksCommand(List<Video> videos, LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer) {
super(HystrixCommandGroupKey.Factory.asKey("GetBookmarks"));
this.videos = videos;
this.loadBalancer = loadBalancer;
StringBuilder b = new StringBuilder();
for (Video v : videos) {
b.append(v.getId()).append("-");
}
this.cacheKey = b.toString();
}
@Override
public Observable<Bookmark> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/bookmarks?" + UrlGenerator.generate("videoId", videos));
return loadBalancer.choose()
.map(holder -> holder.getClient())
.<Bookmark>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent().map((ServerSentEvent sse) -> Bookmark.fromJson(sse.contentAsString()))))
.retry(1);
}
protected Observable<Bookmark> resumeWithFallback() {
List<Bookmark> bs = new ArrayList<>();
for (Video v : videos) {
Map<String, Object> data = new HashMap<>();
data.put("position", 0);
data.put("videoId", v.getId());
bs.add(new Bookmark(data));
}
return Observable.from(bs);
}
@Override
protected String getCacheKey() {
return cacheKey;
}
public static class Bookmark {
private final Map<String, Object> data;
Bookmark(Map<String, Object> data) {
this.data = data;
}
public static Bookmark fromJson(String json) {
return new Bookmark(SimpleJson.jsonToMap(json));
}
public int getPosition() {
return (int) data.get("position");
}
public int getVideoId() {
return Integer.parseInt(String.valueOf(data.get("videoId")));
}
}
}
| 2,334 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/RatingsCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand.Video;
import io.reactivex.lab.gateway.clients.RatingsCommand.Rating;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class RatingsCommand extends HystrixObservableCommand<Rating> {
private final List<Video> videos;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-ratings-service");
public RatingsCommand(Video video) {
this(Arrays.asList(video));
// replace with HystrixCollapser
}
public RatingsCommand(List<Video> videos) {
super(HystrixCommandGroupKey.Factory.asKey("Ratings"));
this.videos = videos;
}
@Override
protected Observable<Rating> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/ratings?" + UrlGenerator.generate("videoId", videos));
return loadBalancer.choose()
.map(holder -> holder.getClient())
.<Rating>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent()
.map((ServerSentEvent sse) -> Rating.fromJson(sse.contentAsString()))))
.retry(1);
}
@Override
protected Observable<Rating> resumeWithFallback() {
Map<String, Object> video = new HashMap<>();
video.put("videoId", videos.get(0).getId());
video.put("estimated_user_rating", 3.5);
video.put("actual_user_rating", 4);
video.put("average_user_rating", 3.1);
return Observable.just(new Rating(video));
}
public static class Rating {
private final Map<String, Object> data;
private Rating(Map<String, Object> data) {
this.data = data;
}
public double getEstimatedUserRating() {
return (double) data.get("estimated_user_rating");
}
public double getActualUserRating() {
return (double) data.get("actual_user_rating");
}
public double getAverageUserRating() {
return (double) data.get("average_user_rating");
}
public static Rating fromJson(String json) {
return new Rating(SimpleJson.jsonToMap(json));
}
}
}
| 2,335 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/MockServiceCommand.java | package io.reactivex.lab.gateway.clients;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import io.reactivex.lab.gateway.routes.mock.BackendResponse;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.client.HttpClientResponse;
import rx.Observable;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixCommandKey;
import com.netflix.hystrix.HystrixCommandProperties;
import com.netflix.hystrix.HystrixObservableCommand;
public class MockServiceCommand extends HystrixObservableCommand<BackendResponse> {
private final long id;
private final int numItems;
private final int itemSize;
private final int delay;
public MockServiceCommand(long id, int numItems, int itemSize, int delay) {
super(Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("MiddleTier"))
.andCommandKey(HystrixCommandKey.Factory.asKey("MiddleTier"))
.andCommandPropertiesDefaults(HystrixCommandProperties.Setter()
.withExecutionIsolationSemaphoreMaxConcurrentRequests(5)
.withExecutionTimeoutInMilliseconds(200))); // change this timeout to <= 80 to see fallbacks
this.id = id;
this.numItems = numItems;
this.itemSize = itemSize;
this.delay = delay;
}
@Override
protected Observable<BackendResponse> construct() {
return RxNetty.createHttpClient("localhost", 9100)
.submit(HttpClientRequest.createGet("/mock.json?numItems=" + numItems + "&itemSize=" + itemSize + "&delay=" + delay + "&id=" + id))
.flatMap((HttpClientResponse<ByteBuf> r) -> r.getContent().map(b -> BackendResponse.fromJson(new ByteBufInputStream(b))));
}
@Override
protected Observable<BackendResponse> resumeWithFallback() {
return Observable.just(new BackendResponse(0, delay, numItems, itemSize, new String[] {}));
}
}
| 2,336 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/BookmarkCommand.java | package io.reactivex.lab.gateway.clients;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.BookmarksCommand.Bookmark;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand.Video;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.functions.Func1;
import com.netflix.hystrix.HystrixCollapser.CollapsedRequest;
import com.netflix.hystrix.HystrixObservableCollapser;
import com.netflix.hystrix.HystrixObservableCommand;
public class BookmarkCommand extends HystrixObservableCollapser<Integer, Bookmark, Bookmark, Video> {
private final Video video;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-bookmark-service");
public BookmarkCommand(Video video) {
this.video = video;
}
@Override
public Video getRequestArgument() {
return video;
}
@Override
protected HystrixObservableCommand<Bookmark> createCommand(Collection<CollapsedRequest<Bookmark, Video>> requests) {
List<Video> videos = new ArrayList<>();
for (CollapsedRequest<Bookmark, Video> r : requests) {
videos.add(r.getArgument());
}
return new BookmarksCommand(videos, loadBalancer);
}
protected void onMissingResponse(CollapsedRequest<Bookmark, Video> r) {
// set a default using setResponse or an exception like this
r.setException(new Exception("No bookmark"));
}
@Override
protected Func1<Bookmark, Integer> getBatchReturnTypeKeySelector() {
return Bookmark::getVideoId;
}
@Override
protected Func1<Video, Integer> getRequestArgumentKeySelector() {
return Video::getId;
}
@Override
protected Func1<Bookmark, Bookmark> getBatchReturnTypeToResponseTypeMapper() {
return (b) -> b;
}
}
| 2,337 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/VideoMetadataCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand.Video;
import io.reactivex.lab.gateway.clients.VideoMetadataCommand.VideoMetadata;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class VideoMetadataCommand extends HystrixObservableCommand<VideoMetadata> {
private final List<Video> videos;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-vms-service");
public VideoMetadataCommand(Video video) {
this(Arrays.asList(video));
// replace with HystrixCollapser
}
public VideoMetadataCommand(List<Video> videos) {
super(HystrixCommandGroupKey.Factory.asKey("VideoMetadata"));
this.videos = videos;
}
@Override
protected Observable<VideoMetadata> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/metadata?" + UrlGenerator.generate("videoId",
videos));
return loadBalancer.choose()
.map(holder -> holder.getClient())
.<VideoMetadata>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent()
.map((ServerSentEvent sse) -> VideoMetadata.fromJson(sse.contentAsString()))))
.retry(1);
}
@Override
protected Observable<VideoMetadata> resumeWithFallback() {
Map<String, Object> video = new HashMap<>();
video.put("videoId", videos.get(0).getId());
video.put("title", "Fallback Video Title");
video.put("other_data", "goes_here");
return Observable.just(new VideoMetadata(video));
}
public static class VideoMetadata {
private final Map<String, Object> data;
public VideoMetadata(Map<String, Object> data) {
this.data = data;
}
public static VideoMetadata fromJson(String json) {
return new VideoMetadata(SimpleJson.jsonToMap(json));
}
public int getId() {
return (int) data.get("videoId");
}
public String getTitle() {
return (String) data.get("title");
}
public Map<String, Object> getDataAsMap() {
return data;
}
}
}
| 2,338 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/PersonalizedCatalogCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand.Catalog;
import io.reactivex.lab.gateway.clients.UserCommand.User;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class PersonalizedCatalogCommand extends HystrixObservableCommand<Catalog> {
private final List<User> users;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-personalized-catalog-service");
public PersonalizedCatalogCommand(User user) {
this(Arrays.asList(user));
// replace with HystrixCollapser
}
public PersonalizedCatalogCommand(List<User> users) {
super(HystrixCommandGroupKey.Factory.asKey("PersonalizedCatalog"));
this.users = users;
}
@Override
protected Observable<Catalog> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/catalog?" + UrlGenerator.generate("userId", users));
return loadBalancer.choose()
.map(holder -> holder.getClient())
.<Catalog>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent()
.map((ServerSentEvent sse) -> Catalog.fromJson(sse.contentAsString()))))
.retry(1);
}
@Override
protected Observable<Catalog> resumeWithFallback() {
return Observable.from(users).<Catalog>map(u -> {
try {
Map<String, Object> userData = new HashMap<>();
userData.put("userId", u.getId());
userData.put("list_title", "Really quirky and over detailed list title!");
userData.put("other_data", "goes_here");
userData.put("videos", Arrays.asList(12345, 23456, 34567, 45678, 56789, 67890));
return new Catalog(userData);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException(e);
}
});
}
public static class Catalog {
private final Map<String, Object> data;
private Catalog(Map<String, Object> data) {
this.data = data;
}
@SuppressWarnings("unchecked")
public Observable<Video> videos() {
try {
return Observable.from((List<Integer>) data.get("videos")).map(Video::new);
} catch (Exception e) {
return Observable.error(e);
}
}
public static Catalog fromJson(String json) {
return new Catalog(SimpleJson.jsonToMap(json));
}
}
public static class Video implements ID {
private final int id;
public Video(int id) {
this.id = id;
}
public int getId() {
return id;
}
}
}
| 2,339 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/UserCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.UserCommand.User;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class UserCommand extends HystrixObservableCommand<User> {
private final List<String> userIds;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-user-service");
public UserCommand(List<String> userIds) {
super(HystrixCommandGroupKey.Factory.asKey("User"));
this.userIds = userIds;
}
@Override
protected Observable<User> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/user?" + UrlGenerator.generate("userId", userIds));
return loadBalancer.choose().map(holder -> holder.getClient())
.<User>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent().map(
(ServerSentEvent sse) -> {
String user = sse.contentAsString();
return User.fromJson(user);
})))
.retry(1);
}
@Override
protected Observable<User> resumeWithFallback() {
return Observable.from(userIds).map(id -> {
Map<String, Object> fallback = new HashMap<>();
fallback.put("userId", id);
fallback.put("name", "Fallback Name Here");
fallback.put("other_data", "goes_here");
User u = new User(fallback);
return u;
});
}
public static class User implements ID {
private final Map<String, Object> data;
public User(Map<String, Object> jsonToMap) {
this.data = jsonToMap;
}
public static User fromJson(String json) {
Map<String, Object> data = SimpleJson.jsonToMap(json);
if (!data.containsKey("userId")) {
throw new IllegalArgumentException("A User object requires a 'userId'");
} else {
try {
int id = Integer.parseInt(String.valueOf(data.get("userId")));
} catch (Exception e) {
throw new IllegalArgumentException("The `userId` must be an Integer");
}
}
return new User(data);
}
public int getId() {
return Integer.parseInt(String.valueOf(data.get("userId")));
}
public String getName() {
return (String) data.get("name");
}
}
}
| 2,340 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/clients/SocialCommand.java | package io.reactivex.lab.gateway.clients;
import com.netflix.hystrix.HystrixCommandGroupKey;
import com.netflix.hystrix.HystrixObservableCommand;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.clients.SocialCommand.Social;
import io.reactivex.lab.gateway.clients.UserCommand.User;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.lab.gateway.loadbalancer.DiscoveryAndLoadBalancer;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.rxnetty.HttpClientHolder;
import rx.Observable;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SocialCommand extends HystrixObservableCommand<Social> {
private final List<User> users;
private static final LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> loadBalancer =
DiscoveryAndLoadBalancer.getFactory().forVip("reactive-lab-social-service");
public SocialCommand(User user) {
this(Arrays.asList(user));
// replace with HystrixCollapser
}
public SocialCommand(List<User> users) {
super(HystrixCommandGroupKey.Factory.asKey("Social"));
this.users = users;
}
@Override
protected Observable<Social> construct() {
HttpClientRequest<ByteBuf> request = HttpClientRequest.createGet("/social?" + UrlGenerator.generate("userId", users));
return loadBalancer.choose().map(holder -> holder.getClient())
.<Social>flatMap(client -> client.submit(request)
.flatMap(r -> r.getContent().map((ServerSentEvent sse) -> {
String social = sse.contentAsString();
return Social.fromJson(social);
})))
.retry(1);
}
@Override
protected Observable<Social> resumeWithFallback() {
Map<String, Object> user = new HashMap<>();
user.put("userId", users.get(0).getId());
user.put("friends", Collections.emptyList());
return Observable.just(new Social(user));
}
private static int randomUser() {
return ((int) (Math.random() * 10000));
}
public static class Social {
private final Map<String, Object> data;
private Social(Map<String, Object> data) {
this.data = data;
}
public Map<String, Object> getDataAsMap() {
return data;
}
public static Social fromJson(String json) {
return new Social(SimpleJson.jsonToMap(json));
}
}
}
| 2,341 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/loadbalancer/DiscoveryAndLoadBalancer.java | package io.reactivex.lab.gateway.loadbalancer;
import com.netflix.eureka2.client.Eureka;
import com.netflix.eureka2.client.EurekaClient;
import com.netflix.eureka2.client.resolver.ServerResolver;
import com.netflix.eureka2.client.resolver.ServerResolvers;
import com.netflix.eureka2.interests.Interests;
import io.netty.buffer.ByteBuf;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.eureka.EurekaMembershipSource;
import netflix.ocelli.rxnetty.HttpClientPool;
import static io.reactivex.netty.pipeline.PipelineConfigurators.clientSseConfigurator;
/**
* Lifecycle of LoadBalancer for app and static accessor.
* <p>
* This class is currently a hack. Upgrade this later to use DI of some kind ... Dagger2?
*/
public class DiscoveryAndLoadBalancer {
public static final String EUREKA_SERVER_HOST = System.getProperty("reactivelab.eureka.server.host", "127.0.0.1");
public static final Integer EUREKA_SERVER_READ_PORT = Integer.getInteger("reactivelab.eureka.server.read.port", 7001);
public static final Integer EUREKA_SERVER_WRITE_PORT = Integer.getInteger("reactivelab.eureka.server.write.port", 7002);
public static LoadBalancerFactory getFactory() {
return Initializer.factory;
}
private static class Initializer {
private static LoadBalancerFactory _lb;
static {
ServerResolver.Server discoveryServer = new ServerResolver.Server(EUREKA_SERVER_HOST, EUREKA_SERVER_READ_PORT);
ServerResolver.Server registrationServer = new ServerResolver.Server(EUREKA_SERVER_HOST, EUREKA_SERVER_WRITE_PORT);
EurekaClient client = Eureka.newClientBuilder(ServerResolvers.from(discoveryServer),
ServerResolvers.from(registrationServer))
.build();
EurekaMembershipSource membershipSource = new EurekaMembershipSource(client);
_lb = new LoadBalancerFactory(membershipSource,
new HttpClientPool<ByteBuf, ServerSentEvent>(clientSseConfigurator()));
client.forInterest(Interests.forFullRegistry()).forEach(System.out::println);
System.out.println("------------ DONE");
/**
* This is making sure that eureka's client registry is warmed up.
*/
client.forInterest(Interests.forFullRegistry()).take(1).toBlocking().single();
}
static final LoadBalancerFactory factory = _lb;
}
}
| 2,342 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/loadbalancer/LoadBalancerFactory.java | package io.reactivex.lab.gateway.loadbalancer;
import com.netflix.eureka2.interests.Interests;
import com.netflix.eureka2.registry.NetworkAddress.ProtocolType;
import com.netflix.eureka2.registry.ServicePort;
import io.netty.buffer.ByteBuf;
import io.reactivex.netty.protocol.http.client.HttpClient;
import io.reactivex.netty.protocol.http.sse.ServerSentEvent;
import netflix.ocelli.Host;
import netflix.ocelli.LoadBalancer;
import netflix.ocelli.LoadBalancers;
import netflix.ocelli.MembershipEvent;
import netflix.ocelli.algorithm.LinearWeightingStrategy;
import netflix.ocelli.eureka.EurekaMembershipSource;
import netflix.ocelli.rxnetty.HttpClientHolder;
import netflix.ocelli.rxnetty.HttpClientPool;
import netflix.ocelli.rxnetty.RxNettyFailureDetector;
import netflix.ocelli.rxnetty.RxNettyPendingRequests;
import rx.Observable;
import java.util.HashSet;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* A utility to create {@link LoadBalancer} instances for different mid-tier services.
*
* @author Nitesh Kant
*/
public class LoadBalancerFactory {
private final EurekaMembershipSource membershipSource;
private final HttpClientPool<ByteBuf, ServerSentEvent> clientPool;
public LoadBalancerFactory(EurekaMembershipSource membershipSource,
HttpClientPool<ByteBuf, ServerSentEvent> clientPool) {
this.membershipSource = membershipSource;
this.clientPool = clientPool;
}
public LoadBalancer<HttpClientHolder<ByteBuf, ServerSentEvent>> forVip(String targetVip) {
Observable<MembershipEvent<Host>> eurekaHostSource = membershipSource.forInterest(Interests.forVips(targetVip), instanceInfo -> {
String ipAddress = instanceInfo.getDataCenterInfo()
.getAddresses().stream()
.filter(na -> na.getProtocolType() == ProtocolType.IPv4)
.collect(Collectors.toList()).get(0).getIpAddress();
HashSet<ServicePort> servicePorts = instanceInfo.getPorts();
ServicePort portToUse = servicePorts.iterator().next();
return new Host(ipAddress, portToUse.getPort());
});
final Map<Host, HttpClientHolder<ByteBuf, ServerSentEvent>> hostVsHolders = new ConcurrentHashMap<>();
String lbName = targetVip + "-lb";
return LoadBalancers.newBuilder(eurekaHostSource.map(
hostEvent -> {
HttpClient<ByteBuf, ServerSentEvent> client = clientPool.getClientForHost(hostEvent.getClient());
HttpClientHolder<ByteBuf, ServerSentEvent> holder;
if (hostEvent.getType() == MembershipEvent.EventType.REMOVE) {
holder = hostVsHolders.remove(hostEvent.getClient());
} else {
holder = new HttpClientHolder<>(client);
hostVsHolders.put(hostEvent.getClient(), holder);
}
return new MembershipEvent<>(hostEvent.getType(), holder);
})).withWeightingStrategy(new LinearWeightingStrategy<>(new RxNettyPendingRequests<>()))
.withName(lbName)
.withFailureDetector(new RxNettyFailureDetector<>()).build();
}
}
| 2,343 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/common/RxNettyResponseWriter.java | package io.reactivex.lab.gateway.common;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import java.io.IOException;
import java.io.Writer;
import java.nio.charset.Charset;
import rx.Observable;
import rx.subjects.ReplaySubject;
public class RxNettyResponseWriter extends Writer {
private final HttpServerResponse<ByteBuf> response;
private final ReplaySubject<Void> completionObservable = ReplaySubject.create();
public RxNettyResponseWriter(HttpServerResponse<ByteBuf> response) {
this.response = response;
}
@Override
public void write(char[] cbuf, int off, int len) throws IOException {
// assertions stole from StringWriter
if ((off < 0) || (off > cbuf.length) || (len < 0) ||
((off + len) > cbuf.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}
response.write(Unpooled.copiedBuffer(cbuf, off, len, Charset.defaultCharset()));
}
@Override
public void flush() throws IOException {
response.flush();
}
@Override
public void close() throws IOException {
try {
response.close();
completionObservable.onCompleted();
} catch (Throwable e) {
completionObservable.onError(e);
}
}
public Observable<Void> asObservable() {
return completionObservable;
}
}
| 2,344 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/common/SimpleJson.java | package io.reactivex.lab.gateway.common;
import java.io.IOException;
import java.util.Map;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectReader;
import org.codehaus.jackson.map.ObjectWriter;
public class SimpleJson {
private static final SimpleJson INSTANCE = new SimpleJson();
private SimpleJson() {
}
public static Map<String, Object> jsonToMap(String jsonString) {
return INSTANCE._jsonToMap(jsonString);
}
public static String mapToJson(Map<String, ? extends Object> map) {
return INSTANCE._mapToJson(map);
}
private final ObjectMapper objectMapper = new ObjectMapper();
private final ObjectReader objectReader = objectMapper.reader(Map.class);
private Map<String, Object> _jsonToMap(String jsonString) {
try {
return objectReader.readValue(jsonString);
} catch (IOException e) {
throw new RuntimeException("Unable to parse JSON", e);
}
}
private final ObjectWriter objectWriter = objectMapper.writerWithType(Map.class);
private String _mapToJson(Map<String, ? extends Object> map) {
try {
return objectWriter.writeValueAsString(map);
} catch (IOException e) {
throw new RuntimeException("Unable to write JSON", e);
}
}
}
| 2,345 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/hystrix/HystrixMetricsStreamHandler.java | package io.reactivex.lab.gateway.hystrix;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.UnpooledByteBufAllocator;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import io.reactivex.netty.protocol.http.server.RequestHandler;
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import rx.Observable;
import rx.Subscription;
import rx.functions.Action1;
import rx.schedulers.Schedulers;
import rx.subjects.PublishSubject;
import rx.subjects.Subject;
import rx.subscriptions.MultipleAssignmentSubscription;
import com.netflix.hystrix.HystrixCommandMetrics;
import com.netflix.hystrix.HystrixThreadPoolMetrics;
/**
* Streams Hystrix metrics in Server Sent Event (SSE) format. RxNetty application handlers shall
* be wrapped by this handler. It transparently intercepts HTTP requests at a configurable path
* (default "/hystrix.stream"), and sends unbounded SSE streams back to the client. All other requests
* are transparently forwarded to the application handlers.
* <p/>
* For RxNetty client tapping into SSE stream: remember to use unpooled HTTP connections. If not, the pooled HTTP
* connection will not be closed on unsubscribe event and the event stream will continue to flow towards the client
* (unless the client is shutdown).
*/
public class HystrixMetricsStreamHandler<I, O> implements RequestHandler<I, O> {
public static final String DEFAULT_HYSTRIX_PREFIX = "/hystrix.stream";
public static final int DEFAULT_INTERVAL = 2000;
private static final byte[] HEADER = "data: ".getBytes(Charset.defaultCharset());
private static final byte[] FOOTER = { 10, 10 };
private static final int EXTRA_SPACE = HEADER.length + FOOTER.length;
private final String hystrixPrefix;
private final long interval;
private final RequestHandler<I, O> appHandler;
public HystrixMetricsStreamHandler(RequestHandler<I, O> appHandler) {
this(DEFAULT_HYSTRIX_PREFIX, DEFAULT_INTERVAL, appHandler);
}
public HystrixMetricsStreamHandler(String hystrixPrefix, long intervalInMillis) {
this.hystrixPrefix = hystrixPrefix;
this.interval = intervalInMillis;
this.appHandler = (HttpServerRequest<I> request, HttpServerResponse<O> response) -> {
return response.writeStringAndFlush("Only supported path is /" + hystrixPrefix);
};
}
public HystrixMetricsStreamHandler(String hystrixPrefix, long interval, RequestHandler<I, O> appHandler) {
this.hystrixPrefix = hystrixPrefix;
this.interval = interval;
this.appHandler = appHandler;
}
@Override
public Observable<Void> handle(HttpServerRequest<I> request, HttpServerResponse<O> response) {
if (request.getPath().startsWith(hystrixPrefix)) {
return handleHystrixRequest(response);
}
return appHandler.handle(request, response);
}
private Observable<Void> handleHystrixRequest(final HttpServerResponse<O> response) {
writeHeaders(response);
final Subject<Void, Void> subject = PublishSubject.create();
final MultipleAssignmentSubscription subscription = new MultipleAssignmentSubscription();
Subscription actionSubscription = Observable.timer(0, interval, TimeUnit.MILLISECONDS, Schedulers.computation())
.subscribe(new Action1<Long>() {
@Override
public void call(Long tick) {
if (!response.getChannel().isOpen()) {
subscription.unsubscribe();
return;
}
try {
for (HystrixCommandMetrics commandMetrics : HystrixCommandMetrics.getInstances()) {
writeMetric(JsonMapper.toJson(commandMetrics), response);
}
for (HystrixThreadPoolMetrics threadPoolMetrics : HystrixThreadPoolMetrics.getInstances()) {
writeMetric(JsonMapper.toJson(threadPoolMetrics), response);
}
} catch (Exception e) {
subject.onError(e);
}
}
});
subscription.set(actionSubscription);
return subject;
}
private void writeHeaders(HttpServerResponse<O> response) {
response.getHeaders().add("Content-Type", "text/event-stream;charset=UTF-8");
response.getHeaders().add("Cache-Control", "no-cache, no-store, max-age=0, must-revalidate");
response.getHeaders().add("Pragma", "no-cache");
}
@SuppressWarnings("unchecked")
private void writeMetric(String json, HttpServerResponse<O> response) {
byte[] bytes = json.getBytes(Charset.defaultCharset());
ByteBuf byteBuf = UnpooledByteBufAllocator.DEFAULT.buffer(bytes.length + EXTRA_SPACE);
byteBuf.writeBytes(HEADER);
byteBuf.writeBytes(bytes);
byteBuf.writeBytes(FOOTER);
response.writeAndFlush((O) byteBuf);
}
} | 2,346 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/hystrix/JsonMapper.java | package io.reactivex.lab.gateway.hystrix;
import java.io.IOException;
import java.io.StringWriter;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerator;
import com.netflix.hystrix.HystrixCircuitBreaker;
import com.netflix.hystrix.HystrixCommandKey;
import com.netflix.hystrix.HystrixCommandMetrics;
import com.netflix.hystrix.HystrixCommandMetrics.HealthCounts;
import com.netflix.hystrix.HystrixCommandProperties;
import com.netflix.hystrix.HystrixThreadPoolKey;
import com.netflix.hystrix.HystrixThreadPoolMetrics;
import com.netflix.hystrix.util.HystrixRollingNumberEvent;
/**
* This code is taken from hystrix-metrics-event-stream module's HystrixMetricsPoller class.
*/
public final class JsonMapper {
private static final JsonFactory jsonFactory = new JsonFactory();
private JsonMapper() {
}
static String toJson(HystrixCommandMetrics commandMetrics) throws IOException {
HystrixCommandKey key = commandMetrics.getCommandKey();
HystrixCircuitBreaker circuitBreaker = HystrixCircuitBreaker.Factory.getInstance(key);
StringWriter jsonString = new StringWriter();
JsonGenerator json = jsonFactory.createJsonGenerator(jsonString);
json.writeStartObject();
json.writeStringField("type", "HystrixCommand");
json.writeStringField("name", key.name());
json.writeStringField("group", commandMetrics.getCommandGroup().name());
json.writeNumberField("currentTime", System.currentTimeMillis());
// circuit breaker
if (circuitBreaker == null) {
// circuit breaker is disabled and thus never open
json.writeBooleanField("isCircuitBreakerOpen", false);
} else {
json.writeBooleanField("isCircuitBreakerOpen", circuitBreaker.isOpen());
}
HealthCounts healthCounts = commandMetrics.getHealthCounts();
json.writeNumberField("errorPercentage", healthCounts.getErrorPercentage());
json.writeNumberField("errorCount", healthCounts.getErrorCount());
json.writeNumberField("requestCount", healthCounts.getTotalRequests());
// rolling counters
json.writeNumberField("rollingCountCollapsedRequests", commandMetrics.getRollingCount(HystrixRollingNumberEvent.COLLAPSED));
json.writeNumberField("rollingCountExceptionsThrown", commandMetrics.getRollingCount(HystrixRollingNumberEvent.EXCEPTION_THROWN));
json.writeNumberField("rollingCountFailure", commandMetrics.getRollingCount(HystrixRollingNumberEvent.FAILURE));
json.writeNumberField("rollingCountFallbackFailure", commandMetrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_FAILURE));
json.writeNumberField("rollingCountFallbackRejection", commandMetrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_REJECTION));
json.writeNumberField("rollingCountFallbackSuccess", commandMetrics.getRollingCount(HystrixRollingNumberEvent.FALLBACK_SUCCESS));
json.writeNumberField("rollingCountResponsesFromCache", commandMetrics.getRollingCount(HystrixRollingNumberEvent.RESPONSE_FROM_CACHE));
json.writeNumberField("rollingCountSemaphoreRejected", commandMetrics.getRollingCount(HystrixRollingNumberEvent.SEMAPHORE_REJECTED));
json.writeNumberField("rollingCountShortCircuited", commandMetrics.getRollingCount(HystrixRollingNumberEvent.SHORT_CIRCUITED));
json.writeNumberField("rollingCountSuccess", commandMetrics.getRollingCount(HystrixRollingNumberEvent.SUCCESS));
json.writeNumberField("rollingCountThreadPoolRejected", commandMetrics.getRollingCount(HystrixRollingNumberEvent.THREAD_POOL_REJECTED));
json.writeNumberField("rollingCountTimeout", commandMetrics.getRollingCount(HystrixRollingNumberEvent.TIMEOUT));
json.writeNumberField("currentConcurrentExecutionCount", commandMetrics.getCurrentConcurrentExecutionCount());
// latency percentiles
json.writeNumberField("latencyExecute_mean", commandMetrics.getExecutionTimeMean());
json.writeObjectFieldStart("latencyExecute");
json.writeNumberField("0", commandMetrics.getExecutionTimePercentile(0));
json.writeNumberField("25", commandMetrics.getExecutionTimePercentile(25));
json.writeNumberField("50", commandMetrics.getExecutionTimePercentile(50));
json.writeNumberField("75", commandMetrics.getExecutionTimePercentile(75));
json.writeNumberField("90", commandMetrics.getExecutionTimePercentile(90));
json.writeNumberField("95", commandMetrics.getExecutionTimePercentile(95));
json.writeNumberField("99", commandMetrics.getExecutionTimePercentile(99));
json.writeNumberField("99.5", commandMetrics.getExecutionTimePercentile(99.5));
json.writeNumberField("100", commandMetrics.getExecutionTimePercentile(100));
json.writeEndObject();
//
json.writeNumberField("latencyTotal_mean", commandMetrics.getTotalTimeMean());
json.writeObjectFieldStart("latencyTotal");
json.writeNumberField("0", commandMetrics.getTotalTimePercentile(0));
json.writeNumberField("25", commandMetrics.getTotalTimePercentile(25));
json.writeNumberField("50", commandMetrics.getTotalTimePercentile(50));
json.writeNumberField("75", commandMetrics.getTotalTimePercentile(75));
json.writeNumberField("90", commandMetrics.getTotalTimePercentile(90));
json.writeNumberField("95", commandMetrics.getTotalTimePercentile(95));
json.writeNumberField("99", commandMetrics.getTotalTimePercentile(99));
json.writeNumberField("99.5", commandMetrics.getTotalTimePercentile(99.5));
json.writeNumberField("100", commandMetrics.getTotalTimePercentile(100));
json.writeEndObject();
// property values for reporting what is actually seen by the command rather than what was set somewhere
HystrixCommandProperties commandProperties = commandMetrics.getProperties();
json.writeNumberField("propertyValue_circuitBreakerRequestVolumeThreshold", commandProperties.circuitBreakerRequestVolumeThreshold().get());
json.writeNumberField("propertyValue_circuitBreakerSleepWindowInMilliseconds", commandProperties.circuitBreakerSleepWindowInMilliseconds().get());
json.writeNumberField("propertyValue_circuitBreakerErrorThresholdPercentage", commandProperties.circuitBreakerErrorThresholdPercentage().get());
json.writeBooleanField("propertyValue_circuitBreakerForceOpen", commandProperties.circuitBreakerForceOpen().get());
json.writeBooleanField("propertyValue_circuitBreakerForceClosed", commandProperties.circuitBreakerForceClosed().get());
json.writeBooleanField("propertyValue_circuitBreakerEnabled", commandProperties.circuitBreakerEnabled().get());
json.writeStringField("propertyValue_executionIsolationStrategy", commandProperties.executionIsolationStrategy().get().name());
json.writeNumberField("propertyValue_executionTimeoutInMilliseconds", commandProperties.executionTimeoutInMilliseconds().get());
json.writeBooleanField("propertyValue_executionIsolationThreadInterruptOnTimeout", commandProperties.executionIsolationThreadInterruptOnTimeout().get());
json.writeStringField("propertyValue_executionIsolationThreadPoolKeyOverride", commandProperties.executionIsolationThreadPoolKeyOverride().get());
json.writeNumberField("propertyValue_executionIsolationSemaphoreMaxConcurrentRequests", commandProperties.executionIsolationSemaphoreMaxConcurrentRequests().get());
json.writeNumberField("propertyValue_fallbackIsolationSemaphoreMaxConcurrentRequests", commandProperties.fallbackIsolationSemaphoreMaxConcurrentRequests().get());
/*
* The following are commented out as these rarely change and are verbose for streaming for something people don't change.
* We could perhaps allow a property or request argument to include these.
*/
// json.put("propertyValue_metricsRollingPercentileEnabled", commandProperties.metricsRollingPercentileEnabled().get());
// json.put("propertyValue_metricsRollingPercentileBucketSize", commandProperties.metricsRollingPercentileBucketSize().get());
// json.put("propertyValue_metricsRollingPercentileWindow", commandProperties.metricsRollingPercentileWindowInMilliseconds().get());
// json.put("propertyValue_metricsRollingPercentileWindowBuckets", commandProperties.metricsRollingPercentileWindowBuckets().get());
// json.put("propertyValue_metricsRollingStatisticalWindowBuckets", commandProperties.metricsRollingStatisticalWindowBuckets().get());
json.writeNumberField("propertyValue_metricsRollingStatisticalWindowInMilliseconds", commandProperties.metricsRollingStatisticalWindowInMilliseconds().get());
json.writeBooleanField("propertyValue_requestCacheEnabled", commandProperties.requestCacheEnabled().get());
json.writeBooleanField("propertyValue_requestLogEnabled", commandProperties.requestLogEnabled().get());
json.writeNumberField("reportingHosts", 1); // this will get summed across all instances in a cluster
json.writeEndObject();
json.close();
return jsonString.getBuffer().toString();
}
static String toJson(HystrixThreadPoolMetrics threadPoolMetrics) throws IOException {
HystrixThreadPoolKey key = threadPoolMetrics.getThreadPoolKey();
StringWriter jsonString = new StringWriter();
JsonGenerator json = jsonFactory.createJsonGenerator(jsonString);
json.writeStartObject();
json.writeStringField("type", "HystrixThreadPool");
json.writeStringField("name", key.name());
json.writeNumberField("currentTime", System.currentTimeMillis());
json.writeNumberField("currentActiveCount", threadPoolMetrics.getCurrentActiveCount().intValue());
json.writeNumberField("currentCompletedTaskCount", threadPoolMetrics.getCurrentCompletedTaskCount().longValue());
json.writeNumberField("currentCorePoolSize", threadPoolMetrics.getCurrentCorePoolSize().intValue());
json.writeNumberField("currentLargestPoolSize", threadPoolMetrics.getCurrentLargestPoolSize().intValue());
json.writeNumberField("currentMaximumPoolSize", threadPoolMetrics.getCurrentMaximumPoolSize().intValue());
json.writeNumberField("currentPoolSize", threadPoolMetrics.getCurrentPoolSize().intValue());
json.writeNumberField("currentQueueSize", threadPoolMetrics.getCurrentQueueSize().intValue());
json.writeNumberField("currentTaskCount", threadPoolMetrics.getCurrentTaskCount().longValue());
json.writeNumberField("rollingCountThreadsExecuted", threadPoolMetrics.getRollingCountThreadsExecuted());
json.writeNumberField("rollingMaxActiveThreads", threadPoolMetrics.getRollingMaxActiveThreads());
json.writeNumberField("propertyValue_queueSizeRejectionThreshold", threadPoolMetrics.getProperties().queueSizeRejectionThreshold().get());
json.writeNumberField("propertyValue_metricsRollingStatisticalWindowInMilliseconds", threadPoolMetrics.getProperties().metricsRollingStatisticalWindowInMilliseconds().get());
json.writeNumberField("reportingHosts", 1); // this will get summed across all instances in a cluster
json.writeEndObject();
json.close();
return jsonString.getBuffer().toString();
}
} | 2,347 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes/RouteForDeviceHome.java | package io.reactivex.lab.gateway.routes;
import io.netty.buffer.ByteBuf;
import io.reactivex.lab.gateway.StartGatewayServer;
import io.reactivex.lab.gateway.clients.BookmarkCommand;
import io.reactivex.lab.gateway.clients.BookmarksCommand.Bookmark;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand;
import io.reactivex.lab.gateway.clients.PersonalizedCatalogCommand.Video;
import io.reactivex.lab.gateway.clients.RatingsCommand;
import io.reactivex.lab.gateway.clients.RatingsCommand.Rating;
import io.reactivex.lab.gateway.clients.SocialCommand;
import io.reactivex.lab.gateway.clients.UserCommand;
import io.reactivex.lab.gateway.clients.VideoMetadataCommand;
import io.reactivex.lab.gateway.clients.VideoMetadataCommand.VideoMetadata;
import io.reactivex.lab.gateway.common.SimpleJson;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import rx.Observable;
public class RouteForDeviceHome {
public Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
List<String> userId = request.getQueryParameters().get("userId");
if (userId == null || userId.size() != 1) {
return StartGatewayServer.writeError(request, response, "A single 'userId' is required.");
}
return new UserCommand(userId).observe().flatMap(user -> {
Observable<Map<String, Object>> catalog = new PersonalizedCatalogCommand(user).observe()
.flatMap(catalogList -> catalogList.videos().<Map<String, Object>> flatMap(
video -> {
Observable<Bookmark> bookmark = new BookmarkCommand(video).observe();
Observable<Rating> rating = new RatingsCommand(video).observe();
Observable<VideoMetadata> metadata = new VideoMetadataCommand(video).observe();
return Observable.zip(bookmark, rating, metadata, (b, r, m) -> combineVideoData(video, b, r, m));
}));
Observable<Map<String, Object>> social = new SocialCommand(user).observe().map(s -> {
return s.getDataAsMap();
});
return Observable.merge(catalog, social);
}).flatMap(data -> {
String json = SimpleJson.mapToJson(data);
return response.writeStringAndFlush("data: " + json + "\n");
});
}
private Map<String, Object> combineVideoData(Video video, Bookmark b, Rating r, VideoMetadata m) {
Map<String, Object> video_data = new HashMap<>();
video_data.put("video_id", video.getId());
video_data.put("bookmark", b.getPosition());
video_data.put("estimated_user_rating", r.getEstimatedUserRating());
video_data.put("metadata", m.getDataAsMap());
return video_data;
}
}
| 2,348 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes/mock/TestRouteWithHystrix.java | package io.reactivex.lab.gateway.routes.mock;
import io.netty.buffer.ByteBuf;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.lab.gateway.clients.MockServiceCommand;
import io.reactivex.lab.gateway.common.RxNettyResponseWriter;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import java.util.Arrays;
import java.util.List;
import rx.Observable;
public class TestRouteWithHystrix {
public static Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
List<String> _id = request.getQueryParameters().get("id");
if (_id == null || _id.size() != 1) {
return writeError(request, response, "Please provide a numerical 'id' value. It can be a random number (uuid).");
}
long id = Long.parseLong(String.valueOf(_id.get(0)));
// set response header
response.getHeaders().addHeader("content-type", "application/json");
Observable<List<BackendResponse>> acd = new MockServiceCommand(id, 2, 50, 50).observe()
// Eclipse 20140224-0627 can't infer without this type hint even though the Java 8 compiler can
.<List<BackendResponse>> flatMap(responseA -> {
Observable<BackendResponse> responseC = new MockServiceCommand(responseA.getResponseKey(), 1, 5000, 80).observe();
Observable<BackendResponse> responseD = new MockServiceCommand(responseA.getResponseKey(), 1, 1000, 1).observe();
return Observable.zip(Observable.just(responseA), responseC, responseD, (a, c, d) -> Arrays.asList(a, c, d));
});
Observable<List<BackendResponse>> be = new MockServiceCommand(id, 25, 30, 15).observe()
// Eclipse 20140224-0627 can't infer without this type hint even though the Java 8 compiler can
.<List<BackendResponse>> flatMap(responseB -> {
Observable<BackendResponse> responseE = new MockServiceCommand(responseB.getResponseKey(), 100, 30, 4).observe();
return Observable.zip(Observable.just(responseB), responseE, (b, e) -> Arrays.asList(b, e));
});
return Observable.zip(acd, be, (_acd, _be) -> {
BackendResponse responseA = _acd.get(0);
BackendResponse responseB = _be.get(0);
BackendResponse responseC = _acd.get(1);
BackendResponse responseD = _acd.get(2);
BackendResponse responseE = _be.get(1);
/**
* The RxNettyResponseWriter bridges synchronous Jackson JSON writing
* with asynchronous Netty writing.
*/
RxNettyResponseWriter writer = new RxNettyResponseWriter(response);
ResponseBuilder.writeTestResponse(writer, responseA, responseB, responseC, responseD, responseE);
return writer;
}).flatMap(w -> w.asObservable());
}
private static Observable<Void> writeError(HttpServerRequest<?> request, HttpServerResponse<?> response, String message) {
System.err.println("Server => Error [" + request.getPath() + "] => " + message);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("Error 500: " + message + "\n");
}
}
| 2,349 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes/mock/ResponseBuilder.java | package io.reactivex.lab.gateway.routes.mock;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Writer;
import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
import java.util.HashMap;
import java.util.Map;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import rx.functions.Action0;
/**
* Build the edge response from the middle-tier responses.
*/
public class ResponseBuilder {
private final static JsonFactory jsonFactory = new JsonFactory();
public static void writeTestResponse(Writer writer, BackendResponse responseA, BackendResponse responseB,
BackendResponse responseC, BackendResponse responseD, BackendResponse responseE) {
writeTestResponse(writer, responseA, responseB, responseC, responseD, responseE, null);
}
public static void writeTestResponse(Writer writer, BackendResponse responseA, BackendResponse responseB,
BackendResponse responseC, BackendResponse responseD, BackendResponse responseE, Action0 onComplete) {
try {
JsonGenerator jsonGenerator = jsonFactory.createJsonGenerator(writer);
generateResponse(responseA, responseB, responseC, responseD, responseE, jsonGenerator);
if (onComplete != null) {
onComplete.call();
}
jsonGenerator.close();
} catch (Exception e) {
throw new RuntimeException("failed to generated response", e);
}
}
public static ByteArrayOutputStream buildTestResponse(BackendResponse responseA, BackendResponse responseB,
BackendResponse responseC, BackendResponse responseD, BackendResponse responseE) {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
JsonGenerator jsonGenerator = jsonFactory.createJsonGenerator(bos);
generateResponse(responseA, responseB, responseC, responseD, responseE, jsonGenerator);
jsonGenerator.close();
return bos;
} catch (Exception e) {
throw new RuntimeException("failed to generated response", e);
}
}
private static void generateResponse(BackendResponse responseA, BackendResponse responseB, BackendResponse responseC, BackendResponse responseD, BackendResponse responseE, JsonGenerator jsonGenerator) throws IOException, JsonGenerationException {
jsonGenerator.writeStartObject();
// multiplication of C, D, E responseKey
jsonGenerator.writeNumberField("responseKey", responseC.getResponseKey() + responseD.getResponseKey() +
responseE.getResponseKey());
// delay values of each response
jsonGenerator.writeArrayFieldStart("delay");
writeTuple(jsonGenerator, "a", responseA.getDelay());
writeTuple(jsonGenerator, "b", responseB.getDelay());
writeTuple(jsonGenerator, "c", responseC.getDelay());
writeTuple(jsonGenerator, "d", responseD.getDelay());
writeTuple(jsonGenerator, "e", responseE.getDelay());
jsonGenerator.writeEndArray();
// itemSize values of each response
jsonGenerator.writeArrayFieldStart("itemSize");
writeTuple(jsonGenerator, "a", responseA.getItemSize());
writeTuple(jsonGenerator, "b", responseB.getItemSize());
writeTuple(jsonGenerator, "c", responseC.getItemSize());
writeTuple(jsonGenerator, "d", responseD.getItemSize());
writeTuple(jsonGenerator, "e", responseE.getItemSize());
jsonGenerator.writeEndArray();
// numItems values of each response
jsonGenerator.writeArrayFieldStart("numItems");
writeTuple(jsonGenerator, "a", responseA.getNumItems());
writeTuple(jsonGenerator, "b", responseB.getNumItems());
writeTuple(jsonGenerator, "c", responseC.getNumItems());
writeTuple(jsonGenerator, "d", responseD.getNumItems());
writeTuple(jsonGenerator, "e", responseE.getNumItems());
jsonGenerator.writeEndArray();
// all items from responses
jsonGenerator.writeArrayFieldStart("items");
addItemsFromResponse(jsonGenerator, responseA);
addItemsFromResponse(jsonGenerator, responseB);
addItemsFromResponse(jsonGenerator, responseC);
addItemsFromResponse(jsonGenerator, responseD);
addItemsFromResponse(jsonGenerator, responseE);
jsonGenerator.writeEndArray();
jsonGenerator.writeEndObject();
}
private static void addItemsFromResponse(JsonGenerator jsonGenerator, BackendResponse a) throws IOException {
for (String s : a.getItems()) {
jsonGenerator.writeString(s);
}
}
private static void writeTuple(JsonGenerator jsonGenerator, String name, int value) throws IOException {
jsonGenerator.writeStartObject();
jsonGenerator.writeNumberField(name, value);
jsonGenerator.writeEndObject();
}
/**
* Add various headers used for logging and statistics.
*/
public static void addResponseHeaders(HttpServerResponse<?> response, long startTime) {
System.out.println("response headers");
Map<String, String> perfResponseHeaders = getPerfResponseHeaders(startTime);
for (Map.Entry<String, String> entry : perfResponseHeaders.entrySet()) {
response.getHeaders().add(entry.getKey(), entry.getValue());
}
}
private static final OperatingSystemMXBean osStats = ManagementFactory.getOperatingSystemMXBean();
/**
* Include performance information as headers.
*
* @param startTime
* @return
*/
public static Map<String, String> getPerfResponseHeaders(long startTime) {
Map<String, String> toReturn = new HashMap<String, String>();
toReturn.put("server_response_time", String.valueOf((System.currentTimeMillis() - startTime)));
toReturn.put("os_arch", osStats.getArch());
toReturn.put("os_name", osStats.getName());
toReturn.put("os_version", osStats.getVersion());
toReturn.put("jvm_version", System.getProperty("java.runtime.version"));
// per core load average
int cores = Runtime.getRuntime().availableProcessors();
double loadAverage = osStats.getSystemLoadAverage();
double loadAveragePerCore = loadAverage / cores;
String l = String.valueOf(loadAveragePerCore);
if (l.length() > 4) {
l = l.substring(0, 4);
}
toReturn.put("load_avg_per_core", l);
return toReturn;
}
} | 2,350 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes/mock/BackendResponse.java | package io.reactivex.lab.gateway.routes.mock;
import java.io.IOException;
import java.io.InputStream;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonToken;
import rx.Observable;
import rx.Scheduler;
import rx.Subscriber;
import rx.schedulers.Schedulers;
public class BackendResponse {
private final static JsonFactory jsonFactory = new JsonFactory();
private final long responseKey;
private final int delay;
private final int numItems;
private final int itemSize;
private final String[] items;
public BackendResponse(long responseKey, int delay, int numItems, int itemSize, String[] items) {
this.responseKey = responseKey;
this.delay = delay;
this.numItems = numItems;
this.itemSize = itemSize;
this.items = items;
}
public static BackendResponse fromJson(InputStream inputStream) {
try {
JsonParser parser = jsonFactory.createJsonParser(inputStream);
return parseBackendResponse(parser);
} catch (Exception e) {
throw new RuntimeException("Failed to parse JSON", e);
}
}
public static BackendResponse fromJson(String json) {
try {
JsonParser parser = jsonFactory.createJsonParser(json);
return parseBackendResponse(parser);
} catch (Exception e) {
throw new RuntimeException("Failed to parse JSON", e);
}
}
public static Observable<BackendResponse> fromJsonToObservable(InputStream inputStream) {
return fromJsonToObservable(inputStream, Schedulers.computation());
}
public static Observable<BackendResponse> fromJsonToObservable(final InputStream inputStream, Scheduler scheduler) {
return Observable.create((Subscriber<? super BackendResponse> o) -> {
try {
o.onNext(fromJson(inputStream));
o.onCompleted();
} catch (Exception e) {
o.onError(e);
}
}).subscribeOn(scheduler);
}
private static BackendResponse parseBackendResponse(JsonParser parser) throws IOException {
try {
// Sanity check: verify that we got "Json Object":
if (parser.nextToken() != JsonToken.START_OBJECT) {
throw new IOException("Expected data to start with an Object");
}
long responseKey = 0;
int delay = 0;
int numItems = 0;
int itemSize = 0;
String[] items = null;
JsonToken current;
while (parser.nextToken() != JsonToken.END_OBJECT) {
String fieldName = parser.getCurrentName();
// advance
current = parser.nextToken();
if (fieldName.equals("responseKey")) {
responseKey = parser.getLongValue();
} else if (fieldName.equals("delay")) {
delay = parser.getIntValue();
} else if (fieldName.equals("itemSize")) {
itemSize = parser.getIntValue();
} else if (fieldName.equals("numItems")) {
numItems = parser.getIntValue();
} else if (fieldName.equals("items")) {
// expect numItems to be populated before hitting this
if (numItems == 0) {
throw new IllegalStateException("Expected numItems > 0");
}
items = new String[numItems];
if (current == JsonToken.START_ARRAY) {
int j = 0;
// For each of the records in the array
while (parser.nextToken() != JsonToken.END_ARRAY) {
items[j++] = parser.getText();
}
} else {
// System.out.println("Error: items should be an array: skipping.");
parser.skipChildren();
}
}
}
return new BackendResponse(responseKey, delay, numItems, itemSize, items);
} finally {
parser.close();
}
}
public long getResponseKey() {
return responseKey;
}
public int getDelay() {
return delay;
}
public int getNumItems() {
return numItems;
}
public int getItemSize() {
return itemSize;
}
public String[] getItems() {
return items;
}
} | 2,351 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes/mock/TestRouteWithSimpleFaultTolerance.java | package io.reactivex.lab.gateway.routes.mock;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.lab.gateway.common.RxNettyResponseWriter;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.client.HttpClientResponse;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
import rx.Observable;
/**
* Accept request to /test and return a response that composes multiple backend services like this:
*
* A) GET http://hostname:9999/mock.json?numItems=2&itemSize=50&delay=50&id={uuid}
* B) GET http://hostname:9999/mock.json?numItems=25&itemSize=30&delay=150&id={uuid}
* C) GET http://hostname:9999/mock.json?numItems=1&itemSize=5000&delay=80&id={a.responseKey}
* D) GET http://hostname:9999/mock.json?numItems=1&itemSize=1000&delay=1&id={a.responseKey}
* E) GET http://hostname:9999/mock.json?numItems=100&itemSize=30&delay=4&id={b.responseKey}
*/
public class TestRouteWithSimpleFaultTolerance {
public static Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
List<String> _id = request.getQueryParameters().get("id");
if (_id == null || _id.size() != 1) {
return writeError(request, response, "Please provide a numerical 'id' value. It can be a random number (uuid).");
}
long id = Long.parseLong(String.valueOf(_id.get(0)));
// set response header
response.getHeaders().addHeader("content-type", "application/json");
Observable<List<BackendResponse>> acd = getDataFromBackend("/mock.json?numItems=2&itemSize=50&delay=50&id=" + id)
// Eclipse 20140224-0627 can't infer without this type hint even though the Java 8 compiler can
.<List<BackendResponse>> flatMap(responseA -> {
Observable<BackendResponse> responseC = getDataFromBackend("/mock.json?numItems=1&itemSize=5000&delay=80&id=" + responseA.getResponseKey());
Observable<BackendResponse> responseD = getDataFromBackend("/mock.json?numItems=1&itemSize=1000&delay=1&id=" + responseA.getResponseKey());
return Observable.zip(Observable.just(responseA), responseC, responseD, (a, c, d) -> Arrays.asList(a, c, d));
});
Observable<List<BackendResponse>> be = getDataFromBackend("/mock.json?numItems=25&itemSize=30&delay=150&id=" + id)
// Eclipse 20140224-0627 can't infer without this type hint even though the Java 8 compiler can
.<List<BackendResponse>> flatMap(responseB -> {
Observable<BackendResponse> responseE = getDataFromBackend("/mock.json?numItems=100&itemSize=30&delay=4&id=" + responseB.getResponseKey());
return Observable.zip(Observable.just(responseB), responseE, (b, e) -> Arrays.asList(b, e));
});
return Observable.zip(acd, be, (_acd, _be) -> {
BackendResponse responseA = _acd.get(0);
BackendResponse responseB = _be.get(0);
BackendResponse responseC = _acd.get(1);
BackendResponse responseD = _acd.get(2);
BackendResponse responseE = _be.get(1);
/**
* The RxNettyResponseWriter bridges synchronous Jackson JSON writing
* with asynchronous Netty writing.
*/
RxNettyResponseWriter writer = new RxNettyResponseWriter(response);
ResponseBuilder.writeTestResponse(writer, responseA, responseB, responseC, responseD, responseE);
return writer;
}).flatMap(w -> w.asObservable());
}
private static Observable<BackendResponse> getDataFromBackend(String url) {
return RxNetty.createHttpClient("localhost", 9999)
.submit(HttpClientRequest.createGet(url))
.timeout(50, TimeUnit.MILLISECONDS) // change the timeout value to see how response differs
.flatMap((HttpClientResponse<ByteBuf> r) -> {
Observable<BackendResponse> bytesToJson = r.getContent().map(b -> {
return BackendResponse.fromJson(new ByteBufInputStream(b));
});
return bytesToJson;
}).onErrorResumeNext(t -> {
BackendResponse fallback = new BackendResponse(0, -1, -1, -1, new String[] {});
return Observable.just(fallback);
});
}
private static Observable<Void> writeError(HttpServerRequest<?> request, HttpServerResponse<?> response, String message) {
System.err.println("Server => Error [" + request.getPath() + "] => " + message);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("Error 500: " + message + "\n");
}
}
| 2,352 |
0 | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes | Create_ds/ReactiveLab/reactive-lab-gateway/src/main/java/io/reactivex/lab/gateway/routes/mock/TestRouteBasic.java | package io.reactivex.lab.gateway.routes.mock;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.lab.gateway.common.RxNettyResponseWriter;
import io.reactivex.netty.RxNetty;
import io.reactivex.netty.protocol.http.client.HttpClientRequest;
import io.reactivex.netty.protocol.http.client.HttpClientResponse;
import io.reactivex.netty.protocol.http.server.HttpServerRequest;
import io.reactivex.netty.protocol.http.server.HttpServerResponse;
import java.util.Arrays;
import java.util.List;
import rx.Observable;
/**
* Handle request and return a response that composes multiple backend services like this:
*
* A) GET http://hostname:9100/mock.json?numItems=2&itemSize=50&delay=50&id={uuid}
* B) GET http://hostname:9100/mock.json?numItems=25&itemSize=30&delay=150&id={uuid}
* C) GET http://hostname:9100/mock.json?numItems=1&itemSize=5000&delay=80&id={a.responseKey}
* D) GET http://hostname:9100/mock.json?numItems=1&itemSize=1000&delay=1&id={a.responseKey}
* E) GET http://hostname:9100/mock.json?numItems=100&itemSize=30&delay=4&id={b.responseKey}
*/
public class TestRouteBasic {
public static Observable<Void> handle(HttpServerRequest<ByteBuf> request, HttpServerResponse<ByteBuf> response) {
List<String> _id = request.getQueryParameters().get("id");
if (_id == null || _id.size() != 1) {
return writeError(request, response, "Please provide a numerical 'id' value. It can be a random number (uuid).");
}
long id = Long.parseLong(String.valueOf(_id.get(0)));
// set response header
response.getHeaders().addHeader("content-type", "application/json");
Observable<List<BackendResponse>> acd = getDataFromBackend("/mock.json?numItems=2&itemSize=50&delay=50&id=" + id)
// Eclipse 20140224-0627 can't infer without this type hint even though the Java 8 compiler can
.<List<BackendResponse>> flatMap(responseA -> {
Observable<BackendResponse> responseC = getDataFromBackend("/mock.json?numItems=1&itemSize=5000&delay=80&id=" + responseA.getResponseKey());
Observable<BackendResponse> responseD = getDataFromBackend("/mock.json?numItems=1&itemSize=1000&delay=1&id=" + responseA.getResponseKey());
return Observable.zip(Observable.just(responseA), responseC, responseD, (a, c, d) -> Arrays.asList(a, c, d));
});
Observable<List<BackendResponse>> be = getDataFromBackend("/mock.json?numItems=25&itemSize=30&delay=150&id=" + id)
// Eclipse 20140224-0627 can't infer without this type hint even though the Java 8 compiler can
.<List<BackendResponse>> flatMap(responseB -> {
Observable<BackendResponse> responseE = getDataFromBackend("/mock.json?numItems=100&itemSize=30&delay=4&id=" + responseB.getResponseKey());
return Observable.zip(Observable.just(responseB), responseE, (b, e) -> Arrays.asList(b, e));
});
return Observable.zip(acd, be, (_acd, _be) -> {
BackendResponse responseA = _acd.get(0);
BackendResponse responseB = _be.get(0);
BackendResponse responseC = _acd.get(1);
BackendResponse responseD = _acd.get(2);
BackendResponse responseE = _be.get(1);
/**
* The RxNettyResponseWriter bridges synchronous Jackson JSON writing
* with asynchronous Netty writing.
*/
RxNettyResponseWriter writer = new RxNettyResponseWriter(response);
ResponseBuilder.writeTestResponse(writer, responseA, responseB, responseC, responseD, responseE);
return writer;
}).flatMap(w -> w.asObservable());
}
private static Observable<BackendResponse> getDataFromBackend(String url) {
return RxNetty.createHttpClient("localhost", 9100)
.submit(HttpClientRequest.createGet(url))
.flatMap((HttpClientResponse<ByteBuf> r) -> {
Observable<BackendResponse> bytesToJson = r.getContent().map(b -> {
return BackendResponse.fromJson(new ByteBufInputStream(b));
});
return bytesToJson;
});
}
private static Observable<Void> writeError(HttpServerRequest<?> request, HttpServerResponse<?> response, String message) {
System.err.println("Server => Error [" + request.getPath() + "] => " + message);
response.setStatus(HttpResponseStatus.BAD_REQUEST);
return response.writeStringAndFlush("Error 500: " + message + "\n");
}
}
| 2,353 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/SourceDataRetriever.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer;
import how.hollow.producer.datamodel.Actor;
import how.hollow.producer.datamodel.Movie;
import java.util.*;
public class SourceDataRetriever {
private final List<Movie> allMovies;
private final List<Actor> allActors;
private final Random rand;
private int nextMovieId;
private int nextActorId;
public SourceDataRetriever() {
this.allMovies = new ArrayList<Movie>();
this.allActors = new ArrayList<Actor>();
this.rand = new Random();
bootstrapData();
}
/**
* Retrieve all movies from the source of truth.
*/
public List<Movie> retrieveAllMovies() {
// change a few movie titles
int numMovieNamesToChange = rand.nextInt(5);
for(int i=0;i<numMovieNamesToChange;i++) {
Movie movie = allMovies.get(rand.nextInt(allMovies.size()));
movie.title = generateRandomString();
}
// maybe change an actor name
if(rand.nextInt(5) == 1) {
Actor actor = allActors.get(rand.nextInt(allActors.size()));
actor.actorName = generateRandomString();
}
// modify a few movie cast lists
int numCastListsToEdit = rand.nextInt(5);
for(int i=0;i<numCastListsToEdit;i++) {
Movie movie = allMovies.get(rand.nextInt(allMovies.size()));
int numActorsToRemove = Math.min(rand.nextInt(4), movie.actors.size());
int numActorsToAdd = rand.nextInt(4);
for(int j=0;j<numActorsToRemove;j++) {
Iterator<Actor> iterator = movie.actors.iterator();
iterator.next();
iterator.remove();
}
for(int j=0;j<numActorsToAdd;j++)
movie.actors.add(allActors.get(rand.nextInt(allActors.size())));
}
/// remove a few movies
int numMoviesToRemove = rand.nextInt(3);
for(int i=0;i<numMoviesToRemove;i++)
allMovies.remove(rand.nextInt(allMovies.size()));
/// add a few movies
int numMoviesToAdd = rand.nextInt(3);
for(int i=0;i<numMoviesToAdd;i++)
allMovies.add(generateNewRandomMovie());
return allMovies;
}
private List<Movie> bootstrapData() {
nextActorId = 1000000;
nextMovieId = 1000000;
for(int i=1;i<1000;i++)
allActors.add(generateNewRandomActor());
for(int i=0;i<10000;i++)
allMovies.add(generateNewRandomMovie());
return allMovies;
}
private Actor generateNewRandomActor() {
return new Actor(++nextActorId, generateRandomString());
}
private Movie generateNewRandomMovie() {
int numActors = rand.nextInt(25) + 1;
Set<Actor> actors = new HashSet<Actor>();
for(int j=0;j<numActors;j++) {
actors.add(allActors.get(rand.nextInt(allActors.size())));
}
return new Movie(++nextMovieId, generateRandomString(), actors);
}
private String generateRandomString() {
Random rand = new Random();
StringBuilder str = new StringBuilder();
int nameChars = rand.nextInt(20) + 5;
for(int j=0;j<nameChars;j++) {
str.append((char)(rand.nextInt(26) + 97));
}
return str.toString();
}
}
| 2,354 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/Producer.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer;
import com.netflix.hollow.api.consumer.HollowConsumer.AnnouncementWatcher;
import com.netflix.hollow.api.consumer.HollowConsumer.BlobRetriever;
import com.netflix.hollow.api.consumer.fs.HollowFilesystemAnnouncementWatcher;
import com.netflix.hollow.api.consumer.fs.HollowFilesystemBlobRetriever;
import com.netflix.hollow.api.producer.HollowProducer;
import com.netflix.hollow.api.producer.HollowProducer.Announcer;
import com.netflix.hollow.api.producer.HollowProducer.Publisher;
import com.netflix.hollow.api.producer.fs.HollowFilesystemAnnouncer;
import com.netflix.hollow.api.producer.fs.HollowFilesystemPublisher;
import how.hollow.producer.datamodel.Movie;
import java.io.File;
public class Producer {
public static final String SCRATCH_DIR = System.getProperty("java.io.tmpdir");
private static final long MIN_TIME_BETWEEN_CYCLES = 10000;
public static void main(String[] args) {
File publishDir = new File(SCRATCH_DIR, "publish-dir");
publishDir.mkdir();
System.out.println("I AM THE PRODUCER. I WILL PUBLISH TO " + publishDir.getAbsolutePath());
Publisher publisher = new HollowFilesystemPublisher(publishDir.toPath());
Announcer announcer = new HollowFilesystemAnnouncer(publishDir.toPath());
BlobRetriever blobRetriever = new HollowFilesystemBlobRetriever(publishDir.toPath());
AnnouncementWatcher announcementWatcher = new HollowFilesystemAnnouncementWatcher(publishDir.toPath());
HollowProducer producer = HollowProducer.withPublisher(publisher)
.withAnnouncer(announcer)
.build();
producer.initializeDataModel(Movie.class);
restoreIfAvailable(producer, blobRetriever, announcementWatcher);
cycleForever(producer);
}
public static void restoreIfAvailable(HollowProducer producer,
BlobRetriever retriever,
AnnouncementWatcher unpinnableAnnouncementWatcher) {
System.out.println("ATTEMPTING TO RESTORE PRIOR STATE...");
long latestVersion = unpinnableAnnouncementWatcher.getLatestVersion();
if(latestVersion != AnnouncementWatcher.NO_ANNOUNCEMENT_AVAILABLE) {
producer.restore(latestVersion, retriever);
System.out.println("RESTORED " + latestVersion);
} else {
System.out.println("RESTORE NOT AVAILABLE");
}
}
public static void cycleForever(HollowProducer producer) {
final SourceDataRetriever sourceDataRetriever = new SourceDataRetriever();
long lastCycleTime = Long.MIN_VALUE;
while(true) {
waitForMinCycleTime(lastCycleTime);
lastCycleTime = System.currentTimeMillis();
producer.runCycle(writeState -> {
for(Movie movie : sourceDataRetriever.retrieveAllMovies()) {
writeState.add(movie); /// <-- this is thread-safe, and can be done in parallel
}
});
}
}
private static void waitForMinCycleTime(long lastCycleTime) {
long targetNextCycleTime = lastCycleTime + MIN_TIME_BETWEEN_CYCLES;
while(System.currentTimeMillis() < targetNextCycleTime) {
try {
Thread.sleep(targetNextCycleTime - System.currentTimeMillis());
} catch(InterruptedException ignore) { }
}
}
}
| 2,355 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/infrastructure/S3Publisher.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer.infrastructure;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.ObjectListing;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.model.S3ObjectSummary;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.Upload;
import com.netflix.hollow.api.producer.HollowProducer.Blob;
import com.netflix.hollow.api.producer.HollowProducer.Publisher;
import com.netflix.hollow.core.memory.encoding.HashCodes;
import com.netflix.hollow.core.memory.encoding.VarInt;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class S3Publisher implements Publisher {
private final AmazonS3 s3;
private final TransferManager s3TransferManager;
private final String bucketName;
private final String blobNamespace;
private final List<Long> snapshotIndex;
public S3Publisher(AWSCredentials credentials, String bucketName, String blobNamespace) {
this.s3 = new AmazonS3Client(credentials);
this.s3TransferManager = new TransferManager(s3);
this.bucketName = bucketName;
this.blobNamespace = blobNamespace;
this.snapshotIndex = initializeSnapshotIndex();
}
@Override
public void publish(Blob blob) {
switch(blob.getType()) {
case SNAPSHOT:
publishSnapshot(blob);
break;
case DELTA:
publishDelta(blob);
break;
case REVERSE_DELTA:
publishReverseDelta(blob);
break;
}
}
public void publishSnapshot(Blob blob) {
String objectName = getS3ObjectName(blobNamespace, "snapshot", blob.getToVersion());
ObjectMetadata metadata = new ObjectMetadata();
metadata.addUserMetadata("to_state", String.valueOf(blob.getToVersion()));
metadata.setHeader("Content-Length", blob.getFile().length());
uploadFile(blob.getFile(), objectName, metadata);
/// now we update the snapshot index
updateSnapshotIndex(blob.getToVersion());
}
public void publishDelta(Blob blob) {
String objectName = getS3ObjectName(blobNamespace, "delta", blob.getFromVersion());
ObjectMetadata metadata = new ObjectMetadata();
metadata.addUserMetadata("from_state", String.valueOf(blob.getFromVersion()));
metadata.addUserMetadata("to_state", String.valueOf(blob.getToVersion()));
metadata.setHeader("Content-Length", blob.getFile().length());
uploadFile(blob.getFile(), objectName, metadata);
}
public void publishReverseDelta(Blob blob) {
String objectName = getS3ObjectName(blobNamespace, "reversedelta", blob.getFromVersion());
ObjectMetadata metadata = new ObjectMetadata();
metadata.addUserMetadata("from_state", String.valueOf(blob.getFromVersion()));
metadata.addUserMetadata("to_state", String.valueOf(blob.getToVersion()));
metadata.setHeader("Content-Length", blob.getFile().length());
uploadFile(blob.getFile(), objectName, metadata);
}
public static String getS3ObjectName(String blobNamespace, String fileType, long lookupVersion) {
StringBuilder builder = new StringBuilder(getS3ObjectPrefix(blobNamespace, fileType));
builder.append(Integer.toHexString(HashCodes.hashLong(lookupVersion)));
builder.append("-");
builder.append(lookupVersion);
return builder.toString();
}
private static String getS3ObjectPrefix(String blobNamespace, String fileType) {
StringBuilder builder = new StringBuilder(blobNamespace);
builder.append("/").append(fileType).append("/");
return builder.toString();
}
private void uploadFile(File file, String s3ObjectName, ObjectMetadata metadata) {
try (InputStream is = new BufferedInputStream(new FileInputStream(file))) {
Upload upload = s3TransferManager.upload(bucketName, s3ObjectName, is, metadata);
upload.waitForCompletion();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/////////////////////// BEGIN SNAPSHOT INDEX CODE ///////////////////////
/*
* We need an index over the available state versions for which snapshot blobs are available.
* The S3Publisher stores that index as an object with a known key in S3.
* The remainder of this class deals with maintaining that index.
*/
public static String getSnapshotIndexObjectName(String blobNamespace) {
return blobNamespace + "/snapshot.index";
}
/**
* Write a list of all of the state versions to S3.
* @param newVersion
*/
private synchronized void updateSnapshotIndex(Long newVersion) {
/// insert the new version into the list
int idx = Collections.binarySearch(snapshotIndex, newVersion);
int insertionPoint = Math.abs(idx) - 1;
snapshotIndex.add(insertionPoint, newVersion);
/// build a binary representation of the list -- gap encoded variable-length integers
byte[] idxBytes = buidGapEncodedVarIntSnapshotIndex();
/// indicate the Content-Length
ObjectMetadata metadata = new ObjectMetadata();
metadata.setHeader("Content-Length", (long)idxBytes.length);
/// upload the new file content.
try(InputStream is = new ByteArrayInputStream(idxBytes)) {
Upload upload = s3TransferManager.upload(bucketName, getSnapshotIndexObjectName(blobNamespace), is, metadata);
upload.waitForCompletion();
} catch(Exception e) {
throw new RuntimeException(e);
}
}
/**
* Encode the sorted list of all state versions as gap-encoded variable length integers.
* @return
*/
private byte[] buidGapEncodedVarIntSnapshotIndex() {
int idx;
byte[] idxBytes;
idx = 0;
long currentSnapshotId = snapshotIndex.get(idx++);
long currentSnapshotIdGap = currentSnapshotId;
try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
while(idx < snapshotIndex.size()) {
VarInt.writeVLong(os, currentSnapshotIdGap);
long nextSnapshotId = snapshotIndex.get(idx++);
currentSnapshotIdGap = nextSnapshotId - currentSnapshotId;
currentSnapshotId = nextSnapshotId;
}
VarInt.writeVLong(os, currentSnapshotIdGap);
idxBytes = os.toByteArray();
} catch(IOException shouldNotHappen) {
throw new RuntimeException(shouldNotHappen);
}
return idxBytes;
}
/**
* Find all of the existing snapshots.
*/
private List<Long> initializeSnapshotIndex() {
List<Long> snapshotIdx = new ArrayList<Long>();
ObjectListing listObjects = s3.listObjects(bucketName, getS3ObjectPrefix(blobNamespace, "snapshot"));
for (S3ObjectSummary summary : listObjects.getObjectSummaries())
addSnapshotStateId(summary, snapshotIdx);
while (listObjects.isTruncated()) {
listObjects = s3.listNextBatchOfObjects(listObjects);
for (S3ObjectSummary summary : listObjects.getObjectSummaries())
addSnapshotStateId(summary, snapshotIdx);
}
Collections.sort(snapshotIdx);
return snapshotIdx;
}
private void addSnapshotStateId(S3ObjectSummary obj, List<Long> snapshotIdx) {
String key = obj.getKey();
try {
snapshotIdx.add(Long.parseLong(key.substring(key.lastIndexOf("-") + 1)));
} catch(NumberFormatException ignore) { }
}
}
| 2,356 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/infrastructure/S3Announcer.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer.infrastructure;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.netflix.hollow.api.producer.HollowProducer.Announcer;
public class S3Announcer implements Announcer {
public static final String ANNOUNCEMENT_OBJECTNAME = "announced.version";
private final AmazonS3 s3;
private final String bucketName;
private final String blobNamespace;
public S3Announcer(AWSCredentials credentials, String bucketName, String blobNamespace) {
this.s3 = new AmazonS3Client(credentials);
this.bucketName = bucketName;
this.blobNamespace = blobNamespace;
}
@Override
public void announce(long stateVersion) {
s3.putObject(bucketName, blobNamespace + "/" + ANNOUNCEMENT_OBJECTNAME, String.valueOf(stateVersion));
}
}
| 2,357 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/infrastructure/DynamoDBAnnouncer.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer.infrastructure;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.UpdateItemSpec;
import com.amazonaws.services.dynamodbv2.document.utils.NameMap;
import com.amazonaws.services.dynamodbv2.document.utils.ValueMap;
import com.netflix.hollow.api.producer.HollowProducer.Announcer;
public class DynamoDBAnnouncer implements Announcer {
private final DynamoDB dynamoDB;
private final String tableName;
private final String blobNamespace;
public DynamoDBAnnouncer(AWSCredentials credentials, String tableName, String blobNamespace) {
this.dynamoDB = new DynamoDB(new AmazonDynamoDBClient(credentials));
this.tableName = tableName;
this.blobNamespace = blobNamespace;
}
@Override
public void announce(long stateVersion) {
Table table = dynamoDB.getTable(tableName);
UpdateItemSpec updateItemSpec = new UpdateItemSpec()
.withPrimaryKey("namespace", blobNamespace)
.withUpdateExpression("set #version = :ver")
.withNameMap(new NameMap().with("#version", "version"))
.withValueMap(new ValueMap().withNumber(":ver", stateVersion));
table.updateItem(updateItemSpec);
}
}
| 2,358 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/datamodel/Actor.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer.datamodel;
import com.netflix.hollow.core.write.objectmapper.HollowPrimaryKey;
@HollowPrimaryKey(fields="actorId")
public class Actor {
public int actorId;
public String actorName;
public Actor() { }
public Actor(int actorId, String actorName) {
this.actorId = actorId;
this.actorName = actorName;
}
}
| 2,359 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/producer/datamodel/Movie.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.producer.datamodel;
import com.netflix.hollow.core.write.objectmapper.HollowHashKey;
import com.netflix.hollow.core.write.objectmapper.HollowPrimaryKey;
import java.util.Set;
@HollowPrimaryKey(fields="id")
public class Movie {
public int id;
public String title;
@HollowHashKey(fields="actorName")
public Set<Actor> actors;
public Movie() { }
public Movie(int id, String title, Set<Actor> actors) {
this.id = id;
this.title = title;
this.actors = actors;
}
}
| 2,360 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/Consumer.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.consumer;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.fs.HollowFilesystemAnnouncementWatcher;
import com.netflix.hollow.api.consumer.fs.HollowFilesystemBlobRetriever;
import com.netflix.hollow.api.consumer.index.HashIndex;
import com.netflix.hollow.api.consumer.index.UniqueKeyIndex;
import com.netflix.hollow.explorer.ui.jetty.HollowExplorerUIServer;
import com.netflix.hollow.history.ui.jetty.HollowHistoryUIServer;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.Movie;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.producer.Producer;
import java.io.File;
public class Consumer {
public static void main(String args[]) throws Exception {
File publishDir = new File(Producer.SCRATCH_DIR, "publish-dir");
System.out.println("I AM THE CONSUMER. I WILL READ FROM " + publishDir.getAbsolutePath());
HollowConsumer.BlobRetriever blobRetriever = new HollowFilesystemBlobRetriever(publishDir.toPath());
HollowConsumer.AnnouncementWatcher announcementWatcher = new HollowFilesystemAnnouncementWatcher(publishDir.toPath());
HollowConsumer consumer = HollowConsumer.withBlobRetriever(blobRetriever)
.withAnnouncementWatcher(announcementWatcher)
.withGeneratedAPIClass(MovieAPI.class)
.build();
consumer.triggerRefresh();
hereIsHowToUseTheDataProgrammatically(consumer);
/// start a history server on port 7777
HollowHistoryUIServer historyServer = new HollowHistoryUIServer(consumer, 7777);
historyServer.start();
/// start an explorer server on port 7778
HollowExplorerUIServer explorerServer = new HollowExplorerUIServer(consumer, 7778);
explorerServer.start();
historyServer.join();
}
private static void hereIsHowToUseTheDataProgrammatically(HollowConsumer consumer) {
/// create an index for Movie based on its primary key (Id)
UniqueKeyIndex<Movie, Integer> idx = Movie.uniqueIndex(consumer);
/// create an index for movies by the names of cast members
HashIndex<Movie, String> moviesByActorName = HashIndex.from(consumer, Movie.class)
.usingPath("actors.element.actorName.value", String.class);
/// find the movie for a some known ID
Movie foundMovie = idx.findMatch(1000004);
/// for each actor in that movie
for(Actor actor : foundMovie.getActors()) {
/// get all of movies of which they are cast members
moviesByActorName.findMatches(actor.getActorName()).forEach(movie -> {
/// and just print the result
System.out.println(actor.getActorName() + " starred in " + movie.getTitle());
});
}
}
}
| 2,361 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/APIGenerator.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.consumer.api;
import com.netflix.hollow.api.codegen.HollowAPIGenerator;
import com.netflix.hollow.core.write.HollowWriteStateEngine;
import com.netflix.hollow.core.write.objectmapper.HollowObjectMapper;
import java.io.File;
import java.io.IOException;
/**
* <ul>
* <li>or use the gradle generation task with `./gradlew generateHollowConsumerApi`</li>
* <li>or use the maven generation task with `mvn hollow:generate-as-project-sources`</li>
* </ul>
* (maven generation is broken atm due the old version of hollow in its dependencies,
* please vote for <a href="https://github.com/IgorPerikov/hollow-maven-plugin/pull/17">this PR</a>)
*/
public class APIGenerator {
private static final String GENERATED_API_NAME = "MovieAPI";
private static final String DATA_MODEL_PACKAGE = "how.hollow.producer.datamodel";
private static final String GENERATED_API_PACKAGE = "how.hollow.consumer.api.generated";
private static final String DATA_MODEL_SOURCE_FOLDER = "src/main/java/" + DATA_MODEL_PACKAGE.replace('.', '/');
private static final String GENERATED_API_CODE_FOLDER = "src/main/java/" + GENERATED_API_PACKAGE.replace('.', '/');
/**
* Run this main method to (re)generate the API based on the POJOs defining the data model.
* If the first arg is populated, it will specify the root project folder. If not, we will attempt to discover the root project folder.
*/
public static void main(String[] args) throws ClassNotFoundException, IOException {
File projectRootFolder;
if(args.length > 0)
projectRootFolder = new File(args[0]);
else
projectRootFolder = findRootProjectFolder();
APIGenerator generator = new APIGenerator(projectRootFolder);
generator.generateFiles();
}
private final File projectRootFolder;
public APIGenerator(File projectRootFolder) {
this.projectRootFolder = projectRootFolder;
}
/**
* Generate the API.
*/
public void generateFiles() throws IOException, ClassNotFoundException {
/// we'll use the following write state engine and object mapper to build schemas
HollowWriteStateEngine stateEngine = new HollowWriteStateEngine();
HollowObjectMapper mapper = new HollowObjectMapper(stateEngine);
/// iterate over all java POJO files describing the data model.
for(String filename : findProjectFolder(DATA_MODEL_SOURCE_FOLDER).list()) {
if(filename.endsWith(".java") && !filename.equals("SourceDataRetriever.java")) {
String discoveredType = filename.substring(0, filename.indexOf(".java"));
/// initialize the schema for that data model type.
mapper.initializeTypeState(Class.forName(DATA_MODEL_PACKAGE + "." + discoveredType));
}
}
File apiCodeFolder = findProjectFolder(GENERATED_API_CODE_FOLDER);
apiCodeFolder.mkdirs();
for(File f : apiCodeFolder.listFiles())
f.delete();
HollowAPIGenerator codeGenerator = new HollowAPIGenerator.Builder()
.withAPIClassname(GENERATED_API_NAME)
.withPackageName(GENERATED_API_PACKAGE)
.withDataModel(stateEngine)
.withDestination(apiCodeFolder.toPath())
.withParameterizeAllClassNames(false)
.withAggressiveSubstitutions(false)
.withBooleanFieldErgonomics(true)
.reservePrimaryKeyIndexForTypeWithPrimaryKey(true)
.withHollowPrimitiveTypes(true)
.withVerboseToString(true)
.withRestrictApiToFieldType()
.withPackageGrouping()
.withErgonomicShortcuts()
.withClassPostfix("")
.build();
codeGenerator.generateSourceFiles();
}
/**
* Find the relative project folder
*/
private File findProjectFolder(String projectFolder) {
File f = projectRootFolder;
for(String s : projectFolder.split("//")) {
f = new File(f, s);
}
return f;
}
/**
* Attempts to find the root project folder.
* Assumption: A file 'readme', which is in the classpath, is nested somewhere underneath the root project folder.
*/
private static File findRootProjectFolder() {
File f = new File(APIGenerator.class.getResource("/readme").getFile());
f = f.getParentFile();
while(!containsBuildGradle(f)) {
f = f.getParentFile();
}
return f;
}
/**
* Assumption: The root project folder contains a file called 'build.gradle'
*/
private static boolean containsBuildGradle(File f) {
return f.listFiles((dir, name) -> name.equals("build.gradle")).length > 0;
}
}
| 2,362 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/MovieAPI.java | package how.hollow.consumer.api.generated;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import java.util.Objects;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.Map;
import com.netflix.hollow.api.consumer.HollowConsumerAPI;
import com.netflix.hollow.api.custom.HollowAPI;
import com.netflix.hollow.core.read.dataaccess.HollowDataAccess;
import com.netflix.hollow.core.read.dataaccess.HollowTypeDataAccess;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
import com.netflix.hollow.core.read.dataaccess.HollowListTypeDataAccess;
import com.netflix.hollow.core.read.dataaccess.HollowSetTypeDataAccess;
import com.netflix.hollow.core.read.dataaccess.HollowMapTypeDataAccess;
import com.netflix.hollow.core.read.dataaccess.missing.HollowObjectMissingDataAccess;
import com.netflix.hollow.core.read.dataaccess.missing.HollowListMissingDataAccess;
import com.netflix.hollow.core.read.dataaccess.missing.HollowSetMissingDataAccess;
import com.netflix.hollow.core.read.dataaccess.missing.HollowMapMissingDataAccess;
import com.netflix.hollow.api.objects.provider.HollowFactory;
import com.netflix.hollow.api.objects.provider.HollowObjectProvider;
import com.netflix.hollow.api.objects.provider.HollowObjectCacheProvider;
import com.netflix.hollow.api.objects.provider.HollowObjectFactoryProvider;
import com.netflix.hollow.api.sampling.HollowObjectCreationSampler;
import com.netflix.hollow.api.sampling.HollowSamplingDirector;
import com.netflix.hollow.api.sampling.SampleResult;
import com.netflix.hollow.core.util.AllHollowRecordCollection;
@SuppressWarnings("all")
public class MovieAPI extends HollowAPI implements HollowConsumerAPI.StringRetriever {
private final HollowObjectCreationSampler objectCreationSampler;
private final StringTypeAPI stringTypeAPI;
private final ActorTypeAPI actorTypeAPI;
private final SetOfActorTypeAPI setOfActorTypeAPI;
private final MovieTypeAPI movieTypeAPI;
private final HollowObjectProvider stringProvider;
private final HollowObjectProvider actorProvider;
private final HollowObjectProvider setOfActorProvider;
private final HollowObjectProvider movieProvider;
public MovieAPI(HollowDataAccess dataAccess) {
this(dataAccess, Collections.<String>emptySet());
}
public MovieAPI(HollowDataAccess dataAccess, Set<String> cachedTypes) {
this(dataAccess, cachedTypes, Collections.<String, HollowFactory<?>>emptyMap());
}
public MovieAPI(HollowDataAccess dataAccess, Set<String> cachedTypes, Map<String, HollowFactory<?>> factoryOverrides) {
this(dataAccess, cachedTypes, factoryOverrides, null);
}
public MovieAPI(HollowDataAccess dataAccess, Set<String> cachedTypes, Map<String, HollowFactory<?>> factoryOverrides, MovieAPI previousCycleAPI) {
super(dataAccess);
HollowTypeDataAccess typeDataAccess;
HollowFactory factory;
objectCreationSampler = new HollowObjectCreationSampler("String","Actor","SetOfActor","Movie");
typeDataAccess = dataAccess.getTypeDataAccess("String");
if(typeDataAccess != null) {
stringTypeAPI = new StringTypeAPI(this, (HollowObjectTypeDataAccess)typeDataAccess);
} else {
stringTypeAPI = new StringTypeAPI(this, new HollowObjectMissingDataAccess(dataAccess, "String"));
}
addTypeAPI(stringTypeAPI);
factory = factoryOverrides.get("String");
if(factory == null)
factory = new StringHollowFactory();
if(cachedTypes.contains("String")) {
HollowObjectCacheProvider previousCacheProvider = null;
if(previousCycleAPI != null && (previousCycleAPI.stringProvider instanceof HollowObjectCacheProvider))
previousCacheProvider = (HollowObjectCacheProvider) previousCycleAPI.stringProvider;
stringProvider = new HollowObjectCacheProvider(typeDataAccess, stringTypeAPI, factory, previousCacheProvider);
} else {
stringProvider = new HollowObjectFactoryProvider(typeDataAccess, stringTypeAPI, factory);
}
typeDataAccess = dataAccess.getTypeDataAccess("Actor");
if(typeDataAccess != null) {
actorTypeAPI = new ActorTypeAPI(this, (HollowObjectTypeDataAccess)typeDataAccess);
} else {
actorTypeAPI = new ActorTypeAPI(this, new HollowObjectMissingDataAccess(dataAccess, "Actor"));
}
addTypeAPI(actorTypeAPI);
factory = factoryOverrides.get("Actor");
if(factory == null)
factory = new ActorHollowFactory();
if(cachedTypes.contains("Actor")) {
HollowObjectCacheProvider previousCacheProvider = null;
if(previousCycleAPI != null && (previousCycleAPI.actorProvider instanceof HollowObjectCacheProvider))
previousCacheProvider = (HollowObjectCacheProvider) previousCycleAPI.actorProvider;
actorProvider = new HollowObjectCacheProvider(typeDataAccess, actorTypeAPI, factory, previousCacheProvider);
} else {
actorProvider = new HollowObjectFactoryProvider(typeDataAccess, actorTypeAPI, factory);
}
typeDataAccess = dataAccess.getTypeDataAccess("SetOfActor");
if(typeDataAccess != null) {
setOfActorTypeAPI = new SetOfActorTypeAPI(this, (HollowSetTypeDataAccess)typeDataAccess);
} else {
setOfActorTypeAPI = new SetOfActorTypeAPI(this, new HollowSetMissingDataAccess(dataAccess, "SetOfActor"));
}
addTypeAPI(setOfActorTypeAPI);
factory = factoryOverrides.get("SetOfActor");
if(factory == null)
factory = new SetOfActorHollowFactory();
if(cachedTypes.contains("SetOfActor")) {
HollowObjectCacheProvider previousCacheProvider = null;
if(previousCycleAPI != null && (previousCycleAPI.setOfActorProvider instanceof HollowObjectCacheProvider))
previousCacheProvider = (HollowObjectCacheProvider) previousCycleAPI.setOfActorProvider;
setOfActorProvider = new HollowObjectCacheProvider(typeDataAccess, setOfActorTypeAPI, factory, previousCacheProvider);
} else {
setOfActorProvider = new HollowObjectFactoryProvider(typeDataAccess, setOfActorTypeAPI, factory);
}
typeDataAccess = dataAccess.getTypeDataAccess("Movie");
if(typeDataAccess != null) {
movieTypeAPI = new MovieTypeAPI(this, (HollowObjectTypeDataAccess)typeDataAccess);
} else {
movieTypeAPI = new MovieTypeAPI(this, new HollowObjectMissingDataAccess(dataAccess, "Movie"));
}
addTypeAPI(movieTypeAPI);
factory = factoryOverrides.get("Movie");
if(factory == null)
factory = new MovieHollowFactory();
if(cachedTypes.contains("Movie")) {
HollowObjectCacheProvider previousCacheProvider = null;
if(previousCycleAPI != null && (previousCycleAPI.movieProvider instanceof HollowObjectCacheProvider))
previousCacheProvider = (HollowObjectCacheProvider) previousCycleAPI.movieProvider;
movieProvider = new HollowObjectCacheProvider(typeDataAccess, movieTypeAPI, factory, previousCacheProvider);
} else {
movieProvider = new HollowObjectFactoryProvider(typeDataAccess, movieTypeAPI, factory);
}
}
public void detachCaches() {
if(stringProvider instanceof HollowObjectCacheProvider)
((HollowObjectCacheProvider)stringProvider).detach();
if(actorProvider instanceof HollowObjectCacheProvider)
((HollowObjectCacheProvider)actorProvider).detach();
if(setOfActorProvider instanceof HollowObjectCacheProvider)
((HollowObjectCacheProvider)setOfActorProvider).detach();
if(movieProvider instanceof HollowObjectCacheProvider)
((HollowObjectCacheProvider)movieProvider).detach();
}
public StringTypeAPI getStringTypeAPI() {
return stringTypeAPI;
}
public ActorTypeAPI getActorTypeAPI() {
return actorTypeAPI;
}
public SetOfActorTypeAPI getSetOfActorTypeAPI() {
return setOfActorTypeAPI;
}
public MovieTypeAPI getMovieTypeAPI() {
return movieTypeAPI;
}
public Collection<HString> getAllHString() {
HollowTypeDataAccess tda = Objects.requireNonNull(getDataAccess().getTypeDataAccess("String"), "type not loaded or does not exist in dataset; type=String");
return new AllHollowRecordCollection<HString>(tda.getTypeState()) {
protected HString getForOrdinal(int ordinal) {
return getHString(ordinal);
}
};
}
public HString getHString(int ordinal) {
objectCreationSampler.recordCreation(0);
return (HString)stringProvider.getHollowObject(ordinal);
}
public Collection<Actor> getAllActor() {
HollowTypeDataAccess tda = Objects.requireNonNull(getDataAccess().getTypeDataAccess("Actor"), "type not loaded or does not exist in dataset; type=Actor");
return new AllHollowRecordCollection<Actor>(tda.getTypeState()) {
protected Actor getForOrdinal(int ordinal) {
return getActor(ordinal);
}
};
}
public Actor getActor(int ordinal) {
objectCreationSampler.recordCreation(1);
return (Actor)actorProvider.getHollowObject(ordinal);
}
public Collection<SetOfActor> getAllSetOfActor() {
HollowTypeDataAccess tda = Objects.requireNonNull(getDataAccess().getTypeDataAccess("SetOfActor"), "type not loaded or does not exist in dataset; type=SetOfActor");
return new AllHollowRecordCollection<SetOfActor>(tda.getTypeState()) {
protected SetOfActor getForOrdinal(int ordinal) {
return getSetOfActor(ordinal);
}
};
}
public SetOfActor getSetOfActor(int ordinal) {
objectCreationSampler.recordCreation(2);
return (SetOfActor)setOfActorProvider.getHollowObject(ordinal);
}
public Collection<Movie> getAllMovie() {
HollowTypeDataAccess tda = Objects.requireNonNull(getDataAccess().getTypeDataAccess("Movie"), "type not loaded or does not exist in dataset; type=Movie");
return new AllHollowRecordCollection<Movie>(tda.getTypeState()) {
protected Movie getForOrdinal(int ordinal) {
return getMovie(ordinal);
}
};
}
public Movie getMovie(int ordinal) {
objectCreationSampler.recordCreation(3);
return (Movie)movieProvider.getHollowObject(ordinal);
}
public void setSamplingDirector(HollowSamplingDirector director) {
super.setSamplingDirector(director);
objectCreationSampler.setSamplingDirector(director);
}
public Collection<SampleResult> getObjectCreationSamplingResults() {
return objectCreationSampler.getSampleResults();
}
}
| 2,363 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/Actor.java | package how.hollow.consumer.api.generated;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.index.UniqueKeyIndex;
import com.netflix.hollow.api.objects.HollowObject;
import com.netflix.hollow.core.schema.HollowObjectSchema;
import com.netflix.hollow.tools.stringifier.HollowRecordStringifier;
@SuppressWarnings("all")
public class Actor extends HollowObject {
public Actor(ActorDelegate delegate, int ordinal) {
super(delegate, ordinal);
}
public int getActorId() {
return delegate().getActorId(ordinal);
}
public String getActorName() {
return delegate().getActorName(ordinal);
}
public boolean isActorNameEqual(String testValue) {
return delegate().isActorNameEqual(ordinal, testValue);
}
public HString getActorNameHollowReference() {
int refOrdinal = delegate().getActorNameOrdinal(ordinal);
if(refOrdinal == -1)
return null;
return api().getHString(refOrdinal);
}
public MovieAPI api() {
return typeApi().getAPI();
}
public ActorTypeAPI typeApi() {
return delegate().getTypeAPI();
}
protected ActorDelegate delegate() {
return (ActorDelegate)delegate;
}
public String toString() {
return new HollowRecordStringifier().stringify(this);
}
/**
* Creates a unique key index for {@code Actor} that has a primary key.
* The primary key is represented by the type {@code int}.
* <p>
* By default the unique key index will not track updates to the {@code consumer} and thus
* any changes will not be reflected in matched results. To track updates the index must be
* {@link HollowConsumer#addRefreshListener(HollowConsumer.RefreshListener) registered}
* with the {@code consumer}
*
* @param consumer the consumer
* @return the unique key index
*/
public static UniqueKeyIndex<Actor, Integer> uniqueIndex(HollowConsumer consumer) {
return UniqueKeyIndex.from(consumer, Actor.class)
.bindToPrimaryKey()
.usingPath("actorId", int.class);
}
} | 2,364 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/Movie.java | package how.hollow.consumer.api.generated;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.index.UniqueKeyIndex;
import com.netflix.hollow.api.objects.HollowObject;
import com.netflix.hollow.core.schema.HollowObjectSchema;
import com.netflix.hollow.tools.stringifier.HollowRecordStringifier;
@SuppressWarnings("all")
public class Movie extends HollowObject {
public Movie(MovieDelegate delegate, int ordinal) {
super(delegate, ordinal);
}
public int getId() {
return delegate().getId(ordinal);
}
public String getTitle() {
return delegate().getTitle(ordinal);
}
public boolean isTitleEqual(String testValue) {
return delegate().isTitleEqual(ordinal, testValue);
}
public HString getTitleHollowReference() {
int refOrdinal = delegate().getTitleOrdinal(ordinal);
if(refOrdinal == -1)
return null;
return api().getHString(refOrdinal);
}
public SetOfActor getActors() {
int refOrdinal = delegate().getActorsOrdinal(ordinal);
if(refOrdinal == -1)
return null;
return api().getSetOfActor(refOrdinal);
}
public MovieAPI api() {
return typeApi().getAPI();
}
public MovieTypeAPI typeApi() {
return delegate().getTypeAPI();
}
protected MovieDelegate delegate() {
return (MovieDelegate)delegate;
}
public String toString() {
return new HollowRecordStringifier().stringify(this);
}
/**
* Creates a unique key index for {@code Movie} that has a primary key.
* The primary key is represented by the type {@code int}.
* <p>
* By default the unique key index will not track updates to the {@code consumer} and thus
* any changes will not be reflected in matched results. To track updates the index must be
* {@link HollowConsumer#addRefreshListener(HollowConsumer.RefreshListener) registered}
* with the {@code consumer}
*
* @param consumer the consumer
* @return the unique key index
*/
public static UniqueKeyIndex<Movie, Integer> uniqueIndex(HollowConsumer consumer) {
return UniqueKeyIndex.from(consumer, Movie.class)
.bindToPrimaryKey()
.usingPath("id", int.class);
}
} | 2,365 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/SetOfActorTypeAPI.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.custom.HollowSetTypeAPI;
import com.netflix.hollow.core.read.dataaccess.HollowSetTypeDataAccess;
import com.netflix.hollow.api.objects.delegate.HollowSetLookupDelegate;
@SuppressWarnings("all")
public class SetOfActorTypeAPI extends HollowSetTypeAPI {
private final HollowSetLookupDelegate delegateLookupImpl;
public SetOfActorTypeAPI(MovieAPI api, HollowSetTypeDataAccess dataAccess) {
super(api, dataAccess);
this.delegateLookupImpl = new HollowSetLookupDelegate(this);
}
public ActorTypeAPI getElementAPI() {
return getAPI().getActorTypeAPI();
}
public MovieAPI getAPI() {
return (MovieAPI)api;
}
public HollowSetLookupDelegate getDelegateLookupImpl() {
return delegateLookupImpl;
}
} | 2,366 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/MovieDelegateLookupImpl.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.delegate.HollowObjectAbstractDelegate;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
import com.netflix.hollow.core.schema.HollowObjectSchema;
@SuppressWarnings("all")
public class MovieDelegateLookupImpl extends HollowObjectAbstractDelegate implements MovieDelegate {
private final MovieTypeAPI typeAPI;
public MovieDelegateLookupImpl(MovieTypeAPI typeAPI) {
this.typeAPI = typeAPI;
}
public int getId(int ordinal) {
return typeAPI.getId(ordinal);
}
public Integer getIdBoxed(int ordinal) {
return typeAPI.getIdBoxed(ordinal);
}
public String getTitle(int ordinal) {
ordinal = typeAPI.getTitleOrdinal(ordinal);
return ordinal == -1 ? null : typeAPI.getAPI().getStringTypeAPI().getValue(ordinal);
}
public boolean isTitleEqual(int ordinal, String testValue) {
ordinal = typeAPI.getTitleOrdinal(ordinal);
return ordinal == -1 ? testValue == null : typeAPI.getAPI().getStringTypeAPI().isValueEqual(ordinal, testValue);
}
public int getTitleOrdinal(int ordinal) {
return typeAPI.getTitleOrdinal(ordinal);
}
public int getActorsOrdinal(int ordinal) {
return typeAPI.getActorsOrdinal(ordinal);
}
public MovieTypeAPI getTypeAPI() {
return typeAPI;
}
@Override
public HollowObjectSchema getSchema() {
return typeAPI.getTypeDataAccess().getSchema();
}
@Override
public HollowObjectTypeDataAccess getTypeDataAccess() {
return typeAPI.getTypeDataAccess();
}
} | 2,367 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/ActorDelegateCachedImpl.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.delegate.HollowObjectAbstractDelegate;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
import com.netflix.hollow.core.schema.HollowObjectSchema;
import com.netflix.hollow.api.custom.HollowTypeAPI;
import com.netflix.hollow.api.objects.delegate.HollowCachedDelegate;
@SuppressWarnings("all")
public class ActorDelegateCachedImpl extends HollowObjectAbstractDelegate implements HollowCachedDelegate, ActorDelegate {
private final Integer actorId;
private final String actorName;
private final int actorNameOrdinal;
private ActorTypeAPI typeAPI;
public ActorDelegateCachedImpl(ActorTypeAPI typeAPI, int ordinal) {
this.actorId = typeAPI.getActorIdBoxed(ordinal);
this.actorNameOrdinal = typeAPI.getActorNameOrdinal(ordinal);
int actorNameTempOrdinal = actorNameOrdinal;
this.actorName = actorNameTempOrdinal == -1 ? null : typeAPI.getAPI().getStringTypeAPI().getValue(actorNameTempOrdinal);
this.typeAPI = typeAPI;
}
public int getActorId(int ordinal) {
if(actorId == null)
return Integer.MIN_VALUE;
return actorId.intValue();
}
public Integer getActorIdBoxed(int ordinal) {
return actorId;
}
public String getActorName(int ordinal) {
return actorName;
}
public boolean isActorNameEqual(int ordinal, String testValue) {
if(testValue == null)
return actorName == null;
return testValue.equals(actorName);
}
public int getActorNameOrdinal(int ordinal) {
return actorNameOrdinal;
}
@Override
public HollowObjectSchema getSchema() {
return typeAPI.getTypeDataAccess().getSchema();
}
@Override
public HollowObjectTypeDataAccess getTypeDataAccess() {
return typeAPI.getTypeDataAccess();
}
public ActorTypeAPI getTypeAPI() {
return typeAPI;
}
public void updateTypeAPI(HollowTypeAPI typeAPI) {
this.typeAPI = (ActorTypeAPI) typeAPI;
}
} | 2,368 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/MovieAPIFactory.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.client.HollowAPIFactory;
import com.netflix.hollow.api.custom.HollowAPI;
import com.netflix.hollow.api.objects.provider.HollowFactory;
import com.netflix.hollow.core.read.dataaccess.HollowDataAccess;
import java.util.Collections;
import java.util.Set;
@SuppressWarnings("all")
public class MovieAPIFactory implements HollowAPIFactory {
private final Set<String> cachedTypes;
public MovieAPIFactory() {
this(Collections.<String>emptySet());
}
public MovieAPIFactory(Set<String> cachedTypes) {
this.cachedTypes = cachedTypes;
}
@Override
public HollowAPI createAPI(HollowDataAccess dataAccess) {
return new MovieAPI(dataAccess, cachedTypes);
}
@Override
public HollowAPI createAPI(HollowDataAccess dataAccess, HollowAPI previousCycleAPI) {
if (!(previousCycleAPI instanceof MovieAPI)) {
throw new ClassCastException(previousCycleAPI.getClass() + " not instance of MovieAPI"); }
return new MovieAPI(dataAccess, cachedTypes, Collections.<String, HollowFactory<?>>emptyMap(), (MovieAPI) previousCycleAPI);
}
} | 2,369 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/MovieDelegateCachedImpl.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.delegate.HollowObjectAbstractDelegate;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
import com.netflix.hollow.core.schema.HollowObjectSchema;
import com.netflix.hollow.api.custom.HollowTypeAPI;
import com.netflix.hollow.api.objects.delegate.HollowCachedDelegate;
@SuppressWarnings("all")
public class MovieDelegateCachedImpl extends HollowObjectAbstractDelegate implements HollowCachedDelegate, MovieDelegate {
private final Integer id;
private final String title;
private final int titleOrdinal;
private final int actorsOrdinal;
private MovieTypeAPI typeAPI;
public MovieDelegateCachedImpl(MovieTypeAPI typeAPI, int ordinal) {
this.id = typeAPI.getIdBoxed(ordinal);
this.titleOrdinal = typeAPI.getTitleOrdinal(ordinal);
int titleTempOrdinal = titleOrdinal;
this.title = titleTempOrdinal == -1 ? null : typeAPI.getAPI().getStringTypeAPI().getValue(titleTempOrdinal);
this.actorsOrdinal = typeAPI.getActorsOrdinal(ordinal);
this.typeAPI = typeAPI;
}
public int getId(int ordinal) {
if(id == null)
return Integer.MIN_VALUE;
return id.intValue();
}
public Integer getIdBoxed(int ordinal) {
return id;
}
public String getTitle(int ordinal) {
return title;
}
public boolean isTitleEqual(int ordinal, String testValue) {
if(testValue == null)
return title == null;
return testValue.equals(title);
}
public int getTitleOrdinal(int ordinal) {
return titleOrdinal;
}
public int getActorsOrdinal(int ordinal) {
return actorsOrdinal;
}
@Override
public HollowObjectSchema getSchema() {
return typeAPI.getTypeDataAccess().getSchema();
}
@Override
public HollowObjectTypeDataAccess getTypeDataAccess() {
return typeAPI.getTypeDataAccess();
}
public MovieTypeAPI getTypeAPI() {
return typeAPI;
}
public void updateTypeAPI(HollowTypeAPI typeAPI) {
this.typeAPI = (MovieTypeAPI) typeAPI;
}
} | 2,370 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/ActorDelegateLookupImpl.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.delegate.HollowObjectAbstractDelegate;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
import com.netflix.hollow.core.schema.HollowObjectSchema;
@SuppressWarnings("all")
public class ActorDelegateLookupImpl extends HollowObjectAbstractDelegate implements ActorDelegate {
private final ActorTypeAPI typeAPI;
public ActorDelegateLookupImpl(ActorTypeAPI typeAPI) {
this.typeAPI = typeAPI;
}
public int getActorId(int ordinal) {
return typeAPI.getActorId(ordinal);
}
public Integer getActorIdBoxed(int ordinal) {
return typeAPI.getActorIdBoxed(ordinal);
}
public String getActorName(int ordinal) {
ordinal = typeAPI.getActorNameOrdinal(ordinal);
return ordinal == -1 ? null : typeAPI.getAPI().getStringTypeAPI().getValue(ordinal);
}
public boolean isActorNameEqual(int ordinal, String testValue) {
ordinal = typeAPI.getActorNameOrdinal(ordinal);
return ordinal == -1 ? testValue == null : typeAPI.getAPI().getStringTypeAPI().isValueEqual(ordinal, testValue);
}
public int getActorNameOrdinal(int ordinal) {
return typeAPI.getActorNameOrdinal(ordinal);
}
public ActorTypeAPI getTypeAPI() {
return typeAPI;
}
@Override
public HollowObjectSchema getSchema() {
return typeAPI.getTypeDataAccess().getSchema();
}
@Override
public HollowObjectTypeDataAccess getTypeDataAccess() {
return typeAPI.getTypeDataAccess();
}
} | 2,371 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/MovieTypeAPI.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.custom.HollowObjectTypeAPI;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
@SuppressWarnings("all")
public class MovieTypeAPI extends HollowObjectTypeAPI {
private final MovieDelegateLookupImpl delegateLookupImpl;
public MovieTypeAPI(MovieAPI api, HollowObjectTypeDataAccess typeDataAccess) {
super(api, typeDataAccess, new String[] {
"id",
"title",
"actors"
});
this.delegateLookupImpl = new MovieDelegateLookupImpl(this);
}
public int getId(int ordinal) {
if(fieldIndex[0] == -1)
return missingDataHandler().handleInt("Movie", ordinal, "id");
return getTypeDataAccess().readInt(ordinal, fieldIndex[0]);
}
public Integer getIdBoxed(int ordinal) {
int i;
if(fieldIndex[0] == -1) {
i = missingDataHandler().handleInt("Movie", ordinal, "id");
} else {
boxedFieldAccessSampler.recordFieldAccess(fieldIndex[0]);
i = getTypeDataAccess().readInt(ordinal, fieldIndex[0]);
}
if(i == Integer.MIN_VALUE)
return null;
return Integer.valueOf(i);
}
public int getTitleOrdinal(int ordinal) {
if(fieldIndex[1] == -1)
return missingDataHandler().handleReferencedOrdinal("Movie", ordinal, "title");
return getTypeDataAccess().readOrdinal(ordinal, fieldIndex[1]);
}
public StringTypeAPI getTitleTypeAPI() {
return getAPI().getStringTypeAPI();
}
public int getActorsOrdinal(int ordinal) {
if(fieldIndex[2] == -1)
return missingDataHandler().handleReferencedOrdinal("Movie", ordinal, "actors");
return getTypeDataAccess().readOrdinal(ordinal, fieldIndex[2]);
}
public SetOfActorTypeAPI getActorsTypeAPI() {
return getAPI().getSetOfActorTypeAPI();
}
public MovieDelegateLookupImpl getDelegateLookupImpl() {
return delegateLookupImpl;
}
@Override
public MovieAPI getAPI() {
return (MovieAPI) api;
}
} | 2,372 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/MovieDelegate.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.delegate.HollowObjectDelegate;
@SuppressWarnings("all")
public interface MovieDelegate extends HollowObjectDelegate {
public int getId(int ordinal);
public Integer getIdBoxed(int ordinal);
public String getTitle(int ordinal);
public boolean isTitleEqual(int ordinal, String testValue);
public int getTitleOrdinal(int ordinal);
public int getActorsOrdinal(int ordinal);
public MovieTypeAPI getTypeAPI();
} | 2,373 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/ActorTypeAPI.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.custom.HollowObjectTypeAPI;
import com.netflix.hollow.core.read.dataaccess.HollowObjectTypeDataAccess;
@SuppressWarnings("all")
public class ActorTypeAPI extends HollowObjectTypeAPI {
private final ActorDelegateLookupImpl delegateLookupImpl;
public ActorTypeAPI(MovieAPI api, HollowObjectTypeDataAccess typeDataAccess) {
super(api, typeDataAccess, new String[] {
"actorId",
"actorName"
});
this.delegateLookupImpl = new ActorDelegateLookupImpl(this);
}
public int getActorId(int ordinal) {
if(fieldIndex[0] == -1)
return missingDataHandler().handleInt("Actor", ordinal, "actorId");
return getTypeDataAccess().readInt(ordinal, fieldIndex[0]);
}
public Integer getActorIdBoxed(int ordinal) {
int i;
if(fieldIndex[0] == -1) {
i = missingDataHandler().handleInt("Actor", ordinal, "actorId");
} else {
boxedFieldAccessSampler.recordFieldAccess(fieldIndex[0]);
i = getTypeDataAccess().readInt(ordinal, fieldIndex[0]);
}
if(i == Integer.MIN_VALUE)
return null;
return Integer.valueOf(i);
}
public int getActorNameOrdinal(int ordinal) {
if(fieldIndex[1] == -1)
return missingDataHandler().handleReferencedOrdinal("Actor", ordinal, "actorName");
return getTypeDataAccess().readOrdinal(ordinal, fieldIndex[1]);
}
public StringTypeAPI getActorNameTypeAPI() {
return getAPI().getStringTypeAPI();
}
public ActorDelegateLookupImpl getDelegateLookupImpl() {
return delegateLookupImpl;
}
@Override
public MovieAPI getAPI() {
return (MovieAPI) api;
}
} | 2,374 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/MovieHollowFactory.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.Movie;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.provider.HollowFactory;
import com.netflix.hollow.core.read.dataaccess.HollowTypeDataAccess;
import com.netflix.hollow.api.custom.HollowTypeAPI;
@SuppressWarnings("all")
public class MovieHollowFactory<T extends Movie> extends HollowFactory<T> {
@Override
public T newHollowObject(HollowTypeDataAccess dataAccess, HollowTypeAPI typeAPI, int ordinal) {
return (T)new Movie(((MovieTypeAPI)typeAPI).getDelegateLookupImpl(), ordinal);
}
@Override
public T newCachedHollowObject(HollowTypeDataAccess dataAccess, HollowTypeAPI typeAPI, int ordinal) {
return (T)new Movie(new MovieDelegateCachedImpl((MovieTypeAPI)typeAPI, ordinal), ordinal);
}
} | 2,375 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/SetOfActorHollowFactory.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.provider.HollowFactory;
import com.netflix.hollow.core.read.dataaccess.HollowTypeDataAccess;
import com.netflix.hollow.api.custom.HollowTypeAPI;
import com.netflix.hollow.api.objects.delegate.HollowSetCachedDelegate;
@SuppressWarnings("all")
public class SetOfActorHollowFactory<T extends SetOfActor> extends HollowFactory<T> {
@Override
public T newHollowObject(HollowTypeDataAccess dataAccess, HollowTypeAPI typeAPI, int ordinal) {
return (T)new SetOfActor(((SetOfActorTypeAPI)typeAPI).getDelegateLookupImpl(), ordinal);
}
@Override
public T newCachedHollowObject(HollowTypeDataAccess dataAccess, HollowTypeAPI typeAPI, int ordinal) {
return (T)new SetOfActor(new HollowSetCachedDelegate((SetOfActorTypeAPI)typeAPI, ordinal), ordinal);
}
} | 2,376 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/ActorDelegate.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.delegate.HollowObjectDelegate;
@SuppressWarnings("all")
public interface ActorDelegate extends HollowObjectDelegate {
public int getActorId(int ordinal);
public Integer getActorIdBoxed(int ordinal);
public String getActorName(int ordinal);
public boolean isActorNameEqual(int ordinal, String testValue);
public int getActorNameOrdinal(int ordinal);
public ActorTypeAPI getTypeAPI();
} | 2,377 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/core/ActorHollowFactory.java | package how.hollow.consumer.api.generated.core;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.provider.HollowFactory;
import com.netflix.hollow.core.read.dataaccess.HollowTypeDataAccess;
import com.netflix.hollow.api.custom.HollowTypeAPI;
@SuppressWarnings("all")
public class ActorHollowFactory<T extends Actor> extends HollowFactory<T> {
@Override
public T newHollowObject(HollowTypeDataAccess dataAccess, HollowTypeAPI typeAPI, int ordinal) {
return (T)new Actor(((ActorTypeAPI)typeAPI).getDelegateLookupImpl(), ordinal);
}
@Override
public T newCachedHollowObject(HollowTypeDataAccess dataAccess, HollowTypeAPI typeAPI, int ordinal) {
return (T)new Actor(new ActorDelegateCachedImpl((ActorTypeAPI)typeAPI, ordinal), ordinal);
}
} | 2,378 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/accessor/ActorDataAccessor.java | package how.hollow.consumer.api.generated.accessor;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.data.AbstractHollowDataAccessor;
import com.netflix.hollow.core.index.key.PrimaryKey;
import com.netflix.hollow.core.read.engine.HollowReadStateEngine;
@SuppressWarnings("all")
public class ActorDataAccessor extends AbstractHollowDataAccessor<Actor> {
public static final String TYPE = "Actor";
private MovieAPI api;
public ActorDataAccessor(HollowConsumer consumer) {
super(consumer, TYPE);
this.api = (MovieAPI)consumer.getAPI();
}
public ActorDataAccessor(HollowReadStateEngine rStateEngine, MovieAPI api) {
super(rStateEngine, TYPE);
this.api = api;
}
public ActorDataAccessor(HollowReadStateEngine rStateEngine, MovieAPI api, String ... fieldPaths) {
super(rStateEngine, TYPE, fieldPaths);
this.api = api;
}
public ActorDataAccessor(HollowReadStateEngine rStateEngine, MovieAPI api, PrimaryKey primaryKey) {
super(rStateEngine, TYPE, primaryKey);
this.api = api;
}
@Override public Actor getRecord(int ordinal){
return api.getActor(ordinal);
}
} | 2,379 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/accessor/MovieDataAccessor.java | package how.hollow.consumer.api.generated.accessor;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Movie;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.data.AbstractHollowDataAccessor;
import com.netflix.hollow.core.index.key.PrimaryKey;
import com.netflix.hollow.core.read.engine.HollowReadStateEngine;
@SuppressWarnings("all")
public class MovieDataAccessor extends AbstractHollowDataAccessor<Movie> {
public static final String TYPE = "Movie";
private MovieAPI api;
public MovieDataAccessor(HollowConsumer consumer) {
super(consumer, TYPE);
this.api = (MovieAPI)consumer.getAPI();
}
public MovieDataAccessor(HollowReadStateEngine rStateEngine, MovieAPI api) {
super(rStateEngine, TYPE);
this.api = api;
}
public MovieDataAccessor(HollowReadStateEngine rStateEngine, MovieAPI api, String ... fieldPaths) {
super(rStateEngine, TYPE, fieldPaths);
this.api = api;
}
public MovieDataAccessor(HollowReadStateEngine rStateEngine, MovieAPI api, PrimaryKey primaryKey) {
super(rStateEngine, TYPE, primaryKey);
this.api = api;
}
@Override public Movie getRecord(int ordinal){
return api.getMovie(ordinal);
}
} | 2,380 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/index/MovieUniqueKeyIndex.java | package how.hollow.consumer.api.generated.index;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Movie;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.index.AbstractHollowUniqueKeyIndex;
import com.netflix.hollow.api.consumer.index.HollowUniqueKeyIndex;
/**
* @deprecated see {@link com.netflix.hollow.api.consumer.index.UniqueKeyIndex} which can be built as follows:
* <pre>{@code
* UniqueKeyIndex<Movie, K> uki = UniqueKeyIndex.from(consumer, Movie.class)
* .usingBean(k);
* Movie m = uki.findMatch(k);
* }</pre>
* where {@code K} is a class declaring key field paths members, annotated with
* {@link com.netflix.hollow.api.consumer.index.FieldPath}, and {@code k} is an instance of
* {@code K} that is the key to find the unique {@code Movie} object.
*/
@Deprecated
@SuppressWarnings("all")
public class MovieUniqueKeyIndex extends AbstractHollowUniqueKeyIndex<MovieAPI, Movie> implements HollowUniqueKeyIndex<Movie> {
public MovieUniqueKeyIndex(HollowConsumer consumer, String... fieldPaths) {
this(consumer, false, fieldPaths);
}
public MovieUniqueKeyIndex(HollowConsumer consumer, boolean isListenToDataRefresh, String... fieldPaths) {
super(consumer, "Movie", isListenToDataRefresh, fieldPaths);
}
@Override
public Movie findMatch(Object... keys) {
int ordinal = idx.getMatchingOrdinal(keys);
if(ordinal == -1)
return null;
return api.getMovie(ordinal);
}
} | 2,381 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/index/MovieAPIHashIndex.java | package how.hollow.consumer.api.generated.index;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Movie;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.core.index.HollowHashIndexResult;
import java.util.Collections;
import java.lang.Iterable;
import com.netflix.hollow.api.consumer.index.AbstractHollowHashIndex;
import com.netflix.hollow.api.consumer.data.AbstractHollowOrdinalIterable;
/**
* @deprecated see {@link com.netflix.hollow.api.consumer.index.HashIndex} which can be built as follows:
* <pre>{@code
* HashIndex<HString, K> uki = HashIndex.from(consumer, HString.class)
* .usingBean(k);
* Stream<HString> results = uki.findMatches(k);
* }</pre>
* where {@code K} is a class declaring key field paths members, annotated with
* {@link com.netflix.hollow.api.consumer.index.FieldPath}, and {@code k} is an instance of
* {@code K} that is the query to find the matching {@code HString} objects.
*/
@Deprecated
@SuppressWarnings("all")
public class MovieAPIHashIndex extends AbstractHollowHashIndex<MovieAPI> {
public MovieAPIHashIndex(HollowConsumer consumer, String queryType, String selectFieldPath, String... matchFieldPaths) {
super(consumer, false, queryType, selectFieldPath, matchFieldPaths);
}
public MovieAPIHashIndex(HollowConsumer consumer, boolean isListenToDataRefresh, String queryType, String selectFieldPath, String... matchFieldPaths) {
super(consumer, isListenToDataRefresh, queryType, selectFieldPath, matchFieldPaths);
}
public Iterable<HString> findStringMatches(Object... keys) {
HollowHashIndexResult matches = idx.findMatches(keys);
if(matches == null) return Collections.emptySet();
return new AbstractHollowOrdinalIterable<HString>(matches.iterator()) {
public HString getData(int ordinal) {
return api.getHString(ordinal);
}
};
}
public Iterable<Actor> findActorMatches(Object... keys) {
HollowHashIndexResult matches = idx.findMatches(keys);
if(matches == null) return Collections.emptySet();
return new AbstractHollowOrdinalIterable<Actor>(matches.iterator()) {
public Actor getData(int ordinal) {
return api.getActor(ordinal);
}
};
}
public Iterable<SetOfActor> findSetOfActorMatches(Object... keys) {
HollowHashIndexResult matches = idx.findMatches(keys);
if(matches == null) return Collections.emptySet();
return new AbstractHollowOrdinalIterable<SetOfActor>(matches.iterator()) {
public SetOfActor getData(int ordinal) {
return api.getSetOfActor(ordinal);
}
};
}
public Iterable<Movie> findMovieMatches(Object... keys) {
HollowHashIndexResult matches = idx.findMatches(keys);
if(matches == null) return Collections.emptySet();
return new AbstractHollowOrdinalIterable<Movie>(matches.iterator()) {
public Movie getData(int ordinal) {
return api.getMovie(ordinal);
}
};
}
} | 2,382 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/index/ActorPrimaryKeyIndex.java | package how.hollow.consumer.api.generated.index;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.index.AbstractHollowUniqueKeyIndex;
import com.netflix.hollow.api.consumer.index.HollowUniqueKeyIndex;
import com.netflix.hollow.core.schema.HollowObjectSchema;
/**
* @deprecated see {@link com.netflix.hollow.api.consumer.index.UniqueKeyIndex} which can be created as follows:
* <pre>{@code
* UniqueKeyIndex<Actor, int> uki = Actor.uniqueIndex(consumer);
* int k = ...;
* Actor m = uki.findMatch(k);
* }</pre>
* @see Actor#uniqueIndex
*/
@Deprecated
@SuppressWarnings("all")
public class ActorPrimaryKeyIndex extends AbstractHollowUniqueKeyIndex<MovieAPI, Actor> {
public ActorPrimaryKeyIndex(HollowConsumer consumer) {
this(consumer, false);
}
public ActorPrimaryKeyIndex(HollowConsumer consumer, boolean isListenToDataRefresh) {
this(consumer, isListenToDataRefresh, ((HollowObjectSchema)consumer.getStateEngine().getNonNullSchema("Actor")).getPrimaryKey().getFieldPaths());
}
private ActorPrimaryKeyIndex(HollowConsumer consumer, String... fieldPaths) {
this(consumer, false, fieldPaths);
}
private ActorPrimaryKeyIndex(HollowConsumer consumer, boolean isListenToDataRefresh, String... fieldPaths) {
super(consumer, "Actor", isListenToDataRefresh, fieldPaths);
}
public Actor findMatch(int actorId) {
int ordinal = idx.getMatchingOrdinal(actorId);
if(ordinal == -1)
return null;
return api.getActor(ordinal);
}
} | 2,383 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/index/ActorUniqueKeyIndex.java | package how.hollow.consumer.api.generated.index;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.index.AbstractHollowUniqueKeyIndex;
import com.netflix.hollow.api.consumer.index.HollowUniqueKeyIndex;
/**
* @deprecated see {@link com.netflix.hollow.api.consumer.index.UniqueKeyIndex} which can be built as follows:
* <pre>{@code
* UniqueKeyIndex<Actor, K> uki = UniqueKeyIndex.from(consumer, Actor.class)
* .usingBean(k);
* Actor m = uki.findMatch(k);
* }</pre>
* where {@code K} is a class declaring key field paths members, annotated with
* {@link com.netflix.hollow.api.consumer.index.FieldPath}, and {@code k} is an instance of
* {@code K} that is the key to find the unique {@code Actor} object.
*/
@Deprecated
@SuppressWarnings("all")
public class ActorUniqueKeyIndex extends AbstractHollowUniqueKeyIndex<MovieAPI, Actor> implements HollowUniqueKeyIndex<Actor> {
public ActorUniqueKeyIndex(HollowConsumer consumer, String... fieldPaths) {
this(consumer, false, fieldPaths);
}
public ActorUniqueKeyIndex(HollowConsumer consumer, boolean isListenToDataRefresh, String... fieldPaths) {
super(consumer, "Actor", isListenToDataRefresh, fieldPaths);
}
@Override
public Actor findMatch(Object... keys) {
int ordinal = idx.getMatchingOrdinal(keys);
if(ordinal == -1)
return null;
return api.getActor(ordinal);
}
} | 2,384 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/index/MoviePrimaryKeyIndex.java | package how.hollow.consumer.api.generated.index;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Movie;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.index.AbstractHollowUniqueKeyIndex;
import com.netflix.hollow.api.consumer.index.HollowUniqueKeyIndex;
import com.netflix.hollow.core.schema.HollowObjectSchema;
/**
* @deprecated see {@link com.netflix.hollow.api.consumer.index.UniqueKeyIndex} which can be created as follows:
* <pre>{@code
* UniqueKeyIndex<Movie, int> uki = Movie.uniqueIndex(consumer);
* int k = ...;
* Movie m = uki.findMatch(k);
* }</pre>
* @see Movie#uniqueIndex
*/
@Deprecated
@SuppressWarnings("all")
public class MoviePrimaryKeyIndex extends AbstractHollowUniqueKeyIndex<MovieAPI, Movie> {
public MoviePrimaryKeyIndex(HollowConsumer consumer) {
this(consumer, false);
}
public MoviePrimaryKeyIndex(HollowConsumer consumer, boolean isListenToDataRefresh) {
this(consumer, isListenToDataRefresh, ((HollowObjectSchema)consumer.getStateEngine().getNonNullSchema("Movie")).getPrimaryKey().getFieldPaths());
}
private MoviePrimaryKeyIndex(HollowConsumer consumer, String... fieldPaths) {
this(consumer, false, fieldPaths);
}
private MoviePrimaryKeyIndex(HollowConsumer consumer, boolean isListenToDataRefresh, String... fieldPaths) {
super(consumer, "Movie", isListenToDataRefresh, fieldPaths);
}
public Movie findMatch(int id) {
int ordinal = idx.getMatchingOrdinal(id);
if(ordinal == -1)
return null;
return api.getMovie(ordinal);
}
} | 2,385 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/api/generated/collections/SetOfActor.java | package how.hollow.consumer.api.generated.collections;
import com.netflix.hollow.core.type.*;
import how.hollow.consumer.api.generated.MovieAPI;
import how.hollow.consumer.api.generated.Actor;
import how.hollow.consumer.api.generated.core.*;
import how.hollow.consumer.api.generated.collections.*;
import com.netflix.hollow.api.objects.HollowSet;
import com.netflix.hollow.core.schema.HollowSetSchema;
import com.netflix.hollow.api.objects.delegate.HollowSetDelegate;
import com.netflix.hollow.api.objects.generic.GenericHollowRecordHelper;
@SuppressWarnings("all")
public class SetOfActor extends HollowSet<Actor> {
public SetOfActor(HollowSetDelegate delegate, int ordinal) {
super(delegate, ordinal);
}
@Override
public Actor instantiateElement(int ordinal) {
return (Actor) api().getActor(ordinal);
}
@Override
public boolean equalsElement(int elementOrdinal, Object testObject) {
return GenericHollowRecordHelper.equalObject(getSchema().getElementType(), elementOrdinal, testObject);
}
public MovieAPI api() {
return typeApi().getAPI();
}
public SetOfActorTypeAPI typeApi() {
return (SetOfActorTypeAPI) delegate.getTypeAPI();
}
} | 2,386 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/infrastructure/S3BlobRetriever.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.consumer.infrastructure;
import com.amazonaws.SdkBaseException;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.transfer.Download;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.netflix.hollow.api.consumer.HollowConsumer.Blob;
import com.netflix.hollow.api.consumer.HollowConsumer.BlobRetriever;
import com.netflix.hollow.core.memory.encoding.VarInt;
import how.hollow.producer.infrastructure.S3Publisher;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class S3BlobRetriever implements BlobRetriever {
private final AmazonS3 s3;
private final TransferManager s3TransferManager;
private final String bucketName;
private final String blobNamespace;
public S3BlobRetriever(AWSCredentials credentials, String bucketName, String blobNamespace) {
this.s3 = new AmazonS3Client(credentials);
this.s3TransferManager = new TransferManager(s3);
this.bucketName = bucketName;
this.blobNamespace = blobNamespace;
}
@Override
public Blob retrieveSnapshotBlob(long desiredVersion) {
try {
return knownSnapshotBlob(desiredVersion);
} catch (AmazonS3Exception transitionNotFound) { }
/// There was no exact match for a snapshot leading to the desired state.
/// We'll use the snapshot index to find the nearest one before the desired state.
try {
File f = downloadFile(S3Publisher.getSnapshotIndexObjectName(blobNamespace));
long snapshotIdxLength = f.length();
long pos = 0;
long currentSnapshotStateId = 0;
try(InputStream is = new BufferedInputStream(new FileInputStream(f))) {
while(pos < snapshotIdxLength) {
long nextGap = VarInt.readVLong(is);
if(currentSnapshotStateId + nextGap > desiredVersion) {
if(currentSnapshotStateId == 0)
return null;
return knownSnapshotBlob(currentSnapshotStateId);
}
currentSnapshotStateId += nextGap;
pos += VarInt.sizeOfVLong(nextGap);
}
if(currentSnapshotStateId != 0)
return knownSnapshotBlob(currentSnapshotStateId);
}
} catch(IOException e) {
throw new RuntimeException(e);
}
return null;
}
@Override
public Blob retrieveDeltaBlob(long currentVersion) {
try {
return knownDeltaBlob("delta", currentVersion);
} catch (AmazonS3Exception transitionNotFound) {
return null;
}
}
@Override
public Blob retrieveReverseDeltaBlob(long currentVersion) {
try {
return knownDeltaBlob("reversedelta", currentVersion);
} catch (AmazonS3Exception transitionNotFound) {
return null;
}
}
private Blob knownSnapshotBlob(long desiredVersion) {
String objectName = S3Publisher.getS3ObjectName(blobNamespace, "snapshot", desiredVersion);
ObjectMetadata objectMetadata = s3.getObjectMetadata(bucketName, objectName);
long toState = Long.parseLong(objectMetadata.getUserMetaDataOf("to_state"));
return new S3Blob(objectName, toState);
}
private Blob knownDeltaBlob(String fileType, long fromVersion) {
String objectName = S3Publisher.getS3ObjectName(blobNamespace, fileType, fromVersion);
ObjectMetadata objectMetadata = s3.getObjectMetadata(bucketName, objectName);
long fromState = Long.parseLong(objectMetadata.getUserMetaDataOf("from_state"));
long toState = Long.parseLong(objectMetadata.getUserMetaDataOf("to_state"));
return new S3Blob(objectName, fromState, toState);
}
private class S3Blob extends Blob {
private final String objectName;
public S3Blob(String objectName, long toVersion) {
super(toVersion);
this.objectName = objectName;
}
public S3Blob(String objectName, long fromVersion, long toVersion) {
super(fromVersion, toVersion);
this.objectName = objectName;
}
@Override
public InputStream getInputStream() throws IOException {
final File tempFile = downloadFile(objectName);
return new BufferedInputStream(new FileInputStream(tempFile)) {
@Override
public void close() throws IOException {
super.close();
tempFile.delete();
}
};
}
}
private File downloadFile(String objectName) throws IOException {
File tempFile = new File(System.getProperty("java.io.tmpdir"), objectName.replace('/', '-'));
Download download = s3TransferManager.download(bucketName, objectName, tempFile);
try {
download.waitForCompletion();
} catch(SdkBaseException | InterruptedException e) {
throw new RuntimeException(e);
}
return tempFile;
}
}
| 2,387 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/infrastructure/S3AnnouncementWatcher.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.consumer.infrastructure;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3Client;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.HollowConsumer.AnnouncementWatcher;
import how.hollow.producer.infrastructure.S3Announcer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class S3AnnouncementWatcher implements AnnouncementWatcher {
private final AmazonS3 s3;
private final String bucketName;
private final String blobNamespace;
private final List<HollowConsumer> subscribedConsumers;
private long latestVersion;
public S3AnnouncementWatcher(AWSCredentials credentials, String bucketName, String blobNamespace) {
this.s3 = new AmazonS3Client(credentials);
this.bucketName = bucketName;
this.blobNamespace = blobNamespace;
this.subscribedConsumers = Collections.synchronizedList(new ArrayList<HollowConsumer>());
this.latestVersion = readLatestVersion();
setupPollingThread();
}
public void setupPollingThread() {
Thread t = new Thread(new Runnable() {
public void run() {
while(true) {
try {
long currentVersion = readLatestVersion();
if(latestVersion != currentVersion) {
latestVersion = currentVersion;
for(HollowConsumer consumer : subscribedConsumers)
consumer.triggerAsyncRefresh();
}
Thread.sleep(1000);
} catch(Throwable th) {
th.printStackTrace();
}
}
}
});
t.setName("hollow-s3-announcementwatcher-poller");
t.setDaemon(true);
t.start();
}
@Override
public long getLatestVersion() {
return latestVersion;
}
@Override
public void subscribeToUpdates(HollowConsumer consumer) {
subscribedConsumers.add(consumer);
}
private long readLatestVersion() {
return Long.parseLong(s3.getObjectAsString(bucketName, blobNamespace + "/" + S3Announcer.ANNOUNCEMENT_OBJECTNAME));
}
}
| 2,388 |
0 | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer | Create_ds/hollow-reference-implementation/src/main/java/how/hollow/consumer/infrastructure/DynamoDBAnnouncementWatcher.java | /*
*
* Copyright 2016 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package how.hollow.consumer.infrastructure;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.netflix.hollow.api.consumer.HollowConsumer;
import com.netflix.hollow.api.consumer.HollowConsumer.AnnouncementWatcher;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class DynamoDBAnnouncementWatcher implements AnnouncementWatcher {
private final DynamoDB dynamoDB;
private final String tableName;
private final String blobNamespace;
private final List<HollowConsumer> subscribedConsumers;
private long latestVersion;
public DynamoDBAnnouncementWatcher(AWSCredentials credentials, String tableName, String blobNamespace) {
this.dynamoDB = new DynamoDB(new AmazonDynamoDBClient(credentials));
this.tableName = tableName;
this.blobNamespace = blobNamespace;
this.subscribedConsumers = Collections.synchronizedList(new ArrayList<HollowConsumer>());
this.latestVersion = readLatestVersion();
setupPollingThread();
}
public void setupPollingThread() {
Thread t = new Thread(new Runnable() {
public void run() {
while (true) {
try {
long currentVersion = readLatestVersion();
if (latestVersion != currentVersion) {
latestVersion = currentVersion;
for(HollowConsumer consumer : subscribedConsumers)
consumer.triggerAsyncRefresh();
}
Thread.sleep(1000);
} catch (Throwable th) {
th.printStackTrace();
}
}
}
});
t.setName("hollow-dynamodb-announcementwatcher-poller");
t.setDaemon(true);
t.start();
}
@Override
public long getLatestVersion() {
return latestVersion;
}
@Override
public void subscribeToUpdates(HollowConsumer consumer) {
subscribedConsumers.add(consumer);
}
public long readLatestVersion() {
Table table = dynamoDB.getTable(tableName);
Item item = table.getItem("namespace", blobNamespace,
"version, pin_version", null);
if (item.isPresent("pin_version") && !item.isNull("pin_version"))
return item.getLong("pin_version");
return item.getLong("version");
}
}
| 2,389 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/LottieDrawableTest.java | package com.airbnb.lottie;
import android.animation.Animator;
import android.graphics.Rect;
import androidx.collection.LongSparseArray;
import androidx.collection.SparseArrayCompat;
import com.airbnb.lottie.model.Font;
import com.airbnb.lottie.model.FontCharacter;
import com.airbnb.lottie.model.Marker;
import com.airbnb.lottie.model.layer.Layer;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import static junit.framework.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.verify;
public class LottieDrawableTest extends BaseTest {
@Mock Animator.AnimatorListener animatorListener;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}
@SuppressWarnings("SameParameterValue")
private LottieComposition createComposition(int startFrame, int endFrame) {
LottieComposition composition = new LottieComposition();
composition.init(new Rect(), startFrame, endFrame, 1000, new ArrayList<Layer>(),
new LongSparseArray<Layer>(0), new HashMap<String, List<Layer>>(0),
new HashMap<String, LottieImageAsset>(0), new SparseArrayCompat<FontCharacter>(0),
new HashMap<String, Font>(0), new ArrayList<Marker>());
return composition;
}
@Test
public void testMinFrame() {
LottieComposition composition = createComposition(31, 391);
LottieDrawable drawable = new LottieDrawable();
drawable.setComposition(composition);
drawable.setMinProgress(0.42f);
assertEquals(182f, drawable.getMinFrame());
}
@Test
public void testMinWithStartFrameFrame() {
LottieComposition composition = createComposition(100, 200);
LottieDrawable drawable = new LottieDrawable();
drawable.setComposition(composition);
drawable.setMinProgress(0.5f);
assertEquals(150f, drawable.getMinFrame());
}
@Test
public void testMaxFrame() {
LottieComposition composition = createComposition(31, 391);
LottieDrawable drawable = new LottieDrawable();
drawable.setComposition(composition);
drawable.setMaxProgress(0.25f);
assertEquals(121f, drawable.getMaxFrame());
}
@Test
public void testMinMaxFrame() {
LottieComposition composition = createComposition(31, 391);
LottieDrawable drawable = new LottieDrawable();
drawable.setComposition(composition);
drawable.setMinAndMaxProgress(0.25f, 0.42f);
assertEquals(121f, drawable.getMinFrame());
assertEquals(182.99f, drawable.getMaxFrame());
}
@Test
public void testPlayWhenSystemAnimationDisabled() {
LottieComposition composition = createComposition(31, 391);
LottieDrawable drawable = new LottieDrawable();
drawable.addAnimatorListener(animatorListener);
drawable.setSystemAnimationsAreEnabled(false);
drawable.setComposition(composition);
drawable.playAnimation();
assertEquals(391, drawable.getFrame());
verify(animatorListener, atLeastOnce()).onAnimationEnd(any(Animator.class), eq(false));
}
@Test
public void testResumeWhenSystemAnimationDisabled() {
LottieComposition composition = createComposition(31, 391);
LottieDrawable drawable = new LottieDrawable();
drawable.addAnimatorListener(animatorListener);
drawable.setSystemAnimationsAreEnabled(false);
drawable.setComposition(composition);
drawable.resumeAnimation();
assertEquals(391, drawable.getFrame());
verify(animatorListener, atLeastOnce()).onAnimationEnd(any(Animator.class), eq(false));
}
}
| 2,390 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/BaseTest.java | package com.airbnb.lottie;
import android.os.Build;
import org.junit.Ignore;
import org.junit.runner.RunWith;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
@RunWith(RobolectricTestRunner.class)
@Config(sdk = Build.VERSION_CODES.P)
@Ignore("Base Test")
public class BaseTest {
}
| 2,391 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/LottieValueAnimatorUnitTest.java | package com.airbnb.lottie;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.graphics.Rect;
import androidx.collection.LongSparseArray;
import androidx.collection.SparseArrayCompat;
import com.airbnb.lottie.model.Font;
import com.airbnb.lottie.model.FontCharacter;
import com.airbnb.lottie.model.Marker;
import com.airbnb.lottie.model.layer.Layer;
import com.airbnb.lottie.utils.LottieValueAnimator;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.mockito.Mockito;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import static junit.framework.Assert.assertEquals;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.times;
public class LottieValueAnimatorUnitTest extends BaseTest {
private interface VerifyListener {
void verify(InOrder inOrder);
}
private LottieComposition composition;
private LottieValueAnimator animator;
private Animator.AnimatorListener spyListener;
private InOrder inOrder;
private AtomicBoolean isDone;
@Before
public void setup() {
animator = createAnimator();
composition = createComposition(0, 1000);
animator.setComposition(composition);
spyListener = Mockito.mock(Animator.AnimatorListener.class);
isDone = new AtomicBoolean(false);
}
private LottieValueAnimator createAnimator() {
// Choreographer#postFrameCallback hangs with robolectric.
return new LottieValueAnimator() {
@Override public void postFrameCallback() {
running = true;
}
@Override public void removeFrameCallback() {
running = false;
}
};
}
private LottieComposition createComposition(int startFrame, int endFrame) {
LottieComposition composition = new LottieComposition();
composition.init(new Rect(), startFrame, endFrame, 1000, new ArrayList<Layer>(),
new LongSparseArray<Layer>(0), new HashMap<String, List<Layer>>(0),
new HashMap<String, LottieImageAsset>(0), new SparseArrayCompat<FontCharacter>(0),
new HashMap<String, Font>(0), new ArrayList<Marker>());
return composition;
}
@Test
public void testInitialState() {
assertClose(0f, animator.getFrame());
}
@Test
public void testResumingMaintainsValue() {
animator.setFrame(500);
animator.resumeAnimation();
assertClose(500f, animator.getFrame());
}
@Test
public void testFrameConvertsToAnimatedFraction() {
animator.setFrame(500);
animator.resumeAnimation();
assertClose(0.5f, animator.getAnimatedFraction());
assertClose(0.5f, animator.getAnimatedValueAbsolute());
}
@Test
public void testPlayingResetsValue() {
animator.setFrame(500);
animator.playAnimation();
assertClose(0f, animator.getFrame());
assertClose(0f, animator.getAnimatedFraction());
}
@Test
public void testReversingMaintainsValue() {
animator.setFrame(250);
animator.reverseAnimationSpeed();
assertClose(250f, animator.getFrame());
assertClose(0.75f, animator.getAnimatedFraction());
assertClose(0.25f, animator.getAnimatedValueAbsolute());
}
@Test
public void testReversingWithMinValueMaintainsValue() {
animator.setMinFrame(100);
animator.setFrame(1000);
animator.reverseAnimationSpeed();
assertClose(1000f, animator.getFrame());
assertClose(0f, animator.getAnimatedFraction());
assertClose(1f, animator.getAnimatedValueAbsolute());
}
@Test
public void testReversingWithMaxValueMaintainsValue() {
animator.setMaxFrame(900);
animator.reverseAnimationSpeed();
assertClose(0f, animator.getFrame());
assertClose(1f, animator.getAnimatedFraction());
assertClose(0f, animator.getAnimatedValueAbsolute());
}
@Test
public void testResumeReversingWithMinValueMaintainsValue() {
animator.setMaxFrame(900);
animator.reverseAnimationSpeed();
animator.resumeAnimation();
assertClose(900f, animator.getFrame());
assertClose(0f, animator.getAnimatedFraction());
assertClose(0.9f, animator.getAnimatedValueAbsolute());
}
@Test
public void testPlayReversingWithMinValueMaintainsValue() {
animator.setMaxFrame(900);
animator.reverseAnimationSpeed();
animator.playAnimation();
assertClose(900f, animator.getFrame());
assertClose(0f, animator.getAnimatedFraction());
assertClose(0.9f, animator.getAnimatedValueAbsolute());
}
@Test
public void testMinAndMaxBothSet() {
animator.setMinFrame(200);
animator.setMaxFrame(800);
animator.setFrame(400);
assertClose(0.33333f, animator.getAnimatedFraction());
assertClose(0.4f, animator.getAnimatedValueAbsolute());
animator.reverseAnimationSpeed();
assertClose(400f, animator.getFrame());
assertClose(0.66666f, animator.getAnimatedFraction());
assertClose(0.4f, animator.getAnimatedValueAbsolute());
animator.resumeAnimation();
assertClose(400f, animator.getFrame());
assertClose(0.66666f, animator.getAnimatedFraction());
assertClose(0.4f, animator.getAnimatedValueAbsolute());
animator.playAnimation();
assertClose(800f, animator.getFrame());
assertClose(0f, animator.getAnimatedFraction());
assertClose(0.8f, animator.getAnimatedValueAbsolute());
}
@Test
public void testSetFrameIntegrity() {
animator.setMinAndMaxFrames(200, 800);
// setFrame < minFrame should clamp to minFrame
animator.setFrame(100);
assertEquals(200f, animator.getFrame());
animator.setFrame(900);
assertEquals(800f, animator.getFrame());
}
@Test(expected = IllegalArgumentException.class)
public void testMinAndMaxFrameIntegrity() {
animator.setMinAndMaxFrames(800, 200);
}
@Test
public void testDefaultAnimator() {
testAnimator(new VerifyListener() {
@Override public void verify(InOrder inOrder) {
inOrder.verify(spyListener, times(1)).onAnimationStart(animator, false);
inOrder.verify(spyListener, times(1)).onAnimationEnd(animator, false);
Mockito.verify(spyListener, times(0)).onAnimationCancel(animator);
Mockito.verify(spyListener, times(0)).onAnimationRepeat(animator);
}
});
}
@Test
public void testReverseAnimator() {
animator.reverseAnimationSpeed();
testAnimator(new VerifyListener() {
@Override public void verify(InOrder inOrder) {
inOrder.verify(spyListener, times(1)).onAnimationStart(animator, true);
inOrder.verify(spyListener, times(1)).onAnimationEnd(animator, true);
Mockito.verify(spyListener, times(0)).onAnimationCancel(animator);
Mockito.verify(spyListener, times(0)).onAnimationRepeat(animator);
}
});
}
@Test
public void testLoopingAnimatorOnce() {
animator.setRepeatCount(1);
testAnimator(new VerifyListener() {
@Override public void verify(InOrder inOrder) {
Mockito.verify(spyListener, times(1)).onAnimationStart(animator, false);
Mockito.verify(spyListener, times(1)).onAnimationRepeat(animator);
Mockito.verify(spyListener, times(1)).onAnimationEnd(animator, false);
Mockito.verify(spyListener, times(0)).onAnimationCancel(animator);
}
});
}
@Test
public void testLoopingAnimatorZeroTimes() {
animator.setRepeatCount(0);
testAnimator(new VerifyListener() {
@Override public void verify(InOrder inOrder) {
Mockito.verify(spyListener, times(1)).onAnimationStart(animator, false);
Mockito.verify(spyListener, times(0)).onAnimationRepeat(animator);
Mockito.verify(spyListener, times(1)).onAnimationEnd(animator, false);
Mockito.verify(spyListener, times(0)).onAnimationCancel(animator);
}
});
}
@Test
public void testLoopingAnimatorTwice() {
animator.setRepeatCount(2);
testAnimator(new VerifyListener() {
@Override public void verify(InOrder inOrder) {
Mockito.verify(spyListener, times(1)).onAnimationStart(animator, false);
Mockito.verify(spyListener, times(2)).onAnimationRepeat(animator);
Mockito.verify(spyListener, times(1)).onAnimationEnd(animator, false);
Mockito.verify(spyListener, times(0)).onAnimationCancel(animator);
}
});
}
@Test
public void testLoopingAnimatorOnceReverse() {
animator.setFrame(1000);
animator.setRepeatCount(1);
animator.reverseAnimationSpeed();
testAnimator(new VerifyListener() {
@Override public void verify(InOrder inOrder) {
inOrder.verify(spyListener, times(1)).onAnimationStart(animator, true);
inOrder.verify(spyListener, times(1)).onAnimationRepeat(animator);
inOrder.verify(spyListener, times(1)).onAnimationEnd(animator, true);
Mockito.verify(spyListener, times(0)).onAnimationCancel(animator);
}
});
}
@Test
public void setMinFrameSmallerThanComposition() {
animator.setMinFrame(-9000);
assertClose(animator.getMinFrame(), composition.getStartFrame());
}
@Test
public void setMaxFrameLargerThanComposition() {
animator.setMaxFrame(9000);
assertClose(animator.getMaxFrame(), composition.getEndFrame());
}
@Test
public void setMinFrameBeforeComposition() {
LottieValueAnimator animator = createAnimator();
animator.setMinFrame(100);
animator.setComposition(composition);
assertClose(100.0f, animator.getMinFrame());
}
@Test
public void setMaxFrameBeforeComposition() {
LottieValueAnimator animator = createAnimator();
animator.setMaxFrame(100);
animator.setComposition(composition);
assertClose(100.0f, animator.getMaxFrame());
}
@Test
public void setMinAndMaxFrameBeforeComposition() {
LottieValueAnimator animator = createAnimator();
animator.setMinAndMaxFrames(100, 900);
animator.setComposition(composition);
assertClose(100.0f, animator.getMinFrame());
assertClose(900.0f, animator.getMaxFrame());
}
@Test
public void setMinFrameAfterComposition() {
LottieValueAnimator animator = createAnimator();
animator.setComposition(composition);
animator.setMinFrame(100);
assertClose(100.0f, animator.getMinFrame());
}
@Test
public void setMaxFrameAfterComposition() {
LottieValueAnimator animator = createAnimator();
animator.setComposition(composition);
animator.setMaxFrame(100);
assertEquals(100.0f, animator.getMaxFrame());
}
@Test
public void setMinAndMaxFrameAfterComposition() {
LottieValueAnimator animator = createAnimator();
animator.setComposition(composition);
animator.setMinAndMaxFrames(100, 900);
assertClose(100.0f, animator.getMinFrame());
assertClose(900.0f, animator.getMaxFrame());
}
@Test
public void maxFrameOfNewShorterComposition() {
LottieValueAnimator animator = createAnimator();
animator.setComposition(composition);
LottieComposition composition2 = createComposition(0, 500);
animator.setComposition(composition2);
assertClose(500.0f, animator.getMaxFrame());
}
@Test
public void maxFrameOfNewLongerComposition() {
LottieValueAnimator animator = createAnimator();
animator.setComposition(composition);
LottieComposition composition2 = createComposition(0, 1500);
animator.setComposition(composition2);
assertClose(1500.0f, animator.getMaxFrame());
}
@Test
public void clearComposition() {
animator.clearComposition();
assertClose(0.0f, animator.getMaxFrame());
assertClose(0.0f, animator.getMinFrame());
}
@Test
public void resetComposition() {
animator.clearComposition();
animator.setComposition(composition);
assertClose(0.0f, animator.getMinFrame());
assertClose(1000.0f, animator.getMaxFrame());
}
@Test
public void resetAndSetMinBeforeComposition() {
animator.clearComposition();
animator.setMinFrame(100);
animator.setComposition(composition);
assertClose(100.0f, animator.getMinFrame());
assertClose(1000.0f, animator.getMaxFrame());
}
@Test
public void resetAndSetMinAterComposition() {
animator.clearComposition();
animator.setComposition(composition);
animator.setMinFrame(100);
assertClose(100.0f, animator.getMinFrame());
assertClose(1000.0f, animator.getMaxFrame());
}
private void testAnimator(final VerifyListener verifyListener) {
spyListener = Mockito.spy(new AnimatorListenerAdapter() {
@Override public void onAnimationEnd(Animator animation) {
verifyListener.verify(inOrder);
isDone.set(true);
}
});
inOrder = inOrder(spyListener);
animator.addListener(spyListener);
animator.playAnimation();
while (!isDone.get()) {
animator.doFrame(System.nanoTime());
}
}
/**
* Animations don't render on the out frame so if an animation is 1000 frames, the actual end will be 999.99. This causes
* actual fractions to be something like .74999 when you might expect 75.
*/
private static void assertClose(float expected, float actual) {
assertEquals(expected, actual, expected * 0.01f);
}
}
| 2,392 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/KeyPathTest.java | package com.airbnb.lottie;
import com.airbnb.lottie.model.KeyPath;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
import static junit.framework.Assert.assertEquals;
public class KeyPathTest extends BaseTest {
private static final String[] V = {
"Shape Layer 1",
"Group 1",
"Rectangle",
"Stroke"
};
private static final String I = "INVALID";
private static final String W = "*";
private static final String G = "**";
private LottieDrawable lottieDrawable;
@Before
public void setupDrawable() {
lottieDrawable = new LottieDrawable();
LottieComposition composition = LottieCompositionFactory.fromJsonStringSync(Fixtures.SQUARES, "squares").getValue();
lottieDrawable.setComposition(composition);
}
//<editor-fold desc="Basic Tests">
@Test public void testV() { assertSize(1, V[0]); }
@Test public void testI() { assertSize(0, I); }
@Test public void testII() { assertSize(0, I, I); }
@Test public void testIV() { assertSize(0, I, V[1]); }
@Test public void testVI() { assertSize(0, V[0], I); }
@Test public void testVV() { assertSize(1, V[0], V[1]); }
@Test public void testIII() { assertSize(0, I, I, I); }
@Test public void testIIV() { assertSize(0, I, I, V[3]); }
@Test public void testIVI() { assertSize(0, I, V[2], I); }
@Test public void testIVV() { assertSize(0, I, V[2], V[3]); }
@Test public void testVII() { assertSize(0, V[0], I, I); }
@Test public void testVIV() { assertSize(0, V[0], I, V[2]); }
@Test public void testVVI() { assertSize(0, V[0], V[1], I); }
@Test public void testVVV() { assertSize(1, V[0], V[1], V[2]); }
@Test public void testIIII() { assertSize(0, I, I, I, I); }
@Test public void testIIIV() { assertSize(0, I, I, I, V[3]); }
@Test public void testIIVI() { assertSize(0, I, I, V[2], I); }
@Test public void testIIVV() { assertSize(0, I, I, V[2], V[3]); }
@Test public void testIVII() { assertSize(0, I, V[1], I, I); }
@Test public void testIVIV() { assertSize(0, I, V[1], I, V[3]); }
@Test public void testIVVI() { assertSize(0, I, V[1], V[2], V[3]); }
@Test public void testIVVV() { assertSize(0, I, V[1], V[2], V[3]); }
@Test public void testVIII() { assertSize(0, V[0], I, I, I); }
@Test public void testVIIV() { assertSize(0, V[0], I, I, V[3]); }
@Test public void testVIVI() { assertSize(0, V[0], I, V[2], I); }
@Test public void testVIVV() { assertSize(0, V[0], I, V[2], V[3]); }
@Test public void testVVII() { assertSize(0, V[0], V[1], I, I); }
@Test public void testVVIV() { assertSize(0, V[0], V[1], I, V[3]); }
@Test public void testVVVI() { assertSize(0, V[0], V[1], V[2], I); }
@Test public void testVVVV() { assertSize(1, V[0], V[1], V[2], V[3]); }
//</editor-fold>
//<editor-fold desc="One Wildcard">
@Test public void testWVVV() { assertSize(2, W, V[1], V[2], V[3]); }
@Test public void testVWVV() { assertSize(2, V[0], W, V[2], V[3]); }
@Test public void testVVWV() { assertSize(1, V[0], V[1], W, V[3]); }
@Test public void testVVVW() { assertSize(2, V[0], V[1], V[2], W); }
//</editor-fold>
//<editor-fold desc="Two Wildcards">
@Test public void testWWVV() { assertSize(4, W, W, V[2], V[3]); }
@Test public void testWVWV() { assertSize(2, W, V[1], W, V[3]); }
@Test public void testWVVW() { assertSize(4, W, V[1], V[2], W); }
@Test public void testWWIV() { assertSize(0, W, W, I, V[3]); }
@Test public void testWWVI() { assertSize(0, W, W, V[2], I); }
@Test public void testWVW() { assertSize(2, W, V[1], W); }
//</editor-fold>
//<editor-fold desc="Three Wildcards">
@Test public void testWWW() { assertSize(4, W, W, W); }
@Test public void testWWWV() { assertSize(4, W, W, W, V[3]); }
@Test public void testWWWI() { assertSize(0, W, W, W, I); }
//</editor-fold>
//<editor-fold desc="Four Wildcards">
@Test public void testWWWW() { assertSize(8, W, W, W, W); }
//</editor-fold>
//<editor-fold desc="One Globstar">
@Test public void testG() { assertSize(18, G); }
@Test public void testGI() { assertSize(0, G, I); }
@Test public void testGV0() { assertSize(1, G, V[0]); }
@Test public void testGV0V0() { assertSize(0, G, V[0], V[0]); }
@Test public void testGV1() { assertSize(2, G, V[1]); }
@Test public void testGV2() { assertSize(4, G, V[2]); }
@Test public void testGV3() { assertSize(4, G, V[3]); }
//</editor-fold>
//<editor-fold desc="Two Globstars">
@Test public void testGV0G() { assertSize(9, G, V[0], G); }
@Test public void testGV1G() { assertSize(8, G, V[1], G); }
@Test public void testGV2G() { assertSize(12, G, V[2], G); }
@Test public void testGIG() { assertSize(0, G, I, G); }
//</editor-fold>
//<editor-fold desc="Wildcard and Globstar">
@Test public void testWG() { assertSize(18, W, G); }
@Test public void testGV0W() { assertSize(2, G, V[0], W); }
@Test public void testWV0I() { assertSize(0, W, V[0], I); }
@Test public void testGV1W() { assertSize(2, G, V[1], W); }
@Test public void testWV1I() { assertSize(0, W, V[1], I); }
@Test public void testGV2W() { assertSize(8, G, V[2], W); }
@Test public void testWV2I() { assertSize(0, W, V[2], I); }
//</editor-fold>
private void assertSize(int size, String... keys) {
KeyPath keyPath = new KeyPath(keys);
List<KeyPath> resolvedKeyPaths = lottieDrawable.resolveKeyPath(keyPath);
assertEquals(size, resolvedKeyPaths.size());
}
}
| 2,393 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/LottieCompositionTest.java | package com.airbnb.lottie;
import static junit.framework.TestCase.assertEquals;
import org.junit.Test;
public class LottieCompositionTest extends BaseTest {
private static final String JSON = "{\"v\":\"4.11.1\",\"fr\":60,\"ip\":0,\"op\":180,\"w\":300,\"h\":300,\"nm\":\"Comp 1\",\"ddd\":0,\"assets\":[]," +
"\"layers\":[{\"ddd\":0,\"ind\":1,\"ty\":4,\"nm\":\"Shape Layer 1\",\"sr\":1,\"ks\":{\"o\":{\"a\":0,\"k\":100,\"ix\":11},\"r\":{\"a\":0," +
"\"k\":0,\"ix\":10},\"p\":{\"a\":0,\"k\":[150,150,0],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100,100]," +
"\"ix\":6}},\"ao\":0,\"shapes\":[{\"ty\":\"rc\",\"d\":1,\"s\":{\"a\":0,\"k\":[100,100],\"ix\":2},\"p\":{\"a\":0,\"k\":[0,0],\"ix\":3}," +
"\"r\":{\"a\":0,\"k\":0,\"ix\":4},\"nm\":\"Rectangle Path 1\",\"mn\":\"ADBE Vector Shape - Rect\",\"hd\":false},{\"ty\":\"fl\"," +
"\"c\":{\"a\":0,\"k\":[0.928262987324,0,0,1],\"ix\":4},\"o\":{\"a\":0,\"k\":100,\"ix\":5},\"r\":1,\"nm\":\"Fill 1\",\"mn\":\"ADBE Vector " +
"Graphic - Fill\",\"hd\":false}],\"ip\":0,\"op\":180,\"st\":0,\"bm\":0}]}";
@Test
public void testGetFrameForProgress() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromJsonStringSync(JSON, null);
//noinspection ConstantConditions
assertEquals(66.59f, result.getValue().getFrameForProgress(0.37f), 0.01f);
}
@Test
public void testGetProgressForFrame() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromJsonStringSync(JSON, null);
//noinspection ConstantConditions
assertEquals(0.5f, result.getValue().getProgressForFrame(90), 0.01f);
}
}
| 2,394 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/Fixtures.java | package com.airbnb.lottie;
class Fixtures {
static final String SQUARES = "{\"v\":\"4.11.1\",\"fr\":29.9700012207031,\"ip\":0," +
"\"op\":61.0000024845809,\"w\":600,\"h\":300,\"nm\":\"Squares\",\"ddd\":0,\"assets\":[]," +
"\"layers\":[{\"ddd\":0,\"ind\":1,\"ty\":4,\"nm\":\"Shape Layer 1\",\"sr\":1," +
"\"ks\":{\"o\":{\"a\":0,\"k\":100,\"ix\":11},\"r\":{\"a\":0,\"k\":0,\"ix\":10}," +
"\"p\":{\"a\":0,\"k\":[300,150,0],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0,0],\"ix\":1}," +
"\"s\":{\"a\":0,\"k\":[100,100,100],\"ix\":6}},\"ao\":0,\"shapes\":[{\"ty\":\"gr\"," +
"\"it\":[{\"ty\":\"gr\",\"it\":[{\"ty\":\"rc\",\"d\":1,\"s\":{\"a\":0,\"k\":[50,50]," +
"\"ix\":2},\"p\":{\"a\":0,\"k\":[0,0],\"ix\":3},\"r\":{\"a\":0,\"k\":0,\"ix\":4}," +
"\"nm\":\"Rectangle Path 1\",\"mn\":\"ADBE Vector Shape - Rect\",\"hd\":false}," +
"{\"ty\":\"st\",\"c\":{\"a\":0,\"k\":[1,0,0,1],\"ix\":3},\"o\":{\"a\":0,\"k\":100," +
"\"ix\":4},\"w\":{\"a\":0,\"k\":11,\"ix\":5},\"lc\":1,\"lj\":1,\"ml\":4,\"nm\":\"Stroke\"," +
"\"mn\":\"ADBE Vector Graphic - Stroke\",\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0," +
"\"k\":[-40,-40],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100," +
"100],\"ix\":3},\"r\":{\"a\":1,\"k\":[{\"i\":{\"x\":[0.833],\"y\":[0.833]}," +
"\"o\":{\"x\":[0.167],\"y\":[0.167]},\"n\":[\"0p833_0p833_0p167_0p167\"],\"t\":0,\"s\":[0]," +
"\"e\":[360]},{\"t\":60.0000024438501}],\"ix\":6},\"o\":{\"a\":0,\"k\":100,\"ix\":7}," +
"\"sk\":{\"a\":0,\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5}," +
"\"nm\":\"Transform\"}],\"nm\":\"Rectangle\",\"np\":2,\"cix\":2,\"ix\":1,\"mn\":\"ADBE " +
"Vector Group\",\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0,\"k\":[0,0],\"ix\":2}," +
"\"a\":{\"a\":0,\"k\":[0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100],\"ix\":3}," +
"\"r\":{\"a\":0,\"k\":0,\"ix\":6},\"o\":{\"a\":0,\"k\":100,\"ix\":7},\"sk\":{\"a\":0," +
"\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5},\"nm\":\"Transform\"}],\"nm\":\"Group " +
"1\",\"np\":1,\"cix\":2,\"ix\":1,\"mn\":\"ADBE Vector Group\",\"hd\":false},{\"ty\":\"gr\"," +
"\"it\":[{\"ty\":\"gr\",\"it\":[{\"ty\":\"rc\",\"d\":1,\"s\":{\"a\":0,\"k\":[50,50]," +
"\"ix\":2},\"p\":{\"a\":0,\"k\":[0,0],\"ix\":3},\"r\":{\"a\":0,\"k\":0,\"ix\":4}," +
"\"nm\":\"Rectangle Path 1\",\"mn\":\"ADBE Vector Shape - Rect\",\"hd\":false}," +
"{\"ty\":\"st\",\"c\":{\"a\":0,\"k\":[1,0,0,1],\"ix\":3},\"o\":{\"a\":0,\"k\":100," +
"\"ix\":4},\"w\":{\"a\":0,\"k\":11,\"ix\":5},\"lc\":1,\"lj\":1,\"ml\":4,\"nm\":\"Stroke\"," +
"\"mn\":\"ADBE Vector Graphic - Stroke\",\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0," +
"\"k\":[40,-40],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100," +
"100],\"ix\":3},\"r\":{\"a\":1,\"k\":[{\"i\":{\"x\":[0.833],\"y\":[0.833]}," +
"\"o\":{\"x\":[0.167],\"y\":[0.167]},\"n\":[\"0p833_0p833_0p167_0p167\"],\"t\":0,\"s\":[0]," +
"\"e\":[360]},{\"t\":60.0000024438501}],\"ix\":6},\"o\":{\"a\":0,\"k\":100,\"ix\":7}," +
"\"sk\":{\"a\":0,\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5}," +
"\"nm\":\"Transform\"}],\"nm\":\"Rectangle\",\"np\":2,\"cix\":2,\"ix\":1,\"mn\":\"ADBE " +
"Vector Group\",\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0,\"k\":[0,0],\"ix\":2}," +
"\"a\":{\"a\":0,\"k\":[0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100],\"ix\":3}," +
"\"r\":{\"a\":0,\"k\":0,\"ix\":6},\"o\":{\"a\":0,\"k\":100,\"ix\":7},\"sk\":{\"a\":0," +
"\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5},\"nm\":\"Transform\"}],\"nm\":\"Group " +
"2\",\"np\":1,\"cix\":2,\"ix\":2,\"mn\":\"ADBE Vector Group\",\"hd\":false}],\"ip\":0," +
"\"op\":61.0000024845809,\"st\":0,\"bm\":0},{\"ddd\":0,\"ind\":2,\"ty\":4,\"nm\":\"Shape " +
"Layer 2\",\"sr\":1,\"ks\":{\"o\":{\"a\":0,\"k\":100,\"ix\":11},\"r\":{\"a\":0,\"k\":0," +
"\"ix\":10},\"p\":{\"a\":0,\"k\":[300,150,0],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0,0]," +
"\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100,100],\"ix\":6}},\"ao\":0," +
"\"shapes\":[{\"ty\":\"gr\",\"it\":[{\"ty\":\"gr\",\"it\":[{\"ty\":\"rc\",\"d\":1," +
"\"s\":{\"a\":0,\"k\":[50,50],\"ix\":2},\"p\":{\"a\":0,\"k\":[0,0],\"ix\":3}," +
"\"r\":{\"a\":0,\"k\":0,\"ix\":4},\"nm\":\"Rectangle Path 1\",\"mn\":\"ADBE Vector Shape - " +
"Rect\",\"hd\":false},{\"ty\":\"st\",\"c\":{\"a\":0,\"k\":[1,0,0,1],\"ix\":3}," +
"\"o\":{\"a\":0,\"k\":100,\"ix\":4},\"w\":{\"a\":0,\"k\":11,\"ix\":5},\"lc\":1,\"lj\":1," +
"\"ml\":4,\"nm\":\"Stroke\",\"mn\":\"ADBE Vector Graphic - Stroke\",\"hd\":false}," +
"{\"ty\":\"tr\",\"p\":{\"a\":0,\"k\":[-40,40],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0]," +
"\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100],\"ix\":3},\"r\":{\"a\":1," +
"\"k\":[{\"i\":{\"x\":[0.833],\"y\":[0.833]},\"o\":{\"x\":[0.167],\"y\":[0.167]}," +
"\"n\":[\"0p833_0p833_0p167_0p167\"],\"t\":0,\"s\":[0],\"e\":[360]}," +
"{\"t\":60.0000024438501}],\"ix\":6},\"o\":{\"a\":0,\"k\":100,\"ix\":7},\"sk\":{\"a\":0," +
"\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5},\"nm\":\"Transform\"}]," +
"\"nm\":\"Rectangle\",\"np\":2,\"cix\":2,\"ix\":1,\"mn\":\"ADBE Vector Group\"," +
"\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0,\"k\":[0,0],\"ix\":2},\"a\":{\"a\":0,\"k\":[0," +
"0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100],\"ix\":3},\"r\":{\"a\":0,\"k\":0,\"ix\":6}," +
"\"o\":{\"a\":0,\"k\":100,\"ix\":7},\"sk\":{\"a\":0,\"k\":0,\"ix\":4},\"sa\":{\"a\":0," +
"\"k\":0,\"ix\":5},\"nm\":\"Transform\"}],\"nm\":\"Group 1\",\"np\":1,\"cix\":2,\"ix\":1," +
"\"mn\":\"ADBE Vector Group\",\"hd\":false},{\"ty\":\"gr\",\"it\":[{\"ty\":\"gr\"," +
"\"it\":[{\"ty\":\"rc\",\"d\":1,\"s\":{\"a\":0,\"k\":[50,50],\"ix\":2},\"p\":{\"a\":0," +
"\"k\":[0,0],\"ix\":3},\"r\":{\"a\":0,\"k\":0,\"ix\":4},\"nm\":\"Rectangle Path 1\"," +
"\"mn\":\"ADBE Vector Shape - Rect\",\"hd\":false},{\"ty\":\"st\",\"c\":{\"a\":0,\"k\":[1," +
"0,0,1],\"ix\":3},\"o\":{\"a\":0,\"k\":100,\"ix\":4},\"w\":{\"a\":0,\"k\":11,\"ix\":5}," +
"\"lc\":1,\"lj\":1,\"ml\":4,\"nm\":\"Stroke\",\"mn\":\"ADBE Vector Graphic - Stroke\"," +
"\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0,\"k\":[40,40],\"ix\":2},\"a\":{\"a\":0," +
"\"k\":[0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100],\"ix\":3},\"r\":{\"a\":1," +
"\"k\":[{\"i\":{\"x\":[0.833],\"y\":[0.833]},\"o\":{\"x\":[0.167],\"y\":[0.167]}," +
"\"n\":[\"0p833_0p833_0p167_0p167\"],\"t\":0,\"s\":[0],\"e\":[360]},{\"i\":{\"x\":[0.833]," +
"\"y\":[0.833]},\"o\":{\"x\":[0.167],\"y\":[0.167]},\"n\":[\"0p833_0p833_0p167_0p167\"]," +
"\"t\":60,\"s\":[360],\"e\":[720]},{\"t\":150.000006109625}],\"ix\":6},\"o\":{\"a\":0," +
"\"k\":100,\"ix\":7},\"sk\":{\"a\":0,\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5}," +
"\"nm\":\"Transform\"}],\"nm\":\"Rectangle\",\"np\":2,\"cix\":2,\"ix\":1,\"mn\":\"ADBE " +
"Vector Group\",\"hd\":false},{\"ty\":\"tr\",\"p\":{\"a\":0,\"k\":[0,0],\"ix\":2}," +
"\"a\":{\"a\":0,\"k\":[0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100],\"ix\":3}," +
"\"r\":{\"a\":0,\"k\":0,\"ix\":6},\"o\":{\"a\":0,\"k\":100,\"ix\":7},\"sk\":{\"a\":0," +
"\"k\":0,\"ix\":4},\"sa\":{\"a\":0,\"k\":0,\"ix\":5},\"nm\":\"Transform\"}],\"nm\":\"Group " +
"2\",\"np\":1,\"cix\":2,\"ix\":2,\"mn\":\"ADBE Vector Group\",\"hd\":false}],\"ip\":0," +
"\"op\":61.0000024845809,\"st\":0,\"bm\":0}]}";
}
| 2,395 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/LottieCompositionFactoryTest.java | package com.airbnb.lottie;
import com.airbnb.lottie.model.LottieCompositionCache;
import com.airbnb.lottie.parser.moshi.JsonReader;
import org.junit.Before;
import org.junit.Test;
import org.robolectric.RuntimeEnvironment;
import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNotSame;
import static junit.framework.Assert.assertNull;
import static okio.Okio.buffer;
import static okio.Okio.source;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertSame;
@SuppressWarnings("ReferenceEquality")
public class LottieCompositionFactoryTest extends BaseTest {
private static final String JSON = "{\"v\":\"4.11.1\",\"fr\":60,\"ip\":0,\"op\":180,\"w\":300,\"h\":300,\"nm\":\"Comp 1\",\"ddd\":0,\"assets\":[]," +
"\"layers\":[{\"ddd\":0,\"ind\":1,\"ty\":4,\"nm\":\"Shape Layer 1\",\"sr\":1,\"ks\":{\"o\":{\"a\":0,\"k\":100,\"ix\":11},\"r\":{\"a\":0," +
"\"k\":0,\"ix\":10},\"p\":{\"a\":0,\"k\":[150,150,0],\"ix\":2},\"a\":{\"a\":0,\"k\":[0,0,0],\"ix\":1},\"s\":{\"a\":0,\"k\":[100,100,100]," +
"\"ix\":6}},\"ao\":0,\"shapes\":[{\"ty\":\"rc\",\"d\":1,\"s\":{\"a\":0,\"k\":[100,100],\"ix\":2},\"p\":{\"a\":0,\"k\":[0,0],\"ix\":3}," +
"\"r\":{\"a\":0,\"k\":0,\"ix\":4},\"nm\":\"Rectangle Path 1\",\"mn\":\"ADBE Vector Shape - Rect\",\"hd\":false},{\"ty\":\"fl\"," +
"\"c\":{\"a\":0,\"k\":[0.928262987324,0,0,1],\"ix\":4},\"o\":{\"a\":0,\"k\":100,\"ix\":5},\"r\":1,\"nm\":\"Fill 1\",\"mn\":\"ADBE Vector " +
"Graphic - Fill\",\"hd\":false}],\"ip\":0,\"op\":180,\"st\":0,\"bm\":0}]}";
private static final String NOT_JSON = "not json";
@Before
public void setup() {
LottieCompositionCache.getInstance().clear();
LottieCompositionCache.getInstance().resize(20);
}
@Test
public void testLoadJsonString() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromJsonStringSync(JSON, "json");
assertNull(result.getException());
assertNotNull(result.getValue());
}
@Test
public void testLoadJsonStringHitsCache() {
LottieResult<LottieComposition> result1 = LottieCompositionFactory.fromJsonStringSync(JSON, "json");
LottieResult<LottieComposition> result2 = LottieCompositionFactory.fromJsonStringSync(JSON, "json");
assertEquals(result1, result2);
}
@Test
public void testLoadDifferentJsonStringsDoesntHitsCache() {
LottieResult<LottieComposition> result1 = LottieCompositionFactory.fromJsonStringSync(JSON, "jso1");
LottieResult<LottieComposition> result2 = LottieCompositionFactory.fromJsonStringSync(JSON, "json2");
assertNotEquals(result1, result2);
}
@Test
public void testLoadInvalidJsonString() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromJsonStringSync(NOT_JSON, "not_json");
assertNotNull(result.getException());
assertNull(result.getValue());
}
@Test
public void testLoadJsonReader() {
JsonReader reader = JsonReader.of(buffer(source(new ByteArrayInputStream(JSON.getBytes()))));
LottieResult<LottieComposition> result = LottieCompositionFactory.fromJsonReaderSync(reader, "json");
assertNull(result.getException());
assertNotNull(result.getValue());
}
@Test
public void testLoadInvalidJsonReader() {
JsonReader reader = JsonReader.of(buffer(source(new ByteArrayInputStream(NOT_JSON.getBytes()))));
LottieResult<LottieComposition> result = LottieCompositionFactory.fromJsonReaderSync(reader, "json");
assertNotNull(result.getException());
assertNull(result.getValue());
}
@Test
public void testLoadInvalidAssetName() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromAssetSync(RuntimeEnvironment.application, "square2.json");
assertEquals(FileNotFoundException.class, result.getException().getClass());
assertNull(result.getValue());
}
@Test
public void testNonJsonAssetFile() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromAssetSync(RuntimeEnvironment.application, "not_json.txt");
assertNotNull(result.getException());
assertNull(result.getValue());
}
@Test
public void testLoadInvalidRawResName() {
LottieResult<LottieComposition> result = LottieCompositionFactory.fromRawResSync(RuntimeEnvironment.application, 0);
assertNotNull(result.getException());
assertNull(result.getValue());
}
@Test
public void testNullMultipleTimesAsync() {
JsonReader reader = JsonReader.of(buffer(source(getNeverCompletingInputStream())));
LottieTask<LottieComposition> task1 = LottieCompositionFactory.fromJsonReader(reader, null);
LottieTask<LottieComposition> task2 = LottieCompositionFactory.fromJsonReader(reader, null);
assertNotSame(task1, task2);
}
@Test
public void testNullMultipleTimesSync() {
JsonReader reader = JsonReader.of(buffer(source(getNeverCompletingInputStream())));
LottieResult<LottieComposition> task1 = LottieCompositionFactory.fromJsonReaderSync(reader, null);
LottieResult<LottieComposition> task2 = LottieCompositionFactory.fromJsonReaderSync(reader, null);
assertNotSame(task1, task2);
}
@Test
public void testZeroCacheWorks() {
JsonReader reader = JsonReader.of(buffer(source(getNeverCompletingInputStream())));
LottieCompositionFactory.setMaxCacheSize(1);
LottieResult<LottieComposition> taskFoo1 = LottieCompositionFactory.fromJsonReaderSync(reader, "foo");
LottieResult<LottieComposition> taskFoo2 = LottieCompositionFactory.fromJsonReaderSync(reader, "foo");
assertNotSame(taskFoo1, taskFoo2);
}
@Test(expected = IllegalArgumentException.class)
public void testCannotSetCacheSizeToZero() {
LottieCompositionFactory.setMaxCacheSize(0);
}
private static InputStream getNeverCompletingInputStream() {
return new InputStream() {
@Override public int read() throws IOException {
return 100;
}
};
}
}
| 2,396 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/LottieTaskTest.java | package com.airbnb.lottie;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
import java.util.concurrent.Callable;
import java.util.concurrent.Semaphore;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
public class LottieTaskTest extends BaseTest {
@Mock
public LottieListener<Integer> successListener;
@Mock
public LottieListener<Throwable> failureListener;
@Rule
public MockitoRule rule = MockitoJUnit.rule();
@Test
public void testListener() {
new LottieTask<>(() -> new LottieResult<>(5), true)
.addListener(successListener)
.addFailureListener(failureListener);
verify(successListener, times(1)).onResult(5);
verifyNoInteractions(failureListener);
}
@Test
public void testException() {
final IllegalStateException exception = new IllegalStateException("foo");
new LottieTask<>((Callable<LottieResult<Integer>>) () -> {
throw exception;
}, true)
.addListener(successListener)
.addFailureListener(failureListener);
verifyNoInteractions(successListener);
verify(failureListener, times(1)).onResult(exception);
}
/**
* This hangs on CI but not locally.
*/
@Ignore("hangs on ci")
@Test
public void testRemoveListener() {
final Semaphore lock = new Semaphore(0);
LottieTask<Integer> task = new LottieTask<>(new Callable<LottieResult<Integer>>() {
@Override public LottieResult<Integer> call() {
return new LottieResult<>(5);
}
})
.addListener(successListener)
.addFailureListener(failureListener)
.addListener(new LottieListener<Integer>() {
@Override public void onResult(Integer result) {
lock.release();
}
});
task.removeListener(successListener);
try {
lock.acquire();
} catch (InterruptedException e) {
throw new IllegalStateException(e);
}
verifyNoInteractions(successListener);
verifyNoInteractions(failureListener);
}
@Test
public void testAddListenerAfter() {
LottieTask<Integer> task = new LottieTask<>(new Callable<LottieResult<Integer>>() {
@Override public LottieResult<Integer> call() {
return new LottieResult<>(5);
}
}, true);
task.addListener(successListener);
task.addFailureListener(failureListener);
verify(successListener, times(1)).onResult(5);
verifyNoInteractions(failureListener);
}
}
| 2,397 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/LottieInitializeTest.java | package com.airbnb.lottie;
import static org.junit.Assert.assertNotNull;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.test.platform.app.InstrumentationRegistry;
import com.airbnb.lottie.network.LottieFetchResult;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import java.io.InputStream;
import java.util.Objects;
public class LottieInitializeTest extends BaseTest {
@Rule
public final TemporaryFolder temporaryFolder1 = new TemporaryFolder();
@Rule
public final TemporaryFolder temporaryFolder2 = new TemporaryFolder();
private final Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
@Before
public void setExecutor() {
LottieTask.EXECUTOR = Runnable::run;
}
@Test
public void fetchAfterSecondInitialize() {
initializeLottie(temporaryFolder1);
// Fetching here causes the resource to be cached in temporaryFolder1:
LottieResult<LottieComposition> result1 = LottieCompositionFactory.fromUrlSync(context, "resources://test1.json");
assertNotNull(result1.getValue());
// Manually delete to simulate the end of a test:
temporaryFolder1.delete();
initializeLottie(temporaryFolder2);
// Fetching here fails if L.setCacheProvider doesn't reset both its internal networkFetcher and its internal networkCache, because
// temporaryFolder1 has been deleted:
LottieResult<LottieComposition> result2 = LottieCompositionFactory.fromUrlSync(context, "resources://test1.json");
assertNotNull(result2.getValue());
}
private void initializeLottie(TemporaryFolder temporaryFolder) {
LottieConfig lottieConfig = new LottieConfig.Builder()
.setNetworkCacheDir(temporaryFolder.getRoot())
.setNetworkFetcher(url -> {
if (url.startsWith("resources://")) {
InputStream stream = Objects.requireNonNull(getClass().getClassLoader())
.getResourceAsStream(url.substring("resources://".length()));
if (stream != null) {
return new LottieFetchSuccess(stream);
}
}
return new LottieFetchFailure("Could not load <$url>");
})
.build();
Lottie.initialize(lottieConfig);
}
private static class LottieFetchSuccess implements LottieFetchResult {
@NonNull private final InputStream jsonStream;
LottieFetchSuccess(@NonNull InputStream jsonStream) {
this.jsonStream = jsonStream;
}
@Override public boolean isSuccessful() {
return true;
}
@Override @NonNull public InputStream bodyByteStream() {
return jsonStream;
}
@Override public String contentType() {
return "application/json";
}
@Override @Nullable public String error() {
return null;
}
@Override public void close() {
// No-op
}
}
private static class LottieFetchFailure implements LottieFetchResult {
@NonNull private final String errorMessage;
LottieFetchFailure(@NonNull String errorMessage) {
this.errorMessage = errorMessage;
}
@Override public boolean isSuccessful() {
return false;
}
@Override @NonNull public InputStream bodyByteStream() {
throw new RuntimeException("LottieFetchFailure has no body");
}
@Override @Nullable public String contentType() {
return null;
}
@Override public String error() {
return errorMessage;
}
@Override public void close() {
// No-op
}
}
}
| 2,398 |
0 | Create_ds/lottie-android/lottie/src/test/java/com/airbnb | Create_ds/lottie-android/lottie/src/test/java/com/airbnb/lottie/MeanCalculatorTest.java | package com.airbnb.lottie;
import com.airbnb.lottie.utils.MeanCalculator;
import org.junit.Before;
import org.junit.Test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
public class MeanCalculatorTest {
private MeanCalculator meanCalculator;
@Before
public void setup() {
meanCalculator = new MeanCalculator();
}
@Test
public void testMeanWithNoNumbers() {
assertThat(meanCalculator.getMean(), equalTo(0f));
}
@Test
public void testMeanWithOneNumber() {
meanCalculator.add(2);
assertThat(meanCalculator.getMean(), equalTo(2f));
}
@Test
public void testMeanWithTwoNumbers() {
meanCalculator.add(2);
meanCalculator.add(4);
assertThat(meanCalculator.getMean(), equalTo(3f));
}
@Test
public void testMeanWithTwentyNumbers() {
for (int i = 1; i <= 20; i++) {
meanCalculator.add(i);
}
assertThat(meanCalculator.getMean(), equalTo(10.5f));
}
@Test
public void testMeanWithHugeNumber() {
meanCalculator.add(Integer.MAX_VALUE - 1);
meanCalculator.add(Integer.MAX_VALUE - 1);
assertThat(meanCalculator.getMean(), equalTo((float) (Integer.MAX_VALUE - 1)));
}
@Test
public void testMeanWithHugeNumberAndNegativeHugeNumber() {
meanCalculator.add(Integer.MAX_VALUE - 1);
meanCalculator.add(Integer.MAX_VALUE - 1);
meanCalculator.add(-Integer.MAX_VALUE + 1);
meanCalculator.add(-Integer.MAX_VALUE + 1);
assertThat(meanCalculator.getMean(), equalTo(0f));
}
}
| 2,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.