Hacker DirectoryHacker Directory
Öğrenmeye devam et
ENHTML kaydet ↓

WEB / WEB-16.01

Web server, runtime ve execution model

HTTP connection’ı karşılayan server ile uygulama kararını çalıştıran runtime aynı rol değildir. Bir request’i proxy’den callback’e kadar izle.

CORE · RED · BLUE · ARTIFACT · PRACTICE

1. Core · Mekanizma

Hareket olmadan bütün senaryoları oku

Proxy upstream

  1. Public read hazır

    Duru GET /notes request’ini hazırlar; edge ve application henüz request’i almamıştır.

    Client / Duru
    GET /notes ready
    Edge server
    Request yok
    Application runtime
    Request yok
    Execution state
    Handler yok
  2. Edge’e ulaştı

    Client GET edge’e ulaşır; upstream henüz request almamıştır ve önceki state’ini korur.

    Client / Duru
    Response bekliyor
    Edge server
    GET alındı
    Application runtime
    Request yok
    Execution state
    Handler yok
  3. Upstream seçimi

    Edge routing kuralına göre /notes request’ini upstream’e iletmeyi hazırlar; bu local karardır.

    Client / Duru
    Response bekliyor
    Edge server
    Upstream seçildi
    Application runtime
    Request yok
    Execution state
    Handler yok
  4. Upstream’e ulaştı

    İkinci HTTP GET application runtime’a ulaşır; bu ayrı hop’tur, aynı process içindeki callback çağrısı değildir.

    Client / Duru
    Response bekliyor
    Edge server
    Upstream bekleniyor
    Application runtime
    GET /notes alındı
    Execution state
    Handler bekliyor
  5. Local handler

    Runtime’daki local handler Runtime note response’unu üretir; content uzunluğu 12 UTF-8 byte’dır.

    Client / Duru
    Response bekliyor
    Edge server
    Upstream bekleniyor
    Application runtime
    200 response hazır
    Execution state
    Handler result Runtime note
  6. Upstream response

    Application’ın 200 response’u ve body’si edge’e ulaşır; client henüz response almamıştır.

    Client / Duru
    Response bekliyor
    Edge server
    200 Runtime note alındı
    Application runtime
    Response delivered upstream hop
    Execution state
    Handler tamamlandı
  7. Client’a ulaştı

    Edge’in 200 response’u ve body’si client’a ulaşır; iki HTTP hop’un completion sonuçları ayrı tutulur.

    Client / Duru
    200 Runtime note alındı
    Edge server
    Response delivered client hop
    Application runtime
    Upstream exchange tamam
    Execution state
    Handler tamamlandı

Edge static

  1. Static read hazır

    Client public /static/note read request’ini hazırlar; application’a iletilmiş request yoktur.

    Client / Duru
    Static GET hazır
    Edge server
    Request yok
    Application runtime
    Request yok
    Execution state
    Kullanılmadı
  2. Edge’e ulaştı

    GET edge’e ulaşır; routing kuralı bu path için edge’in static serving rolünü seçer.

    Client / Duru
    Response bekliyor
    Edge server
    Static GET alındı
    Application runtime
    Request yok
    Execution state
    Kullanılmadı
  3. Local static read

    Edge kendi static kaynağından Static note response’unu üretir; upstream’e request iletilmez.

    Client / Duru
    Response bekliyor
    Edge server
    200 Static note hazır
    Application runtime
    Request yok
    Execution state
    Static kaynak hazır
  4. Client’a ulaştı

    Static 200 response’u ve body’si client’a ulaşır; application runtime bu exchange’e katılmaz.

    Client / Duru
    200 Static note alındı
    Edge server
    Client response aldı
    Application runtime
    Request yok
    Execution state
    Static kaynak hazır
  5. Content kaynağı

    Client 200 Static note body’sini almıştır. Upstream’e gidilmediği, bu örneğin edge routing kararıyla bilinir; client’ın yalnız status ve body görmesi application handler’ının çalışıp çalışmadığını kanıtlamaz. Bu sahne DOM veya piksel görünümü çizmez.

    Client / Duru
    200 Static note alındı
    Edge server
    Exchange tamamlandı
    Application runtime
    Request yok
    Execution state
    Static kaynak kaydedildi

Async CPU bölümü

  1. Sınırlı CPU işi

    Örnekteki Node callback bağlamında 10000 terimli toplam işi ve sırada bekleyen event callback hazırlanır.

    Client / Duru
    HTTP modellenmiyor
    Edge server
    Kullanılmadı
    Application runtime
    İş hazır; event sırada
    Execution state
    Toplam bekliyor
  2. Async giriş

    Async function ilk await’e ulaşmadan CPU bölümünü çalıştırır; sıradaki callback bu synchronous bölümün arasına girmez.

    Client / Duru
    HTTP modellenmiyor
    Edge server
    Kullanılmadı
    Application runtime
    cpu-start; main JS active
    Execution state
    Hesap sürüyor
  3. Hesap tamamlandı

    1..10000 toplamı 50005000 olarak tamamlanır; bu sonuç başka CPU’da çalışıldığı veya süre ölçüldüğü anlamına gelmez.

    Client / Duru
    HTTP modellenmiyor
    Edge server
    Kullanılmadı
    Application runtime
    cpu-end; main JS active
    Execution state
    Toplam: 50005000
  4. Caller devam eder

    Function Promise döndürdükten sonra caller-after-call kaydı oluşur; synchronous hesap zaten bitmiştir.

    Client / Duru
    HTTP modellenmiyor
    Edge server
    Kullanılmadı
    Application runtime
    caller-after-call
    Execution state
    Toplam: 50005000
  5. Await continuation

    Örnekteki execution bağlamında resolved result’ın await continuation’ı, sıradaki event callback’ten önce çalışır.

    Client / Duru
    HTTP modellenmiyor
    Edge server
    Kullanılmadı
    Application runtime
    caller-after-await
    Execution state
    Toplam: 50005000
  6. Sıradaki callback

    Event callback synchronous CPU bölümü bittikten sonra çalışır; async keyword otomatik parallel execution sağlamaz.

    Client / Duru
    HTTP modellenmiyor
    Edge server
    Kullanılmadı
    Application runtime
    event-callback observed
    Execution state
    Toplam: 50005000; süre ölçülmedi

ROLLER · STATE · VERİ AKIŞI

Server rolleri ürün adlarıyla sınırlı değildir

Web server, HTTP request kabul edip uygun response veren rolü anlatır: static content sunabilir veya işi uygulamaya aktarabilir. Application server ise request’i uygulama mantığına bağlayıp sonucu üretir. Bu roller her zaman iki makine, iki process veya iki ayrı ürün gerektirmez. Node http.createServer callback’i sayesinde aynı process hem HTTP server hem uygulamanın çalışma ortamı olabilir. Framework routing ve middleware düzenini sağlar; runtime’ın code execution ve I/O yeteneklerinin yerine geçmez.

Duru public /notes route’unu istediğinde edge server request’i upstream’e aktarır; application runtime Runtime note response’unu üretir. /static/note route’unda ise edge Static note’u kendisi döndürür ve application’a request gitmez. Bu iki davranış aynı dış origin altında bulunabilir. “Her response backend business logic’ten geldi” veya “web server yalnız dosya sunar” genellemeleri aradaki farkı kaybettirir.

Python HTTPServer socket’i dinleyip request’i handler’a yönlendirir; ThreadingHTTPServer ise ThreadingMixIn ile thread tabanlı request handling kullanır. Bu, bütün Python uygulamalarının aynı execution model’e sahip olduğu anlamına gelmez. Web server veya application server etiketi de hangi process’in hangi port’u dinlediğini, hangi runtime’ın code çalıştırdığını tek başına söylemez.

Reverse proxy ikinci bir HTTP hop açar

Reverse proxy client request’ini kabul eder, seçtiği upstream’e kendi request’ini gönderir, upstream response’unu alır ve client’a response verir. Client→edge ile edge→application ayrı exchange’lerdir; aynı socket veya aynı process içindeki function call değildir. Örnekte method, path ve body içeriği korunur. Gerçek proxy ayrıca URI mapping, cache, buffering veya connection policy uygulayabilir; davranış configuration’a bağlıdır.

TLS termination yapan edge ile plaintext upstream aynı confidentiality sınırını sağlamaz. Bu örneğin local HTTP hop’ları TLS yapılandırmasını ölçmez. Proxy’nin request’i yönlendirmesi application user/object authorization’ını da otomatik tamamlamaz. Identity ve forwarded metadata’nın hangi trust boundary’de kabul edildiği ayrıca tanımlanır; bu dersin odak noktası bu metadata’dan önceki hop ve execution ayrımıdır.

Edge Static note response’u için upstream’e gitmez. Normal proxy akışında ise Runtime note edge’e ulaşmışken client henüz response’u almamış olabilir. Sahne iki arrival anını ayrı tutar. Edge’in request’i görmesi handler’ın çalıştığını veya Browser’ın body’yi tükettiğini tek başına kanıtlamaz.

Async iş CPU paralelliği değildir

Node’un varsayılan JavaScript callback’leri tek event-loop thread’inde çalışır. Uygun network I/O işleri kernel’e, bazı filesystem/crypto işlemleri libuv worker pool’a bırakılabilir. Ancak uygulamanın yazdığı uzun JavaScript loop’u kendiliğinden pool’a taşınmaz. async function ilk await’e kadar synchronous code çalıştırır; Promise döndürmek bu bölümün başka CPU’da koşmasını sağlamaz.

Artifact’te 1..10000 toplamı 50005000’dur. Örnekteki async function bu sınırlı hesabı await olmadan bitirir; sıradaki event callback synchronous bölümün ortasında çalışmaz. Buradan süre veya throughput sonucu çıkarılmaz. CPU-intensive JavaScript için worker_threads gibi ayrı execution seçenekleri vardır; thread/pool maliyeti ve sonuç messaging’i ayrıca tasarlanır. Daha çok process veya thread sınırsız kapasite ya da doğru shared-state davranışı garantisi değildir.

Process kendi application memory state’ini taşır; ayrı process’te local variable değiştirmek parent değişkenini otomatik değiştirmez. Thread aynı process kaynaklarını kullanabilir, fakat her JavaScript Worker ayrı global/state taşıyabilir; paylaşım ve transfer için explicit mekanizmalar gerekir. Worker_threads, libuv worker pool ve Browser Web Worker aynı API değildir. Replica’lar arasında state paylaşılacaksa in-memory değişken yerine ownership ve store sözleşmesi açıkça belirlenir.

2. Red · Güven ve etki

Hareket olmadan bütün senaryoları oku

Async CPU

  1. Async computation seçildi

    Fixture async function içinde ilk await olmadan 1..10000 toplamını hesaplar. Async keyword tek başına CPU paralelliği yaratmaz.

    Call/route context
    Async function
    Runtime/edge owner
    CPU başlamadı
    Callback/policy boundary
    Callback bekliyor
  2. Synchronous bölüm başladı

    Trace cpu-start ile başlar. Bu bölüm mevcut JavaScript execution’da çalışır; callback henüz araya girmiş değildir.

    Call/route context
    Call continuation bekliyor
    Runtime/edge owner
    cpu-start
    Callback/policy boundary
    Callback bekliyor
  3. Bounded CPU bölümü tamamlandı

    cpu-end sonucu sum=50005000’dur. Promise döndürülmesi computation’ı ayrı thread’e taşımış değildir.

    Call/route context
    Call continuation bekliyor
    Runtime/edge owner
    cpu-end; sum=50005000
    Callback/policy boundary
    Callback bekliyor
  4. Caller continuation ayrıldı

    caller-after-call ardından caller-after-await görülür. Await’in bulunması önceki synchronous CPU bölümünü geriye dönük nonblocking yapmaz.

    Call/route context
    caller-after-await
    Runtime/edge owner
    CPU tamamlandı
    Callback/policy boundary
    Callback bekliyor
  5. Queued callback daha sonra çalıştı

    event-callback trace’in sonundadır. Bu seçili sıralama durationMs=null kaldığı için production latency ölçümü değildir.

    Call/route context
    Caller ilerledi
    Runtime/edge owner
    CPU tamamlandı
    Callback/policy boundary
    event-callback
  6. Capacity kontrolü gerçek modele bağlı kaldı

    Callback işi bounded tutulmalıdır; CPU ownership gerektiğinde ayrı worker’a verilir. Fixture’da parallelCPUClaim=false kalır ve yük saldırısı çalıştırılmaz.

    Call/route context
    Execution order known
    Runtime/edge owner
    Automatically parallel=false
    Callback/policy boundary
    Latency/capacity not measured

Static role

  1. Static response rolü seçildi

    Duru /static/note yolunu seçer. Bu public örnekte response sahibi edge’dir; uygulama handler’ı otomatik çağrılmaz.

    Call/route context
    /static/note
    Runtime/edge owner
    Route incelenmedi
    Callback/policy boundary
    Application sonucu yok
  2. Static route sonucu okundu

    staticExchange upstreamReached=false taşır. Edge’in content sunması Node application’da identity veya object policy çalıştığını kanıtlamaz.

    Call/route context
    /static/note
    Runtime/edge owner
    Static owner: edge
    Callback/policy boundary
    Upstream not reached
  3. Representation public kapsamıyla ayrıldı

    Body Static note ve responseStatus=200’dür. Bu normal public response, personalized veri için aynı serving contract’ın güvenli olduğunu göstermez.

    Call/route context
    Public static representation
    Runtime/edge owner
    Status=200; 11 content octets
    Callback/policy boundary
    Application policy not shown
  4. Status authority’ye çevrilmedi

    Edge 200 sonucu yalnız seçilen static representation’ı açıklar. Application permission kontrolü veya session acceptance bu status’tan türetilmez.

    Call/route context
    Public static representation
    Runtime/edge owner
    Edge source known
    Callback/policy boundary
    No inferred authenticated grant
  5. Sensitive route sözleşmesi ayrı tutuldu

    Personalized response için route owner, identity ve resource policy açık tasarlanmalıdır. Bir ürünün proxy veya web server adı bu contract’ın kanıtı değildir.

    Call/route context
    Public static fixture only
    Runtime/edge owner
    Route boundary explicit
    Callback/policy boundary
    Sensitive policy requires separate evidence
  6. Serving hükmü source’uyla kapandı

    Bu case static branch’in no-upstream sonucunu açıklamaktadır. Eksik application log’unu tek başına no-upstream kanıtı sayan genel kural kurulmaz.

    Call/route context
    Known: static branch
    Runtime/edge owner
    Known: no upstream dispatch
    Callback/policy boundary
    No application authorization claim

VARSAYIM · SINIR · KONTROL

Paylaşılan execution kapasitesinin sınırı

Bir handler’ın synchronous JavaScript işi aynı event-loop callback queue’sunu geciktirebilir. Yanlış varsayım, async keyword’ünün bütün işi nonblocking yaptığı düşüncesidir. Normal bir hesap yeterince büyüdüğünde başka request’lerin ilerlemesini etkileyebilir. Availability etkisi runtime, concurrency ve iş miktarına bağlıdır; bu küçük 10000 terimli örnekten production latency veya kapasite sonucu çıkarılamaz.

Kontrol, callback içindeki işi sınırlamak ve I/O ile CPU işini uygun execution mekanizmasına vermektir. Worker pool’un da kapasitesi vardır; her iş için yeni thread açmak otomatik çözüm değildir. Worker kullanılıyorsa sonuç correlation’ı ve lifecycle açık olmalı, memory’nin bütün replica’larda ortak olduğu varsayılmamalıdır. Bir process’in state’inin diğerine görünmemesi tek başına data loss veya compromise kanıtı değildir.

Content’i hangi bileşenin ürettiğini ayır

Static response’u application permission kontrolünden geçmiş sonuç saymak, hop ile handler’ın görevlerini karıştırır. Public Static note için edge’in doğrudan response vermesi normaldir. Personalized data’da ise aynı varsayım confidentiality veya stale-result konusunda yanlış sonuca götürebilir. Edge cache/route seçimi application policy uygulayacaksa bu sorumluluk açıkça tanımlanmalıdır. Ürün adı veya edge’den gelen 200 status bu sözleşmenin kanıtı değildir.

Proxy’nin request’i başarıyla iletmesi upstream failure veya client’a tamamlanmamış response olasılığını ortadan kaldırmaz. Request ID gibi correlation metadata’sını hop bazında izle; content kaynağını static veya upstream diye ayır ve response arrival anlarını ayrı oku. Böylece hangi bileşenin sonucu ürettiğiyle hangi bileşenin sonucu aldığı aynı success etiketi altında kaybolmaz.

3. Blue · Güvenli geliştirme ve savunma

Hareket olmadan bütün senaryoları oku

Response hop’ları

  1. Proxy exchange evidence seçildi

    proxyExchange /notes için clientPath ve upstreamPath alanlarını taşır. Client status ile upstream observation aynı gözlem noktası değildir.

    Runtime observation
    Proxy exchange /notes
    Hop/process review
    Hop map incelenmedi
    Evidence scope
    Client knowledge okunmadı
  2. Upstream dispatch alanı okundu

    upstreamReached=true bu branch için routing sonucudur. Correlation kaydı eksik olsa bile yalnız log yokluğundan bunun false olduğu sonucu verilmez.

    Runtime observation
    Proxy exchange /notes
    Hop/process review
    Upstream reached=true
    Evidence scope
    Client knowledge okunmadı
  3. Body source ve byte hesabı ayrıldı

    Runtime note representation’ı 12 UTF-8 content octet’tir. Bu sayı HTTP wrapper, header veya network packet boyutu değildir.

    Runtime observation
    Runtime note
    Hop/process review
    Content octets=12
    Evidence scope
    Body source: runtime
  4. Response arrival sırası karşılaştırıldı

    upstreamArrivalBeforeClientArrival=true bu iki-hop örneğin sırasını açıklar. Edge’in response alması henüz client’ın body’yi öğrendiği an değildir.

    Runtime observation
    Declared proxy exchange
    Hop/process review
    Upstream arrival before client
    Evidence scope
    Knowledge boundaries separate
  5. Browser render evidence eklenmedi

    Response status/body declaration DOM veya piksel görünümünü göstermez. Runtime, edge ve browser observation’ları kendi source’larıyla ilişkilendirilir.

    Runtime observation
    Status/body declared
    Hop/process review
    Hop ordering declared
    Evidence scope
    UNKNOWN: DOM/pixels
  6. Proxy evidence kapsamı kapandı

    Bu defter normal forwarding owner’larını açıklar; bütün production proxy erişim log’u şeması veya throughput sonucu değildir.

    Runtime observation
    Known: runtime body source
    Hop/process review
    Known: selected hop order
    Evidence scope
    Runtime/browser generalization withheld

Process memory

  1. Process state gözlemi seçildi

    memory fixture proc-main ve proc-child için ayrı aliases kullanır. İki process’in ordinary object’leri aynı mutable state değildir.

    Runtime observation
    proc-main / proc-child
    Hop/process review
    State okunmadı
    Evidence scope
    Shared-memory evidence yok
  2. Başlangıç parent state okundu

    parentStateBefore=7 kaydı parent ownership’ini açıklar. Child’ın yapacağı update parent’a otomatik aktarılacak diye varsayılmaz.

    Runtime observation
    Parent before=7
    Hop/process review
    Child separate process
    Evidence scope
    Shared-memory evidence yok
  3. Child sonucu ayrı okundu

    childStateAfter=42 olur. Bu ordinary state değişimi child’ın kendi process alanındadır; ortak store veya explicit message sonucu olarak gösterilmez.

    Runtime observation
    Parent before=7
    Hop/process review
    Child after=42
    Evidence scope
    SharedMemoryUsed=false
  4. Parent after state karşılaştırıldı

    parentStateAfter=7 kalır. Child’ın değişikliği parent’ı değiştirmemiştir; bu sonucu tek başına data loss veya compromise diye adlandırmak yanlıştır.

    Runtime observation
    Parent after=7
    Hop/process review
    Child after=42
    Evidence scope
    Ownership scope consistent
  5. Worker ve process rolleri eşitlenmedi

    Worker thread, ayrı process ve shared memory farklı seçimlerdir. Bu fixture separate process ve sharedMemoryUsed=false ile sınırlıdır.

    Runtime observation
    Separate-process profile
    Hop/process review
    No implicit shared object
    Evidence scope
    Other IPC/worker behavior unknown
  6. Memory hükmü kendi sınırında kaldı

    Seçilen before/after state’ler ownership ayrımını destekler. Replicas, durable store, restart recovery veya bütün cancellation davranışı bu iki sayıdan çıkarılmaz.

    Runtime observation
    Known: parent retained 7
    Hop/process review
    Known: child reached 42
    Evidence scope
    No distributed durability claim

UYGULAMA · GÜVENLİK KONTROLÜ · DOĞRULAMA

Role ve hop akışını çıkar

İlk gözlem, dinleyen endpoint ile request’in yönlendirildiği bileşendir. /notes için edge ve application’daki request correlation’ı aranır; /static/note için application request count’unun artmaması beklenir. Client status/body ile edge’in upstream gözlemi farklı telemetry noktalarıdır. Native API event adları gerçek proxy access-log şeması değildir; field mapping kullanılan server ürününe bağlıdır.

Request callback’inde method/path, response status ve byte sayısını ayrı oku. Runtime note UTF-8 content’i 12 byte’dır; hangi hop’un ürettiğini ve uzunluğun hangi encoded content’e ait olduğunu koru. WEB-16.03 response finish ile client arrival ayrımını açar. Correlation kaydı eksikse upstream hiç çalışmadı sonucunu otomatik üretme. Static akışındaki no-upstream sonucu ise server routing kararıyla desteklenir.

Execution model ile ölçüm sonucunu ayır

CPU örneğinde async function giriş/çıkışını, caller continuation’ı ve queued callback sırasını izle. 1..10000 toplamını bağımsız n(n+1)/2 hesabıyla karşılaştır; doğruluk ölçütü “hızlı göründü” değildir. Queue gecikmesini production latency diye yorumlamak için gerçek workload ve zaman ölçümü gerekir. Küçük, sınırlı hesap yalnız async code’un synchronous bölümünü açıklar.

Memory ownership için parent state’in 7, ayrı process state’inin 42 olduğu gözlemler birbirinden ayrılır. Correlation için gerçek PID yerine uygun referanslar kullanılabilir; thread/worker API’si ise açıkça adlandırılır. Shared memory yoksa bir object mutation bütün process’lerin ortak state’i değildir. Uzun hesap worker’a taşınacaksa normal result, cancellation ve worker failure sınırları da tasarlanır; yalnız async eklemek bu lifecycle’ı kurmaz.

Artifact XPath’i synchronousCPU=true ile automaticallyParallel=true birlikte yazılmış work kayıtlarını sayar. Normal async CPU kaydında sonuç 0, yanlış parallel yorumunu içeren kontrol kaydında 1’dir. XML bu örneğin eğitim şemasıdır; event-loop telemetry kaynağı değildir. Work elementi eksikken count=0 çıkması da runtime davranışının doğru olduğunu kanıtlamaz.

Execution maliyetini request sınırında yönet

Async sözcüğü CPU maliyetini ortadan kaldırmaz. Request’in kabul edilen boyutunu ve yapılacak işin üst sınırını handler’dan önce belirle; event loop üzerinde süresi belirsiz büyük hesap başlatma. Network ve disk I/O için uygun asynchronous API kullanılırken CPU işi ayrı bir worker havuzuna alınabilir. Havuzun bekleyen iş sayısı, süre sınırı ve hata davranışı da sınırlı olmalıdır; sınırsız worker açmak güvenli bir kapasite politikası değildir.

Bu örnekte 1..10000 hesabının doğru toplamı ve callback sırası, seçilen küçük işi açıklar. Sınırı aşan işte handler veya worker’a dispatch yapılmadığını ayrıca doğrula; worker hatasında normal sonuç üretme. Kabul edilen işin sonucu ile queue gecikmesini ayrı gözle. Dispatch ya da completion kaydı eksikse iş yapılmadı sonucuna atlama. Buradaki sıralama kaydı gerçek hizmetin kapasitesini, zaman aşımı uygulamasını veya worker izolasyonunu ölçmez.

ŞİMDİ VAKAYA UYGULA

Async keyword ve edge response hangi authority’yi vermez?

Bounded CPU trace ve public static route iki farklı execution sınırı gösterir. Hop source ve process memory ownership kendi evidence’ıyla okunur.

Vakadaki input, server işleme ve response için karar sırasını çıkar. Parsed veya valid data ile completed operation aynı sonuç değildir; hangi owner’ın hangi koşulu değerlendirdiğini belirt.

Bağlı vaka dosyasını aç ↗

ÖRNEĞİ BİRLİKTE OKUYALIM

Server rolü ve execution defteri

Bir alan seç; hangi sonucu desteklediğini ve nerede yetersiz kaldığını incele.

Ham kaydı ve alan açıklamalarını oku
{
  "roles": {
    "client": "Duru",
    "edge": "HTTP reverse-proxy or static-serving role",
    "runtime": "Node application execution role",
    "framework": "not installed; manual handler organization"
  },
  "proxyExchange": {
    "clientPath": "/notes",
    "upstreamPath": "/notes",
    "upstreamReached": true,
    "responseStatus": 200,
    "body": "Runtime note",
    "contentOctets": 12,
    "upstreamArrivalBeforeClientArrival": true
  },
  "staticExchange": {
    "clientPath": "/static/note",
    "upstreamReached": false,
    "responseStatus": 200,
    "body": "Static note",
    "contentOctets": 11
  },
  "cpu": {
    "n": 10000,
    "sum": 50005000,
    "asyncFunctionFirstAwaitAbsent": true,
    "selectedTrace": [
      "cpu-start",
      "cpu-end",
      "caller-after-call",
      "caller-after-await",
      "event-callback"
    ],
    "parallelCPUClaim": false,
    "durationMs": null
  },
  "memory": {
    "parentProcessAlias": "proc-main",
    "separateProcessAlias": "proc-child",
    "parentStateBefore": 7,
    "childStateAfter": 42,
    "parentStateAfter": 7,
    "sharedMemoryUsed": false
  },
  "selector": {
    "language": "XPath",
    "xml": "<observations><work async=\"true\" synchronousCPU=\"true\" automaticallyParallel=\"false\"/></observations>",
    "xpath": "count(/observations/work[@synchronousCPU=\"true\" and @automaticallyParallel=\"true\"])",
    "expected": 0,
    "positiveFixtureXml": "<observations><work async=\"true\" synchronousCPU=\"true\" automaticallyParallel=\"true\"/></observations>",
    "positiveExpected": 1,
    "scope": "Only authored protocol-decision observations, not product log field names or a live HTTP capture.",
    "missingFieldBehavior": "Missing observation is insufficient evidence; zero matches is not proof of correct runtime behavior."
  }
}
roles
HTTP serving, runtime ve framework rolleri aynı ürün veya process olmak zorunda değildir.
proxyExchange / staticExchange
Upstream arrival ile edge’in kendi ürettiği response farklı yollardır.
cpu / memory
Sınırlı toplam hesabı ve callback sırası, process memory ownership’inden ayrı okunur.

Public-note akışını anlatan inert defterdir. Callback sırası örnekteki execution bağlamına aittir; TLS, production kapasitesi veya genel process isolation ölçümü değildir.

İki yanlış kanı

async function uzun CPU loop’unu otomatik başka thread’e taşır.

İlk await’e kadar JavaScript synchronous çalışır; CPU worker execution ayrı seçimdir.

Web server ve application server her zaman ayrı makinelerdir.

Bunlar rollerdir; aynı process iki rolü taşıyabilir veya reverse proxy ayrı hop açabilir.

SIRA SENDE

Bu hikâyeyi sen çöz.

Sonucu tahmin et, kanıtın sınırını bul ve nedenini kendi cümlenle anlat.

async function ilk await’e kadar CPU hesabı yapıyor. caller-before-call ile caller-after-call arasında otomatik parallel CPU çalışması var mı?

  1. Evet. async etiketi bütün function body’yi worker thread’e taşır.
  2. Hayır. cpu-start ve cpu-end, caller-after-call’dan önce.
Gerekçeli cevabı oku

Hayır. cpu-start ve cpu-end, caller-after-call’dan önce. — async keyword, senkron CPU işini başka thread’e taşımaz. Bu izde caller ilerlemeden CPU bölümü tamamlanır; parallelCPUClaim=false.

Child process state değerini 42 yaptı. Parent state neden 7 olarak kaldı?

Dersten seçilen artifact alanları; öğretim örneği

memory
{"parentProcessAlias":"proc-main","separateProcessAlias":"proc-child","parentStateBefore":7,"childStateAfter":42,"parentStateAfter":7,"sharedMemoryUsed":false}
  1. State’ler process’e ait; sharedMemoryUsed=false.
  2. Aynı application adı bütün process’lere tek heap verir.
Gerekçeli cevabı oku

State’ler process’e ait; sharedMemoryUsed=false. — Child’ın yerel state değişikliği parent’ın object’ini değiştirmez. IPC veya shared memory ayrıca kurulmalıdır.

Static serving ile reverse-proxy akışındaki upstreamReached farkı neyi gösterir? Server role’leri neden host sayısı değildir?

Gerekçeli cevabı oku

Static branch’te edge body’yi upstream’e gitmeden sunar. Proxy branch’te upstream response önce edge’e, sonra client’a ulaşır. Web server ile application runtime aynı veya farklı process/host’larda yer alabilir. Elle düzenlenmiş handler’lar, framework kurulduğunu göstermez; CPU hesabının sırası da performans benchmark’ı değildir.

□ Role ile host/process yerleşimini ayırdım.

□ Upstream ve client arrival’larını ayrı tuttum.

Uygulama konsolunu aç · request / response / browser
Request, URL, cookie ve DOM örneklerini ayrıca aç

Kaynaklar ve kapsam