aleph

Aleph เปิดเผยข้อมูลจากเครือข่ายเป็นสตรีม Manifold ซึ่งสามารถแปลงเป็น java.io.InputStream , ช่อง core.async ลำดับ Clojure หรือการแสดงไบต์อื่นๆ ได้อย่างง่ายดาย มันเปิดเผย wrappers เริ่มต้นอย่างง่ายสำหรับ HTTP, TCP และ UDP แต่อนุญาตให้เข้าถึงประสิทธิภาพและความยืดหยุ่นเต็มรูปแบบของไลบรารี Netty พื้นฐาน

ไลนิงเกน:

[aleph " 0.8.2 " ]

deps.edn:

aleph/aleph { :mvn/version " 0.8.2 " }
; ; alternatively
io.github.clj-commons/aleph { :git/sha " ... " }

HTTP

เซิร์ฟเวอร์

Aleph ปฏิบัติตามข้อกำหนดของ Ring อย่างครบถ้วน และสามารถทดแทนเซิร์ฟเวอร์ที่เข้ากันได้กับ Ring ที่มีอยู่ได้ อย่างไรก็ตาม ยังอนุญาตให้ฟังก์ชันตัวจัดการส่งคืน Manifold ที่เลื่อนออกไปเพื่อแสดงการตอบสนองในที่สุด คุณลักษณะนี้อาจเล่นได้ไม่ดีนักกับมิดเดิลแวร์ซิงโครนัสริงซึ่งปรับเปลี่ยนการตอบสนอง แต่สามารถแก้ไขได้ง่าย ๆ โดยการปรับใช้มิดเดิลแวร์ใหม่โดยใช้ตัวดำเนินการปล่อยโฟลว์ของ Manifold ตัวช่วย aleph.http/wrap-ring-async-handler สามารถใช้เพื่อแปลงตัวจัดการ Ring ของ async 3-arity ให้เป็นตัวจัดการที่สอดคล้องกับ Aleph

( require '[aleph.http :as http])

( defn handler [req]
  { :status 200
   :headers { " content-type " " text/plain " }
   :body " hello! " })

( http/start-server handler { :port 8080 }) ; HTTP/1-only

; ; To support HTTP/2, do the following:
; ; (def my-ssl-context ...)
( http/start-server handler { :port 443
                            :http-versions [ :http2 :http1 ]
                            :ssl-context my-ssl-context})
; ; See aleph.examples.http2 for more details

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

ลูกค้า

สำหรับคำขอไคลเอ็นต์ HTTP นั้น Aleph จะจำลองตัวเองตาม clj-http ยกเว้นว่าทุกคำขอจะส่งคืน Manifold ที่เลื่อนออกไปทันทีซึ่งแสดงถึงการตอบสนอง

( require
  '[aleph.http :as http]
  '[manifold.deferred :as d]
  '[clj-commons.byte-streams :as bs])

( -> @( http/get " https://google.com/ " )
    :body
    bs/to-string
    prn)

( d/chain ( http/get " https://google.com " )
         :body
         bs/to-string
         prn)

; ; To support HTTP/2, do the following:
( def conn-pool
  ( http/connection-pool { :connection-options { :http-versions [ :http2 :http1 ]}}))
@( http/get " https://google.com " { :pool conn-pool})
; ; See aleph.examples.http2 for more details

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

• ควรตั้งค่าการกำหนดค่าพร็อกซีสำหรับการเชื่อมต่อเมื่อตั้งค่าพูลการเชื่อมต่อ ไม่อนุญาตให้ตั้งค่าพร็อกซีตามคำขอ

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

• :proxy-ignore-hosts ไม่ได้รับการสนับสนุน

• ทั้งมิดเดิลแวร์คุกกี้และการจัดเก็บคุกกี้ในตัวไม่รองรับพารามิเตอร์คุกกี้ที่ล้าสมัยตั้งแต่ RFC2965: ความคิดเห็น, URL ความคิดเห็น, ละทิ้ง, เวอร์ชัน (ดูโครงสร้างทั้งหมดของคุกกี้)

• เมื่อใช้ :debug , :save-request? และ :debug-body? ตัวเลือก คำขอที่เกี่ยวข้องจะถูกเก็บไว้ใน :aleph/netty-request , :aleph/request , :aleph/request-body คีย์ของแผนที่การตอบสนอง

• :response-interceptor

• Aleph แนะนำ :log-activity การกำหนดค่าพูลการเชื่อมต่อเพื่อเปิดการบันทึกการเปลี่ยนแปลงสถานะการเชื่อมต่อ เช่นเดียวกับดัมพ์ฐานสิบหกของคำขอ/การตอบกลับ

• :cache และ :cache-config ตัวเลือกยังไม่รองรับในขณะนี้

ไคลเอนต์ Aleph ยังรองรับตัวแก้ไข DNS แบบอะซิงก์อย่างสมบูรณ์และปรับแต่งได้สูง

หากต้องการเรียนรู้เพิ่มเติม โปรดอ่านโค้ดตัวอย่าง

HTTP/2

ตั้งแต่เวอร์ชัน 0.7.0 Aleph รองรับ HTTP/2 ทั้งในไคลเอนต์และเซิร์ฟเวอร์

โดยส่วนใหญ่แล้ว การรองรับ HTTP/2 ของ Aleph เป็นการทดแทน HTTP/1 แบบดรอปอิน สำหรับความเข้ากันได้แบบย้อนหลัง Aleph จะใช้ค่าเริ่มต้นเป็น HTTP/1 เท่านั้น ดูโค้ด HTTP/2 ตัวอย่างเพื่อดูภาพรวมที่ดีในการเริ่มต้นใช้งาน HTTP/2

สิ่งที่ต้องระวัง:

1. การอัปโหลดแบบหลายส่วนยังไม่รองรับ HTTP/2 เนื่องจาก Netty ไม่รองรับการอัปโหลดแบบหลายส่วนภายใต้ HTTP/2 สำหรับการพัฒนาใหม่ ให้เปิดสตรีม/คำขอ H2 ใหม่สำหรับแต่ละไฟล์แทน (โดยทั่วไป HTTP/2 ไม่จำเป็นต้องมีหลายส่วน เนื่องจากไม่มีข้อจำกัดด้านจำนวนการเชื่อมต่อเช่นเดียวกับ HTTP/1) สำหรับโค้ดหลายส่วนที่มีอยู่ ให้ใช้ HTTP/1 ตามหลักการแล้ว สิ่งนี้จะถูกเพิ่มในรุ่นต่อๆ ไป
2. ขณะนี้ Aleph ไม่รองรับวิธี CONNECT ภายใต้ HTTP/2 ยึดติดกับ HTTP/1 หากคุณใช้ CONNECT
3. Aleph จะไม่รองรับการพุชเซิร์ฟเวอร์ HTTP/2 เนื่องจาก Chrome เลิกใช้แล้วและปิดการใช้งานอย่างมีประสิทธิภาพ
4. ขณะนี้ Aleph ไม่รองรับตัวอย่าง HTTP/2 (ส่วนหัวมาถึงหลังส่วนเนื้อหา)
5. Aleph ไม่ได้ทำอะไรเลยกับข้อมูลลำดับความสำคัญ เราต้องการเปิดเผย API เพื่อรองรับการใช้การจัดลำดับความสำคัญของผู้ใช้ แต่เบราว์เซอร์ไม่เคยเห็นด้วยกับวิธีการตีความ และบางส่วน (เช่น Safari) ไม่เคยใช้อย่างมีประสิทธิภาพ เราคิดว่าการย้ายส่วนหัวลำดับความสำคัญ HTTP/3 กลับไปเป็น HTTP/2 ถือเป็นเป้าหมายที่ดีกว่า
6. ปัจจุบัน Aleph ใช้การควบคุมโฟลว์เริ่มต้นของ Netty นี่คือหน้าต่างขนาด 64 kb ซึ่งจะมีการตอบรับไบต์ทันทีที่ได้รับ เราวางแผนที่จะเพิ่มการสนับสนุนสำหรับการปรับขนาดหน้าต่างเริ่มต้นและกลยุทธ์การควบคุมโฟลว์ในรุ่นอนาคต
7. หากคุณใช้ pipeline-transform เพื่อแก้ไขไปป์ไลน์ Netty คุณจะต้องตรวจสอบการใช้งาน HTTP/2 ของคุณ ภายใต้ฝากระโปรง รหัส HTTP/2 ใหม่ใช้การตั้งค่าไปป์ไลน์แบบมัลติเพล็กซ์ของ Netty โดยมีไปป์ไลน์ระดับการเชื่อมต่อที่ใช้ร่วมกันที่ฟีดเฟรมเฉพาะสตรีมไปยังไปป์ไลน์ N ที่สร้างขึ้นสำหรับสตรีม N รายการแต่ละรายการ (คู่คำขอ/การตอบกลับ HTTP มาตรฐานแมปกับสตรีม H2 เดียว)

เว็บซ็อกเก็ต

ในคำขอ HTTP ใดๆ ที่มีส่วนหัว Upgrade ที่เหมาะสม คุณสามารถเรียก (aleph.http/websocket-connection req) ซึ่งส่งคืนการเลื่อนออกไปซึ่งให้ผล สตรีมดูเพล็กซ์ ซึ่งใช้สตรีมเดี่ยวเพื่อแสดงการสื่อสารแบบสองทิศทาง สามารถรับข้อความจากลูกค้าผ่านทาง take! และส่งให้ลูกค้าทาง put! - ตัวจัดการ echo WebSocket จะประกอบด้วย:

( require '[manifold.stream :as s])

( defn echo-handler [req]
  ( let [s @( http/websocket-connection req)]
    ( s/connect s s)))

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

ไคลเอนต์ WebSocket สามารถสร้างได้ผ่าน (aleph.http/websocket-client url) ซึ่งส่งคืนการเลื่อนออกไปซึ่งให้ผลสตรีมดูเพล็กซ์ที่สามารถส่งและรับข้อความจากเซิร์ฟเวอร์

หากต้องการเรียนรู้เพิ่มเติม โปรดอ่านโค้ดตัวอย่าง

TCP

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

เซิร์ฟเวอร์ echo TCP คล้ายกับตัวอย่าง WebSocket ข้างต้นมาก:

( require '[aleph.tcp :as tcp])

( defn echo-handler [s info]
  ( s/connect s s))

( tcp/start-server echo-handler { :port 10001 })

สามารถสร้างไคลเอนต์ TCP ได้ผ่าน (aleph.tcp/client {:host "example.com", :port 10001}) ซึ่งส่งคืนการเลื่อนออกไปซึ่งให้ผลสตรีมดูเพล็กซ์

หากต้องการเรียนรู้เพิ่มเติม โปรดอ่านโค้ดตัวอย่าง

ยูดีพี

ซ็อกเก็ต UDP สามารถสร้างขึ้นได้โดยใช้ (aleph.udp/socket {:port 10001, :broadcast? false}) หากระบุ :port มันจะให้ผลลัพธ์ซ็อกเก็ตดูเพล็กซ์ซึ่งสามารถใช้เพื่อส่งและรับข้อความ ซึ่งมีโครงสร้างเป็นแมปที่มีข้อมูลต่อไปนี้:

{ :host " example.com "
 :port 10001
 :message ...}

โดยที่แพ็กเก็ตขาเข้าจะมี :message ที่เป็นไบต์อาร์เรย์ ซึ่งสามารถบังคับได้โดยใช้ byte-streams และแพ็กเก็ตขาออกอาจเป็นข้อมูลใดๆ ที่สามารถบีบบังคับให้เป็นตัวแทนไบนารีได้ หากไม่ได้ระบุ :port ไว้ ซ็อกเก็ตจะสามารถใช้เพื่อส่งข้อความเท่านั้น

หากต้องการเรียนรู้เพิ่มเติม โปรดอ่านโค้ดตัวอย่าง

การพัฒนา

Aleph ใช้ Leiningen ในการจัดการการขึ้นต่อกัน เรียกใช้ REPL และการทดสอบ และสร้างโค้ด

การสนับสนุน tools.deps ขั้นต่ำมีอยู่ในรูปแบบของไฟล์ deps.edn ซึ่งสร้างจาก project.clj ให้เพียงพอที่จะใช้ Aleph เป็นการพึ่งพา git หรือ :local/root เมื่อคอมมิตการเปลี่ยนแปลง project.clj ให้รัน deps/lein-to-deps และคอมมิตการเปลี่ยนแปลงผลลัพธ์ด้วย

ใบอนุญาต

ลิขสิทธิ์ © 2010-2024 แซคารี เทลแมน

เผยแพร่ภายใต้ใบอนุญาต MIT

สนับสนุน

ขอขอบคุณ YourKit มากที่สนับสนุน Aleph YourKit รองรับโครงการโอเพ่นซอร์สด้วยเครื่องมือที่เป็นนวัตกรรมและชาญฉลาดสำหรับการตรวจสอบและจัดทำโปรไฟล์แอปพลิเคชัน Java และ .NET

YourKit เป็นผู้สร้าง YourKit Java Profiler, YourKit .NET Profiler และ YourKit YouMonitor