ดาวน์โหลด parallec - ดาวน์โหลดซอร์สโค้ด parallec

parallec

หมวดหมู่อื่นๆ

v0.10.1-beta

ดาวน์โหลด

[ ภาพรวม API | สร้างและส่งงาน | ติดตามสถานะและตรวจสอบการตอบกลับ | การกำหนดค่า ]

ทวีตโดยผู้สร้าง Akka และนำเสนอใน [ สัปดาห์นี้ใน #Scala | OSChina - 2015 ติดอันดับ 100 ]

ภาพรวม

Parallec เป็นไลบรารี Java ไคลเอ็นต์แบบอะซิงก์ HTTP(S)/SSH/TCP/UDP/Ping แบบขนานที่รวดเร็วซึ่งใช้ Akka สามารถรวมและจัดการการตอบสนองของ API ได้ อย่างปรับขนาดได้ และส่งไป ได้ทุกที่ ด้วยการเขียนโค้ด 20 บรรทัด บริบทการตอบสนอง ที่สะดวกสบายเป็นพิเศษช่วยให้คุณสามารถส่งผ่านวัตถุใดๆ ก็ได้เมื่อจัดการกับการตอบสนอง ตอนนี้คุณสามารถดำเนินการเรียก API ที่ปรับขนาดได้ จากนั้นส่งข้อมูลรวมไปยังทุกที่ได้อย่างง่ายดายไปยังการค้นหาแบบยืดหยุ่น, kafka, MongoDB, กราไฟท์, memcached ฯลฯ การควบคุมการทำงานพร้อมกันในระดับงานที่ยืดหยุ่นโดยไม่ต้องสร้างพูลเธรด 1,000 เธรด Parallec หมายถึง Paralle l C lient (ออกเสียงว่า "เหมือนพารา") เยี่ยมชม www.parallec.io

ชมการสาธิต : การรวมการตอบสนอง HTTP ของเว็บเซิร์ฟเวอร์ 8,000 รายการ ไปยังหน่วยความจำใน 12 วินาที / ไปยัง ElasticSearch ใน 16 วินาที

ข้อความแสดงข้อผิดพลาดแบบรวม - ดีบักที่เป็นมิตรพร้อมการมองเห็นแบบเต็ม : มีปัญหาในการดีบักในสภาพแวดล้อมที่เกิดขึ้นพร้อมกันหรือไม่ ไม่มีอีกแล้ว! ข้อยกเว้น การหมดเวลา การติดตามสแต็ก คำขอที่ส่ง และเวลาที่ได้รับการตอบสนองทั้งหมดจะ ถูกบันทึกและรวมไว้ ในแผนผังการตอบสนอง มีอยู่ใน ParallelTask สำหรับการโพลทันทีหลังจากที่คุณดำเนินการงานแบบอะซิงโครนัส การหมดเวลาหลายระดับ (ผู้ปฏิบัติงาน/ผู้จัดการ) รับประกันว่างานจะกลับมาแม้จะเป็นคำขอ 100,000 รายการก็ตาม

กรณีการใช้งานจริง : ใช้กันอย่างแพร่หลายในซอฟต์แวร์โครงสร้างพื้นฐานในฐานะกลไกการสำรวจและการรวมกลุ่ม

การปรับใช้แอปพลิเคชัน / PaaS : Parallec ได้รับการรวมเข้ากับระบบการปรับใช้แอปพลิเคชันการผลิตหลักของ eBay (PaaS) Parallec จัดระเบียบงาน API มากกว่า 10 รายการ โดยแต่ละงานกำหนดเป้าหมายไปที่เซิร์ฟเวอร์ 10 ถึง 1,000 รายการ มากกว่ากลุ่มแอปพลิเคชันมากกว่า 1,000 รายการในการผลิต Parallec ถูกนำมาใช้กับ Winder เอ็นจิ้นเวิร์กโฟลว์เพื่อจัดการกับเวิร์กโฟลว์ที่ซับซ้อนมากขึ้น แต่ก็คล้ายกับอันนี้
การแยกข้อมูล / ETL : ทีมข่าวกรองเว็บของ eBay Israel ใช้ Parallec เพื่อดำเนินการเรียก API แบบขนาน 10,000-100,000 ไปยังเซิร์ฟเวอร์บุคคลที่สามเพียงเซิร์ฟเวอร์เดียว พร้อมประสิทธิภาพที่ได้รับการปรับปรุงอย่างมากและลดทรัพยากรลง
การแก้ไขปัญหาเครือข่ายผ่านการซักถาม : ในทีมงานเครือข่าย/คลาวด์ของ eBay Parallec เป็นเครื่องมือที่ช่วยให้มั่นใจได้ว่ามีอัตราการแจ้งเตือนผิดพลาดที่ต่ำมาก เพื่อตรวจจับความล้มเหลวของสวิตช์ได้อย่างแม่นยำ Parallec ทำหน้าที่เป็นกลไกการโพลหลักในส่วนประกอบหลักเพื่อตรวจสอบความสมบูรณ์ของตัวแทนและทำเครื่องหมายตัวแทนเพื่อกำจัดสัญญาณรบกวนได้อย่างมีประสิทธิภาพและทันท่วงที
การจัดการตัวแทน / ผู้เชี่ยวชาญด้านตัวแทน : ในทีมงานปฏิบัติการ/เครื่องมือในเว็บไซต์ของ eBay นั้น Parallec ทำหน้าที่เป็นกลไกหลักในการจัดการและตรวจสอบตัวแทนหุ่นเชิด / ตัวแทนเกลือ / kubernetes kubelet เช่นเดียวกับตัวแทนบนเซิร์ฟเวอร์ที่ใช้งานจริงมากกว่า 100,000 แห่ง เพื่อให้มั่นใจว่าการดำเนินงานสามารถปรับขนาดได้

เริ่มต้นเลย

ดาวน์โหลด JAR ล่าสุดหรือคว้าจาก Maven:

< dependency >
	< groupId >io.parallec</ groupId >
	< artifactId >parallec-core</ artifactId >
	< version >0.10.6</ version >
</ dependency >

สแนปชอตของเวอร์ชันการพัฒนามีอยู่ในที่เก็บ snapshots ของ Sonatype

หรือเกรเดิล:

compile 'io.parallec:parallec-core:0.10.6'

ตัวอย่าง 6 บรรทัด

ในตัวอย่างด้านล่าง เพียงเปลี่ยน allowanceHttpGet() เป็น waitSsh() , preparTcp() , preparUdp() , preparPing() ช่วยให้คุณสามารถดำเนินการ SSH/TCP/Ping แบบขนานได้ รายละเอียดโปรดอ้างอิงถึง Java Doc และโค้ดตัวอย่าง

 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 บรรทัด

เมื่อคุณได้เรียนรู้พื้นฐานแล้ว ลองดูวิธีการง่ายๆ ในการส่งต่อไคลเอ็นต์การค้นหาแบบยืดหยุ่นโดยใช้ บริบทการตอบสนอง ที่สะดวกเพื่อรวบรวมข้อมูลทุกที่ที่คุณต้องการ คุณยังสามารถส่งแฮชแมปไปยัง responseContext บันทึกผลลัพธ์ที่ประมวลผลไปยังแมปในระหว่างที่ onCompleted และใช้แมพภายนอกเพื่อทำงานต่อไป

...
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 ();

คำขอที่แตกต่างกันไปยังเป้าหมายเดียวกัน

ตอนนี้มาดู ความง่าย ในการใช้เทมเพลตคำขอเพื่อส่งคำขอที่แตกต่างกันหลายรายการไปยังเป้าหมายเดียวกัน อนุญาตให้เปลี่ยนตัวแปรได้ในเนื้อหาโพสต์ URL และส่วนหัว อ่านเพิ่มเติม..

 pc . prepareHttpGet ( "/userdata/sample_weather_$ZIP.txt" )
    . setReplaceVarMapToSingleTargetSingleVar ( "ZIP" ,
        Arrays . asList ( "95037" , "48824" ), "www.parallec.io" )
    . execute ( new ParallecResponseHandler () {...}...

http://www.parallec.io/userdata/sample_weather_48824.txt
http://www.parallec.io/userdata/sample_weather_95037.txt

มีอะไรใหม่

06/2017 เพิ่มการเข้ารหัสการตอบสนองแบบไดนามิกตามประเภทเนื้อหาการตอบสนอง
09/2016 เพิ่มตัวเลือกในการบันทึกส่วนหัวการตอบกลับใน HTTP #24
08/2016 รองรับ Parallel async UDP (ผ่าน Netty) #41
07/2016 รองรับการเปลี่ยนพอร์ตที่แตกต่างกันในคำขอที่แตกต่างกัน
06/2016 Parallel SSH เพิ่ม run sudo พร้อมรหัสผ่านสำหรับคำสั่ง

รายละเอียดเพิ่มเติมโปรดตรวจสอบบันทึกการเปลี่ยนแปลง

รุ่นต่างๆ

เวอร์ชันพร้อมใช้งานจริงล่าสุดคือ 0.10.x ซึ่งเราใช้ในการผลิต
บน async-http-client 2.x เวอร์ชัน Parallec.io ที่ใช้ async-http-client ที่ทันสมัยยิ่งขึ้น (ปัจจุบันใช้ AHC เวอร์ชัน 2.0.15 ) คือ 0.20.0-SNAPSHOT เวอร์ชันนี้ผ่านการทดสอบหน่วยอย่างครอบคลุมแต่ยังไม่ได้ใช้ในการผลิต เวอร์ชันนี้ ต้องใช้ JDK8 เนื่องจาก AHC 2.x และสามารถใช้ได้กับปลั๊กอิน parallec ที่มีเวอร์ชันเดียวกัน 0.20.0-SNAPSHOT โปรดตรวจสอบรายละเอียด #37

การอ่านเพิ่มเติม

ตัวอย่างเพิ่มเติม เกี่ยวกับการตั้งค่าบริบท ส่งไปยัง Elastic Search / Kafka, การรันแบบอะซิงโครนัส, การโพลความคืบหน้าอัตโนมัติ, ติดตามความคืบหน้า, TCP/SSH/Ping ตัวอย่าง UDP อยู่ที่นี่ และยังมีอีกมากมายที่จะตามมา
ตั้งค่าโฮสต์เป้าหมาย จากรายการ สตริง ข้อความทีละบรรทัด เส้นทาง json จาก URL ในเครื่องหรือระยะไกล
เอกสารฉบับเต็ม
จาวาด็อก
Ping Demo เซิร์ฟเวอร์ Ping 8000 ภายใน 11.1 วินาที การทดสอบประสิทธิภาพเทียบกับ FPing

กลุ่มผู้ใช้

ถามคำถามและติดตามข่าวสารล่าสุดเกี่ยวกับการพัฒนาห้องสมุดโดยเข้าร่วมกลุ่มสนทนา/ฟอรัม: Parallec.io Google Group
อย่าลังเลที่จะส่งปัญหา Github สำหรับคำถามและข้อเสนอแนะใดๆ เช่นกัน
ตรวจสอบคำถามที่พบบ่อย

ใช้กรณี

การตรวจสอบ การจัดการ และการพุชการกำหนดค่า การตรวจสอบ Ping ของเว็บเซิร์ฟเวอร์ที่ปรับขนาดได้
การค้นหาสถานะสินทรัพย์ / เซิร์ฟเวอร์ การดำเนินการงานระยะไกลด้วยวิธีแบบไม่ใช้เอเจนต์ (SSH แบบขนาน) หรือแบบใช้เอเจนต์ (HTTP/TCP แบบขนาน)
การรวมและการประมวลผล API ที่ปรับขนาดได้พร้อมปลายทางที่ยืดหยุ่นพร้อมคิวข้อความ / พื้นที่จัดเก็บ / เอ็นจิ้นการแจ้งเตือนที่คุณชื่นชอบ
การจัดระเบียบและขั้นตอนการทำงานบนเว็บเซิร์ฟเวอร์หลายเครื่อง
คำขอที่แตกต่างกันแบบขนานพร้อมการควบคุมการทำงานพร้อมกันไปยังเซิร์ฟเวอร์เดียว: เป็นไคลเอนต์แบบคู่ขนานสำหรับการดำเนินการ CRUD ฐานข้อมูล / เว็บเซิร์ฟเวอร์ที่เปิดใช้งาน REST API อนุญาตให้เปลี่ยนตัวแปรได้ในเนื้อหาโพสต์ URL และส่วนหัว
โหลดการทดสอบด้วยเทมเพลตคำขอ
การตรวจสอบเครือข่ายพร้อมการตรวจสอบที่ใช้งานอยู่ผ่าน UDP/Ping ฯลฯ

คุณสมบัติ

Parallec สร้างขึ้นจากนักแสดง Akka และ Async HTTP Client / Netty / Jsch ไลบรารีมุ่งเน้นไปที่ HTTP ในขณะเดียวกันก็เปิดใช้งานการสื่อสารที่ปรับขนาดได้ผ่าน SSH/Ping/TCP

ความครอบคลุมการทดสอบ 90%+ ช่วยให้มั่นใจได้ว่าคุณจะพบตัวอย่างของแต่ละคุณสมบัติอยู่เสมอ

อินเทอร์เฟซ ที่ใช้งานง่ายเป็นพิเศษ พร้อมรูปแบบตัวสร้างคล้ายกับใน Async HTTP Client แต่จัดการการทำงานพร้อมกันในเบื้องหลัง
ตัวจัดการการตอบสนองทั่วไปพร้อมบริบท บริบทการตอบสนองพิเศษช่วยให้มีอิสระและความสะดวกสบายในการประมวลผลคำตอบแต่ละรายการในแบบของคุณ ประมวลผลและรวบรวมข้อมูล จากทุกที่ ไปยัง Kafka, Redis, Elastic Search, mongoDB, CMS และอื่นๆ
ยืดหยุ่นว่าเมื่อใดที่จะเรียกใช้ตัวจัดการ : ก่อน (ในเธรดของผู้ปฏิบัติงาน) หรือหลังการรวม (ในเธรดหลัก/ผู้จัดการ)
การป้อนข้อมูลโฮสต์เป้าหมายที่ยืดหยุ่น : อินพุตโฮสต์เป้าหมายจากรายการ สตริง เส้นทาง JSON จากไฟล์ในเครื่องหรือ URL ระยะไกล
ปรับขนาดได้และรวดเร็ว ปรับขนาดได้ไม่จำกัด ด้วย การควบคุมการทำงาน พร้อมกันในตัว
การโพลความคืบหน้าอัตโนมัติ เพื่อเปิดใช้งานการทำงานพร้อมกันในระดับงานด้วย Async API สำหรับงานและการเตรียมการที่ยาวนาน
ขอเทมเพลต เพื่อจัดการกับคำขอที่ไม่สม่ำเสมอ
สะดวกในการจัดการกรณีความสำเร็จและความล้มเหลวในที่เดียว จัดการในฟังก์ชันเดียวที่คุณสามารถรับการตอบสนอง รวมถึงการตอบสนองจริงหากสำเร็จ หรือรายละเอียดสแต็กเทรซและข้อผิดพลาดหากเกิดความล้มเหลว
ตัวกำหนดเวลางานที่ทราบความจุ ช่วยให้คุณจัดคิวอัตโนมัติและเริ่มทำงานเมื่อความจุไม่เพียงพอ (เช่น ส่ง 5 งานติดต่อกัน โดยแต่ละงานเข้าชมเว็บไซต์ 100,000 เว็บไซต์โดยการทำงานพร้อมกันเริ่มต้นจะส่งผลให้มีคิวเพิ่มขึ้น)
การติดตามความคืบหน้าของงานอย่างละเอียด ช่วยให้คุณติดตามความคืบหน้าของแต่ละสถานะงานได้ จากงานแบบขนานบนโฮสต์เป้าหมาย 1,000 รายการ คุณสามารถตรวจสอบสถานะของงานโฮสต์เดียว และเปอร์เซ็นต์ความคืบหน้าของจำนวนงานที่เสร็จสมบูรณ์
การยกเลิกงานโดยละเอียด ในระดับคำขอทั้งหมด/แต่ละรายการ จากงานแบบขนานบนโฮสต์เป้าหมาย 1,000 รายการ คุณสามารถยกเลิกชุดย่อยของโฮสต์เป้าหมายหรือยกเลิกงานแบบขนานทั้งหมดได้ตลอดเวลา
การรวมรหัสสถานะ มีให้ทันที
Parallel Ping รองรับทั้ง InetAddress.reachable ICMP (ต้องใช้รูท) และ Ping ตามกระบวนการพร้อมการลองใหม่ การทดสอบประสิทธิภาพแสดงให้เห็นว่ามี ความเร็วเป็น 2 เท่าของ FPing ที่ปรับแต่งอย่างดีที่สุดในการส่ง Ping ไปยังเป้าหมาย 1500 เป้าหมาย (2.2 กับ 4.5 วินาที)
Parallel SSH รองรับทั้งการเข้าสู่ระบบด้วยคีย์และรหัสผ่านและการยกเลิกงาน
TCP/UDP แบบขนาน รองรับการปิดช่องสัญญาณตามระยะหมดเวลาที่ไม่ได้ใช้งาน

แรงจูงใจ

การจัดการการตอบสนองที่ยืดหยุ่นและการประมวลผลทันทีที่ฝังอยู่ในแอปพลิเคชันอื่น
จัดการ API แบบอะซิงก์พร้อมการสำรวจความคืบหน้าอัตโนมัติสำหรับการควบคุมการทำงานพร้อมกันในระดับงาน
รองรับโปรโตคอลอื่น ๆ และอื่น ๆ ..
ใครๆ ก็สามารถเขียนได้ 20 บรรทัดเพื่อให้ใบสมัครของตนกลายเป็น REST Commander

ด้วยการตอบรับ บทเรียน และการปรับปรุงจากการใช้งานภายในและโอเพ่นซอร์สของ REST Commander ในปีที่ผ่านมา ตอนนี้เราได้ทำให้แกนหลักของ REST Commander เป็นไลบรารีแบบสแตนด์อโลนที่ใช้งานง่าย เราได้เพิ่มคุณสมบัติ ใหม่มากกว่า 15 รายการ เขียนโค้ดใหม่มากกว่า 70% พร้อม การครอบคลุมการทดสอบมากกว่า 90% เพื่อการใช้งานและการสนับสนุนที่มั่นใจ ครั้งนี้เรายังจัดโครงสร้างให้ดีขึ้นเพื่อให้การพัฒนาภายในส่วนใหญ่สามารถทำได้โดยตรงที่นี่

ชมการทำงานของ Parallec

[ ดูการสาธิต ](https://www.youtube.com/watch?v=QcavegPMDms"การสาธิต Parallec - คลิกเพื่อดู!"): Parallec รวบรวมสถานะเว็บไซต์ 100 แห่งเพื่อค้นหาแบบยืดหยุ่นและแสดงภาพด้วยโค้ด 20 บรรทัด

ชมการสาธิตการโทร HTTP บนเซิร์ฟเวอร์ 8000 เครื่อง : การรวมการตอบสนอง HTTP ของเว็บเซิร์ฟเวอร์ 8,000 รายการ ไปยังหน่วยความจำใน 12 วินาที / ไปยัง ElasticSearch ใน 16 วินาที

[ ดูการสาธิต Ping ](https://www.youtube.com/watch?v=9m1TFuO1Mys"การสาธิต Parallec Ping เทียบกับ FPing - คลิกเพื่อดู!"): Parallec มี ความเร็ว 2 เท่า ของ FPing ที่ปรับแต่งอย่างดีที่สุดพร้อมผลลัพธ์ที่แม่นยำและเหมือนกัน ส่ง Ping ไปยังเซิร์ฟเวอร์ 8,000 เครื่องภายใน 11.1 วินาที รายละเอียดตรวจสอบได้ที่นี่

ผลงาน

โปรดทราบว่าความเร็วจะแตกต่างกันไปขึ้นอยู่กับความเร็วเครือข่าย เวลาตอบสนองของ API เซิร์ฟเวอร์ที่ช้าที่สุด การหมดเวลา และการตั้งค่าการทำงานพร้อมกัน

HTTP

เราดำเนินการ API การดำเนินการงานระยะไกลบนเซิร์ฟเวอร์ 3,000 เครื่องพร้อมการตอบสนองที่รวมอยู่ในการค้นหาแบบยืดหยุ่น ซึ่งแสดงเป็นภาพภายใน 15 วินาที โดยการเขียนโค้ด 25 บรรทัด

ด้วย API ที่เร็วกว่าอีกตัวหนึ่ง คุณสามารถเรียกเซิร์ฟเวอร์ 8,000 เครื่องในศูนย์ข้อมูลเดียวกันพร้อมการตอบสนองที่รวมอยู่ในหน่วยความจำภายใน 12 วินาที

ปิง

Parallec 2.2 วินาทีเทียบกับ FPing 4.5 วินาทีบนเซิร์ฟเวอร์ 1500 แห่ง Parallec มีความเร็วเป็น 2 เท่าของ FPing (หลังจากการปรับจูนอย่างดีที่สุด: -i 1 -r 0 v3.12) ของการ Ping เซิร์ฟเวอร์ 1500 แห่ง ในขณะที่ได้รับผลลัพธ์ Ping เดียวกัน Parallec ปิงเซิร์ฟเวอร์ 8000 เครื่องภายใน 11.1 วินาทีอย่างรวดเร็ว

ตามปกติ อย่าพึ่งพาตัวเลขเหล่านี้และดำเนินการเปรียบเทียบของคุณเอง

เปรียบเทียบ Parallec กับ REST Commander กับ ThreadPools + Async Client

เมื่อเปรียบเทียบกับโซลูชันที่ใช้ Java Thread Pool แล้ว Parallec ช่วยให้คุณควบคุมการทำงานพร้อมกันได้โดยไม่ต้องกังวล โดยไม่มีข้อจำกัดด้านขนาดเธรด กลุ่มเธรดไม่พอดีเมื่อจำเป็นต้องมีการทำงานพร้อมกัน 1,000 (1,000 เธรด...) หรือต้องการการตั้งค่าการทำงานพร้อมกันที่แตกต่างกันสำหรับแต่ละคำขอ
เมื่อเปรียบเทียบกับโซลูชัน Node.js แบบเธรดเดียว Parallec ช่วยให้สามารถจัดการการตอบสนองที่เน้นการประมวลผลแบบขนานด้วยคอร์หลายคอร์ได้
ปัญหาที่คล้ายกันกับการล็อกล่ามส่วนกลางของ Python และหากต้องการใช้ CPU หลายตัว คุณจะต้องใช้กระบวนการหลายกระบวนการที่มีราคาแพง สิ่งเหล่านี้เหมาะสำหรับ I/O เท่านั้น แต่ไม่มีการประมวลผลการตอบสนองที่เข้มข้นของ CPU

ใน Parallec คุณสามารถจัดการการตอบสนองได้ทั้งใน Worker (ก่อนการรวม: ในแบบคู่ขนาน) หรือใน Manager (หลังการรวม: เธรดเดี่ยว) อ่านเพิ่มเติม..

ติดตามรีวิวงานอื่นๆ ที่เกี่ยวข้องได้ที่นี่

คุณสมบัติ	พาราเล็ค	ผู้บัญชาการส่วนที่เหลือ	เธรดพูล + ไคลเอ็นต์ Async
ไลบรารี่แบบฝังพร้อมอินเทอร์เฟซรูปแบบตัวสร้างที่ใช้งานง่าย
แอปพลิเคชันพร้อมใช้งานพร้อมการส่งคำขอตามตัวช่วยสร้าง GUI และการรวมการตอบสนอง
การควบคุมการทำงานพร้อมกันอย่างง่ายไม่ถูกจำกัดด้วยขนาดเธรด
ตัวจัดการการตอบสนองทันทีโดยไม่ต้องรอการตอบกลับทั้งหมด
ตัวกำหนดเวลางานที่ทราบความจุและการควบคุมความจุทั่วโลก
เสรีภาพโดยรวมในการประมวลผลการตอบสนองและการรวม API: ตัวจัดการการตอบสนองและบริบทการตอบสนองแบบเสียบได้และทั่วไป
ปลั๊กอิน 1 บรรทัดเพื่อเปิดใช้งานการตรวจสอบสิทธิ์ไคลเอ็นต์ SSL
ความครอบคลุมการทดสอบ 90%
โหลดโฮสต์เป้าหมายจากการสืบค้น CMS, เส้นทาง JSON, ข้อความ, รายการ, สตริงจาก URL/local
การทำงานพร้อมกันและการประสานระดับงานสำหรับ Async API: ความคืบหน้าของงานโพลอัตโนมัติ
การกำหนดค่าระดับงานเมื่อหมดเวลาและการแทนที่ Async HTTP Client
การควบคุมงานแบบอะซิงก์และซิงค์พร้อมการสำรวจและยกเลิกความคืบหน้า
SSH แบบขนานที่ปรับขนาดได้พร้อมรหัสผ่านและการเข้าสู่ระบบตามคีย์
ความสามารถในการปรับขนาดและความเร็วที่ได้รับการพิสูจน์แล้วบนโฮสต์เป้าหมายมากกว่า 100,000 รายการในสภาพแวดล้อมการใช้งานจริง
เทมเพลตคำขอทั่วไปที่มีการแทนที่ตัวแปรสำหรับการส่งคำขอที่แตกต่างกันไปยังโฮสต์เป้าหมายเดียวกัน/ต่างกัน
Ping ที่ปรับขนาดได้ด้วยการลองใหม่
TCP/UDP ที่ปรับขนาดได้พร้อมการหมดเวลาที่ไม่ได้ใช้งาน
ตำแหน่งตัวจัดการที่ยืดหยุ่นได้ที่ผู้ปฏิบัติงาน (แบบขนาน) หรือเธรดผู้จัดการ
การรวมการตอบสนองสองระดับนอกกรอบในรหัสสถานะ
ตัดแต่งบันทึกการตอบสนองที่กำหนดค่าได้ในช่วงเวลา
ยกเลิกงานในรายการโฮสต์เป้าหมาย

ปลั๊กอิน

ปลั๊กอินรับรองความถูกต้องไคลเอ็นต์ SSL

เปลี่ยนบันทึก

ผู้ร่วมให้ข้อมูล

เราขอขอบคุณอย่างสุดซึ้งผู้มีส่วนร่วมทุกคนสำหรับความพยายามของพวกเขา

ลูคัส ไครเกอร์ http://stackoverflow.com/users/1240557/kryger
บิลซ์วู
ไฟซาล-ฮามีด
ห้าเล็กq
ไบรอันท์1410
ดีเจกุกส์

ผู้เขียน

Parallec ให้บริการแก่คุณโดย Yuanteng (Jeff) Pei และ Teng Song, Cloud Infrastructure & Platform Services (CIPS) ที่ eBay Inc. (ผู้เขียนต้นฉบับ)

เครดิตและรับทราบ

เราขอขอบคุณผู้จัดการของเรา Andy Santosa ผู้จัดการโครงการ Marco Rotelli บริการโครงสร้างพื้นฐานคลาวด์และแพลตฟอร์ม (CIPS) และฝ่ายกฎหมายสำหรับการสนับสนุนครั้งใหญ่ในโครงการนี้และความพยายามของโอเพ่นซอร์ส
การโพลความคืบหน้าอัตโนมัติได้รับแรงบันดาลใจจากกระแสแสง
เราขอขอบคุณ openpojo และผู้เขียน Osman Shoukry สำหรับความช่วยเหลือของเขาในการทำให้ openpojo เข้าถึงได้มากขึ้นสำหรับเราเพื่อใช้ในโครงการของเรา
เราขอขอบคุณ AsyncHttpClient และ Stephane Landelle สำหรับคำแนะนำ

ผลงาน

ข้อเสนอแนะที่เป็นประโยชน์ใด ๆ ก็ยินดีเป็นอย่างยิ่ง ซึ่งรวมถึงคำขอฟีเจอร์ รายงานข้อบกพร่อง คำขอดึง ความคิดเห็นเชิงสร้างสรรค์ และอื่นๆ คุณต้องยอมรับใน[สิ่งนี้](https://github.com/eBay/parallec/blob/master/CONTRIBUTING.md) ก่อนที่จะส่ง [pull ](https://github.com/eBay/parallec/pulls) คำขอ