[ Get-Started | Features | Use Cases | Samples | Change Log / What's New / Versions | User Group | Motivation | Demos | Performance | Compare | Contributors | About | News | Plugin | 中文介绍 ]
[ API Overview | Generate & Submit Task | Track Status & Examine Responses | Configurations ]
Tweeted by the Creator of Akka & Featured in [ This Week in #Scala | OSChina - 2015 Top 100 ]
Parallec is a fast parallel async HTTP(S)/SSH/TCP/UDP/Ping client java library based on Akka. Scalably aggregate and handle API responses anyway and send it anywhere by writing 20 lines of code. A super convenient response context let you pass in/out any object when handling the responses. Now you can conduct scalable API calls, then effortlessly pass aggregated data anywhere to elastic search, kafka, MongoDB, graphite, memcached, etc. Flexible task level concurrency control without creating a 1,000 threads thread pool. Parallec means Parallel Client (pronounced as "Para-like"). Visit www.parallec.io
Watch Demo: 8,000 web server HTTP response aggregation to memory in 12 seconds / to ElasticSearch in 16 seconds.
Aggregated error messages - Debug friendly with full visibility: Having trouble debugging in concurrent environment? Not any more! All exceptions, timeout, stack traces, request sent and response received time are captured and aggregated in the response map. It is available in ParallelTask for polling right after you execute a task asynchronously. Multi-level (worker/manager) timeout guarantees tasks return even for 100,000s of requests.
Production Use Cases: widely used in infrastructure software as the polling and aggregation engine
Donwload the latest JAR or grab from Maven:
<dependency>
<groupId>io.parallec</groupId>
<artifactId>parallec-core</artifactId>
<version>0.10.6</version>
</dependency>
Snapshots of the development version are available in Sonatype's snapshots
repository.
or Gradle:
compile 'io.parallec:parallec-core:0.10.6'
6 Line Example
In the example below, simply changing prepareHttpGet() to prepareSsh(), prepareTcp(), prepareUdp(), preparePing() enables you to conduct parallel SSH/TCP/Ping. Details please refer to the Java Doc and Example Code.
import io.parallec.core.*;
import java.util.Map;
ParallelClient pc = new ParallelClient();
pc.prepareHttpGet("").setTargetHostsFromString("www.google.com www.ebay.com www.yahoo.com")
.execute(new ParallecResponseHandler() {
public void onCompleted(ResponseOnSingleTask res,
Map<String, Object> responseContext) {
System.out.println( res.toString() ); }
});
20 Line Example
Now that you have learned the basics, check out how easy to pass an elastic search client using the convenient response context to aggregate data anywhere you like. You can also pass a hash map to the responseContext
, save the processed results to the map during onCompleted
, and use the map outside for further work.
...
import org.elasticsearch.client.Client;
import static org.elasticsearch.node.NodeBuilder.*;
ParallelClient pc = new ParallelClient();
org.elasticsearch.node.Node node = nodeBuilder().node(); //elastic client initialize
HashMap<String, Object> responseContext = new HashMap<String, Object>();
responseContext.put("Client", node.client());
pc.prepareHttpGet("")
.setConcurrency(1000).setResponseContext(responseContext)
.setTargetHostsFromLineByLineText("http://www.parallec.io/userdata/sample_target_hosts_top100_old.txt", HostsSourceType.URL)
.execute( new ParallecResponseHandler() {
public void onCompleted(ResponseOnSingleTask res,
Map<String, Object> responseContext) {
Map<String, Object> metricMap = new HashMap<String, Object>();
metricMap.put("StatusCode", res.getStatusCode().replaceAll(" ", "_"));
metricMap.put("LastUpdated",PcDateUtils.getNowDateTimeStrStandard());
metricMap.put("NodeGroupType", "Web100");
Client client = (Client) responseContext.get("Client");
client.prepareIndex("local", "parallec", res.getHost()).setSource(metricMap).execute();
}
});
node.close(); pc.releaseExternalResources();
Different Requests to the Same Target
Now see how easy to use the request template to send multiple different requests to the same target. Variable replacement is allowed in post body, url and headers. Read more..
pc.prepareHttpGet("/userdata/sample_weather_$ZIP.txt")
.setReplaceVarMapToSingleTargetSingleVar("ZIP",
Arrays.asList("95037","48824"), "www.parallec.io")
.execute(new ParallecResponseHandler() {...}...
More details please check the Change Log.
0.10.x
, where we use in production.async-http-client
(currently using AHC version 2.0.15
) is 0.20.0-SNAPSHOT
. This version has passed comprehensive unit tests but has not been used yet in production. This version requires JDK8 due to AHC 2.x and can be used with the parallec-plugins with the same version 0.20.0-SNAPSHOT
, details please check #37.Parallec is built on Akka actors and Async HTTP Client / Netty / Jsch. The library focuses on HTTP while also enables scalable communication over SSH/Ping/TCP.
90%+ Test coverage assures you always find an example of each of feature.
With the feedbacks, lessons, and improvements from the past year of internal usage and open source of REST Commander, we now made the core of REST Commander as an easy to use standalone library. We added 15+ new features, rewritten 70%+ of the code, with 90%+ test coverage for confident usage and contribution. This time we also structure it better so that most internal development can be directly made here.
[Watch Demo](https://www.youtube.com/watch?v=QcavegPMDms"Parallec demo - Click to Watch!"): Parallec Aggregates 100 websites status to elastic search and visualized with 20 lines of code.
Watch Demo on HTTP Calls on 8000 Servers: 8,000 web server HTTP response aggregation to memory in 12 seconds / to ElasticSearch in 16 seconds.
[Watch Ping Demo](https://www.youtube.com/watch?v=9m1TFuO1Mys"Parallec Ping vs FPing demo - Click to Watch!"): Parallec is 2x Speed of best-efforted tuned FPing with same accurate results and pings 8000 servers within 11.1 seconds, details check here.
Note that speed varies based on network speed, API response time, the slowest servers, timeout, and concurrency settings.
We conducted remote task execution API on 3,000 servers with response aggregated to elastic search, visualized within 15 seconds, by writing 25 lines of code.
With another faster API, calls to 8,000 servers in the same datacenter with response aggregated in memory in 12 seconds.
Parallec 2.2 seconds vs FPing 4.5 seconds on 1500 servers. Parallec is 2x the speed of FPing (after best-effort tuning : -i 1 -r 0 v3.12) of pinging 1500 servers while getting the same ping results. Parallec pings 8000 servers within 11.1 seconds with breeze.
As usual, don't rely on these numbers and perform your own benchmarks.
In Parallec, you may handle response either in Worker (before aggregation: in parallel) or in Manager (after aggregation: single thread). Read More..
For more related work review, please visit here.
Features | Parallec | REST Commander | Thread Pools + Async Client |
---|---|---|---|
Embedded library with intuitive builder pattern interface | |||
Ready to use application with GUI wizard based request submission and response aggregation | |||
Simple concurrency control not limited by thread size | |||
Immediate response handler without waiting all response return | |||
Capacity aware task scheduler and global capacity control | |||
Total freedom of response processing and API aggregation: Pluggable and generic response handler and response context | |||
1 line plugin to enable SSL Client auth | |||
90% Test Coverage | |||
Load target hosts from CMS query, JSON Path, text, list, string from URL/local | |||
Task level concurrency and orchestration for Async APIs: auto polling task progress | |||
Task level configuration on timeout and replacing Async HTTP Client | |||
Async and sync task control with progress polling and cancellation | |||
Scalable Parallel SSH with password and key based login | |||
Proven scalability and speed on 100,000+ target hosts in Production environment | |||
Generic request template with variable replacement for sending different requests to same/different target hosts | |||
Scalable Ping with Retries | |||
Scalable TCP/UDP with idle timeout | |||
Flexible handler location at either worker (in parallel) or manager thread | |||
Out-of-the-box two-level response aggregation on status code | |||
Configurable response log trimming on intervals | |||
Cancel task on a list of target hosts |
We deeply thank all contributors for their effort.
Parallec is served to you by Yuanteng (Jeff) Pei and Teng Song, Cloud Infrastructure & Platform Services (CIPS) at eBay Inc. (original authors)
Any helpful feedback is more than welcome. This includes feature requests, bug reports, pull requests, constructive feedback, and etc. You must agree on this before submitting a pull request.
Code licensed under Apache License v2.0
© 2015-2017 eBay Software Foundation