הכנת קוד הפלאגין

C++‎

‫Proxy-Wasm C++ SDK מאפשר למפתחים להשתמש ב-C++‎ כדי להטמיע תוספים של WebAssembly ‏ (Wasm) עבור Service Extensions. ה-SDK משתמש בערכת הכלים של C++‎ WebAssembly‏ Emscripten, וגם בספריות אחרות, כמו protobuf, ובאופן אופציונלי, Abseil.

בגלל שבניית פלאגינים שנכתבו ב-C++ תלויה בגרסאות ספציפיות של הכלים והספריות האלה, אנחנו ממליצים להשתמש בקובץ אימג' של Docker שסופק על ידי Proxy-Wasm C++ SDK. ההוראות ל-C++‎ בדף הזה מתייחסות לשיטה של Docker. כדי ליצור תוספי C++ בלי להשתמש ב-Docker, אפשר לעיין במסמכי ה-SDK של Proxy-Wasm C++.

1. מתקינים את Docker אם הוא עדיין לא מותקן. ‫Docker כלול ב-Cloud Shell, סביבת המעטפת האינטראקטיבית של Google Cloud .

2. מורידים עותק של Proxy-Wasm C++ SDK. הדרך הכי פשוטה לעשות את זה היא לשכפל את מאגר Git:

   git clone https://github.com/proxy-wasm/proxy-wasm-cpp-sdk.git
   

3. יוצרים את קובץ האימג' של Docker של Proxy-Wasm C++ SDK מקובץ Dockerfile שסופק על ידי ה-SDK:

   cd proxy-wasm-cpp-sdk
   docker build -t wasmsdk:v3 -f Dockerfile-sdk .
   

   כשהפקודה מסיימת ליצור ספריות ותלויות של SDK, קובץ האימג' של Docker שמתקבל משויך לתג שצוין, שהוא wasmsdk:v3 בדוגמה הזו.

המשך

‫Proxy-Wasm Go SDK מספק ערכת SDK מלאה של Go. ‫Go מספקת ביצועים טובים ותמיכה עשירה בספריות של צד שלישי שנכתבו ב-Go טהורה.

מתקינים את ערכת הכלים של Go בגרסה 1.24.0.

חלודה

היכולת להתאים אישית את Service Extensions ניתנת באמצעות WebAssembly ו-Proxy-Wasm. ‫WebAssembly תומך במספר שפות תכנות. ‫Google ממליצה על Rust כי היא מספקת תמיכה מצוינת ב-WebAssembly, ו-Proxy-Wasm מספקת ערכת SDK מלאה של Rust. בנוסף, Rust מספקת ביצועים טובים ובטיחות חזקה של טיפוסים.

1. מתקינים את ערכת הכלים של Rust.

   בסיום תהליך ההתקנה, פועלים לפי ההוראות שמופיעות במסוף כדי לסיים את תהליך ההגדרה.

2. הוספת תמיכה ב-Wasm לשרשרת הכלים של Rust:

   rustup target add wasm32-wasip1
   

C++‎

1. יצירת ספרייה חדשה, נפרדת מ-proxy-wasm-cpp-sdk:

   mkdir myproject
   

2. בספרייה, יוצרים קובץ Makefile עם התוכן הבא:

   # Express any dependencies
   PROTOBUF=     # full / lite / none
   WASM_DEPS=    # absl_base re2 ...
   
   # Include the SDK Makefile
   PROXY_WASM_CPP_SDK=/sdk
   include ${PROXY_WASM_CPP_SDK}/Makefile
   

3. מוסיפים קובץ מקור C++ לתוסף באותה ספרייה. השמות של קובצי המקור של C++ חייבים להיות זהים לקובצי ה-Wasm שהיעדים של קובץ ה-Makefile, עם הסיומת .wasm שהוחלפה ב-.cc. בדוגמה הזו, שם קובץ המקור צריך להיות myproject.cc.

4. מוסיפים את קוד הפלאגין לקובץ המקור.

   דוגמת קוד המקור הבאה היא תוסף שכותב מחדש את מארח הבקשה, ופולט כותרת תגובה:

   #include "proxy_wasm_intrinsics.h"
   
   class MyHttpContext : public Context {
    public:
     explicit MyHttpContext(uint32_t id, RootContext* root) : Context(id, root) {}
   
     FilterHeadersStatus onRequestHeaders(uint32_t headers,
                                          bool end_of_stream) override {
       LOG_INFO("onRequestHeaders: hello from wasm");
   
       // Route Extension example: host rewrite
       if (replaceRequestHeader(":authority", "service-extensions.com") != WasmResult::Ok) {
         LOG_ERROR("Failed to replace :authority header");
       }
       if (replaceRequestHeader(":path", "/") != WasmResult::Ok) {
         LOG_ERROR("Failed to replace :path header");
       }
       return FilterHeadersStatus::Continue;
     }
   
     FilterHeadersStatus onResponseHeaders(uint32_t headers,
                                           bool end_of_stream) override {
       LOG_INFO("onResponseHeaders: hello from wasm");
   
       // Traffic Extension example: add response header
       if (addResponseHeader("hello", "service-extensions") != WasmResult::Ok) {
         LOG_ERROR("Failed to add response header");
       }
       return FilterHeadersStatus::Continue;
     }
   };
   
   static RegisterContextFactory register_StaticContext(
       CONTEXT_FACTORY(MyHttpContext), ROOT_FACTORY(RootContext));

   השיטה onRequestHeaders היא קריאה חוזרת (callback) שמופעלת על ידי Service Extensions.

המשך

1. יוצרים ספרייה חדשה לתוסף:

   mkdir go-plugin
   

2. בספרייה, יוצרים קובץ go.mod באמצעות הכלי Go:

   go mod init go-plugin
   

3. באותה תיקייה, יוצרים קובץ מקור בשם main.go ומוסיפים לקובץ את קוד הפלאגין.

   דוגמת קוד המקור הבאה היא תוסף שכותב מחדש את מארח הבקשה, ופולט כותרת תגובה:

   package main
   
   import (
   	"fmt"
   
   	"github.com/proxy-wasm/proxy-wasm-go-sdk/proxywasm"
   	"github.com/proxy-wasm/proxy-wasm-go-sdk/proxywasm/types"
   )
   
   func main() {}
   func init() {
   	proxywasm.SetVMContext(&vmContext{})
   }
   
   type vmContext struct {
   	types.DefaultVMContext
   }
   
   type pluginContext struct {
   	types.DefaultPluginContext
   }
   
   type httpContext struct {
   	types.DefaultHttpContext
   }
   
   func (*vmContext) NewPluginContext(contextID uint32) types.PluginContext {
   	return &pluginContext{}
   }
   
   func (*pluginContext) NewHttpContext(uint32) types.HttpContext {
   	return &httpContext{}
   }
   
   func (ctx *httpContext) OnHttpRequestHeaders(numHeaders int, endOfStream bool) types.Action {
   	defer func() {
   		err := recover()
   		if err != nil {
   			proxywasm.SendHttpResponse(500, [][2]string{}, []byte(fmt.Sprintf("%v", err)), 0)
   		}
   	}()
   	proxywasm.LogInfof("onRequestHeaders: hello from wasm")
   
   	// Route Extension example: host rewrite
   	err := proxywasm.ReplaceHttpRequestHeader(":authority", "service-extensions.com")
   	if err != nil {
   		panic(err)
   	}
   	err = proxywasm.ReplaceHttpRequestHeader(":path", "/")
   	if err != nil {
   		panic(err)
   	}
   	return types.ActionContinue
   }
   
   func (ctx *httpContext) OnHttpResponseHeaders(numHeaders int, endOfStream bool) types.Action {
   	defer func() {
   		err := recover()
   		if err != nil {
   			proxywasm.SendHttpResponse(500, [][2]string{}, []byte(fmt.Sprintf("%v", err)), 0)
   		}
   	}()
   	proxywasm.LogInfof("onResponseHeaders: hello from wasm")
   
   	// Traffic Extension example: add response header
   	err := proxywasm.AddHttpResponseHeader("hello", "service-extensions")
   	if err != nil {
   		panic(err)
   	}
   	return types.ActionContinue
   }
   

   השיטה OnHttpRequestHeaders היא קריאה חוזרת (callback) שמופעלת על ידי Service Extensions.

4. כדי להוריד ולהצמיד תלות של הפרויקט בספריות, מריצים את הפקודה go mod tidy:

   go mod tidy
   

חלודה

1. יוצרים ספרייה של חבילת Rust באמצעות הפקודה cargo new ממנהל החבילות של Rust, ‏ Cargo:

   cargo new --lib my-wasm-plugin
   

   הפקודה יוצרת ספרייה שמכילה קובץ cargo.toml שאפשר לעדכן כדי לתאר איך ליצור את חבילת Rust, וספרייה src שבה מאחסנים את קוד הפלאגין.

2. מעדכנים את הקובץ cargo.toml כדי לציין את הפרמטרים שנדרשים ליצירת החבילה:

   [package]
   name = "my-wasm-plugin"
   version = "0.1.0"
   edition = "2021"
   

3. כדי לרשום את Proxy-Wasm Rust SDK ותמיכה ברישום ביומן כרכיבי תלות, מוסיפים את הקטע dependencies. לדוגמה:

   [dependencies]
   proxy-wasm = "0.2"
   log = "0.4"
   

4. כדי ליצור ספרייה דינמית כנדרש לפלאגינים, מוסיפים את הקטע lib. לדוגמה:

   [lib]
   crate-type = ["cdylib"]
   

5. כדי להקטין את הגודל של הפלאגין המהודר, מוסיפים את profile.release הקטע. לדוגמה:

   [profile.release]
   lto = true
   opt-level = 3
   codegen-units = 1
   panic = "abort"
   strip = "debuginfo"
   

6. מוסיפים את קוד הפלאגין לקובץ lib.rs בספרייה src.

   דוגמת קוד המקור הבאה היא תוסף שכותב מחדש את מארח הבקשה, ופולט כותרת תגובה:

   use log::info;
   use proxy_wasm::traits::*;
   use proxy_wasm::types::*;
   
   proxy_wasm::main! { {
       proxy_wasm::set_log_level(LogLevel::Trace);
       proxy_wasm::set_http_context(|_, _| -> Box<dyn HttpContext> { Box::new(MyHttpContext) });
   } }
   
   struct MyHttpContext;
   
   impl Context for MyHttpContext {}
   
   impl HttpContext for MyHttpContext {
       fn on_http_request_headers(&mut self, _: usize, _: bool) -> Action {
           info!("onRequestHeaders: hello from wasm");
   
           // Route extension example: host rewrite
           self.set_http_request_header(":authority", Some("service-extensions.com"));
           self.set_http_request_header(":path", Some("/"));
           return Action::Continue;
       }
   
       fn on_http_response_headers(&mut self, _: usize, _: bool) -> Action {
           info!("onResponseHeaders: hello from wasm");
   
           // Traffic extension example: add response header
           self.add_http_response_header("hello", "service-extensions");
           return Action::Continue;
       }
   }

   השיטה on_http_request_headers היא קריאה חוזרת (callback) שמופעלת על ידי Service Extensions.

C++‎

כדי לקמפל את הפלאגין, מריצים את הפקודה הבאה מתוך הספרייה שבה נמצאים קובץ ה-Makefile וקבצי המקור של הפלאגין ב-C++‎:

docker run -v $PWD:/work -w /work wasmsdk:v3 /build_wasm.sh myproject.wasm

הפקודה הזו ממפה את הספרייה הנוכחית לספרייה work בקובץ האימג' של Docker, ואז מריצה את הסקריפט build_wasm.sh שסופק על ידי קובץ האימג' של Docker כדי ליצור את קוד הפלאגין. בסיום פעולת ההידור, אם היא הושלמה בהצלחה, נוצר קובץ myproject.wasm שמכיל את בייטקוד ה-Wasm המהודר בספרייה הנוכחית.

בפעם הראשונה שקוד הפלאגין עובר קומפילציה באמצעות קובץ אימג' של Docker,‏ Emscripten יוצר את הספריות הרגילות. כדי לשמור אותן במטמון בתמונת Docker, כך שלא יהיה צורך ליצור אותן מחדש בכל פעם, צריך לבצע commit לתמונה עם הספריות הרגילות אחרי ההידור הראשון שמתבצע בהצלחה:

docker commit `docker ps -l | grep wasmsdk:v3 | awk '{print $1}'` wasmsdk:v3

מידע נוסף על יצירת תוספים ל-C++ זמין במאמרי העזרה בנושא Proxy-Wasm C++ SDK.

המשך

כדי לקמפל את קוד הפלאגין, מריצים את הפקודה go build:

env GOOS=wasip1 GOARCH=wasm go build -buildmode=c-shared -o main.wasm main.go

קומפילציה מוצלחת יוצרת קובץ main.wasm בספרייה הנוכחית.

חלודה

כדי לקמפל את קוד הפלאגין, מריצים את הפקודה cargo build:

cargo build --release --target wasm32-wasip1

בסיום ה-build בהצלחה, תופיע הודעה Finished release [optimized] target(s). אם אתם מכירים את Envoy, תוכלו לטעון את הפלאגין ב-Envoy ולאמת את ההתנהגות שלו.

מאגר כללי

1. יוצרים ספרייה מקומית package/ ומעתיקים אליה את מודול הפלאגין שניתן לפרסום. הארטיפקט של הפלאגין צריך להיקרא plugin.wasm הפקודה לדוגמה הבאה מעתיקה את הארטיפקט של הפלאגין שנבנה על ידי Rust:

   mkdir -p package && cp -f target/wasm32-wasip1/release/my_wasm_plugin.wasm package/plugin.wasm
   

2. יוצרים מאגר Artifact Registry עם --repository-format שמוגדר ל-generic.

3. מוודאים שיש לכם את ההרשאות הנדרשות למאגר.

4. כדי להעלות את מודול ה-Wasm שלכם כארטיפקט גנרי למאגר, משתמשים בפקודה gcloud artifacts generic upload.

   gcloud artifacts generic upload \
       --project=PROJECT_ID \
       --location=LOCATION \
       --repository=REPOSITORY \
       --source=package/plugin.wasm \
       --package=PACKAGE \
       --version=VERSION
   

   מחליפים את מה שכתוב בשדות הבאים:

   • ‫PROJECT_ID: Google Cloud מזהה הפרויקט
   • ‫LOCATION: המיקום של המאגר באזור או בכמה אזורים
   • ‫REPOSITORY: השם של המאגר שאליו רוצים להעלות את מודול ה-Wasm
   • ‫PACKAGE: שם החבילה של הקובץ
   • ‫VERSION: הגרסה של מודול ה-Wasm

   בסיום ההעלאה, שימו לב לשם של הארטיפקט הגנרי שמופיע עם התווית name, לדוגמה add_header_plugin:v4 בדוגמה הבאה. צריך לציין את השם הזה כשיוצרים פלאגין או גרסת פלאגין.

   Uploading file: plugin.wasm...done.
   '@type': type.googleapis.com/google.devtools.artifactregistry.v1.GenericArtifact
   createTime: '2025-06-16T11:02:25.080248Z'
   name: projects/my-project/locations/us/repositories/my-generic-repo/genericArtifacts/add_header_plugin:v4
   updateTime: '2025-06-16T11:02:25.080248Z'
   version: v4
   

5. כדי לוודא שהפריט הועלה בהצלחה אל Artifact Registry, מריצים את הפקודה gcloud artifacts files list ומוודאים שברשימה מופיע קובץ בשם PACKAGE:VERSION:plugin.wasm.

    gcloud artifacts files list \
        --project=PROJECT_ID \
        --location=LOCATION \
        --repository=REPOSITORY
   

מאגר Docker

1. יוצרים מאגר Artifact Registry עם --repository-format שמוגדר ל-docker.

2. מוודאים שיש לכם את ההרשאות הנדרשות למאגר.

3. יוצרים ספרייה מקומית בשם package/ ומעתיקים אליה את ארטיפקט הפלאגין שניתן לפרסום. בדוגמה הבאה מועתק ארטיפקט של פלאגין שנבנה על ידי Rust:

   mkdir -p package && cp -f target/wasm32-wasip1/release/my_wasm_plugin.wasm package/plugin.wasm
   

4. יוצרים קובץ package/Dockerfile עם התוכן הבא:

   FROM scratch
   COPY plugin.wasm plugin.wasm
   

5. אורזים את קוד הפלאגין באמצעות Cloud Build או Docker.

   Cloud Build

   1. יוצרים קובץ package/cloudbuild.yaml build config עם התוכן הבא:

      steps:
        - name: 'gcr.io/cloud-builders/docker'
          args: [ 'build', '--no-cache', '--platform', 'wasm',
                '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE:IMAGE_TAG', '.' ]
      images: [ 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE:IMAGE_TAG' ]
      

      הנתיב שבו מאחסנים את הפלאגין צריך להיות בפורמט הבא:

      LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE:IMAGE_TAG
      

      מחליפים את מה שכתוב בשדות הבאים:

      • ‫LOCATION: המיקום האזורי או הרב-אזורי של המאגר
      • ‫PROJECT_ID: מזהה הפרויקט ב Google Cloud מסוף
      • ‫REPOSITORY: השם של המאגר שבו אתם רוצים לאחסן את התמונה
      • ‫IMAGE: שם תמונת הקונטיינר במאגר, לדוגמה, us-docker.pkg.dev/my-project/my-repo/my-wasm-plugin
      • ‫IMAGE_TAG: תג האימג' שיוקצה לקונטיינר. לדוגמה, production

   2. מפעילים את הפעולה כדי ליצור את מאגר הפלאגין ולהעלות אותו ל-Artifact Registry:

      gcloud builds submit --config package/cloudbuild.yaml package/
      

   Docker

   1. מתקינים את Docker אם הוא עדיין לא מותקן. ‫Docker כלול ב-Cloud Shell, סביבת המעטפת האינטראקטיבית של Google Cloud .

   2. הגדרת אימות של Docker ב-Artifact Registry לדוגמה:

      gcloud auth login
      gcloud auth configure-docker LOCATION-docker.pkg.dev
      gcloud auth print-access-token | docker login -u oauth2accesstoken --password-stdin https://LOCATION-docker.pkg.dev
      

   3. יוצרים את קובץ האימג' של הקונטיינר:

      docker build --no-cache --platform wasm -t my-wasm-plugin package/
      

   4. כדי לתייג את התמונה המקומית עם שם התמונה במאגר, משתמשים בתגי תמונה:

      docker tag my-wasm-plugin LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE:IMAGE_TAG
      

      מחליפים את מה שכתוב בשדות הבאים:

      • ‫LOCATION: המיקום האזורי או הרב-אזורי של המאגר
      • ‫PROJECT_ID: מזהה הפרויקט ב Google Cloud מסוף
      • ‫REPOSITORY: השם של המאגר שבו אתם רוצים לאחסן את התמונה
      • ‫IMAGE: שם תמונת הקונטיינר במאגר, לדוגמה, us-docker.pkg.dev/my-project/my-repo/my-wasm-plugin.
      • ‫IMAGE_TAG: תג האימג' להקצאה לקונטיינר, לדוגמה production

   5. מעלים את קובץ האימג' של קונטיינר עם התגים ל-Artifact Registry.

      docker push LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE:IMAGE_TAG
      

6. כדי לוודא שהתמונה הועלתה בהצלחה אל Artifact Registry, מריצים את הפקודה gcloud artifacts docker images list.

   gcloud artifacts docker images list LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE \
       --include-tags
   

C++‎

נתוני ההגדרה מועברים לשיטה onConfigure של אובייקט ההקשר הבסיסי, שמופעל פעם אחת בהפעלת הפלאגין ונשאר פעיל למשך חיי זמן הריצה של Wasm שמארח את הפלאגין. אובייקט ההקשר הבסיסי הוא מופע של המחלקה RootContext או של מחלקת משנה של RootContext.

קוד הפלאגין יכול לקבוע באיזו מחלקה יש להשתמש עבור הקשר הבסיסי באמצעות הערך RegisterContextFactory. לדוגמה, קוד הפלאגין הבא רושם את MyRootContext ואת MyHttpContext כסוגי המחלקות שבהן יש להשתמש עבור מופעים של הקשרים root ו-stream. לאחר מכן הוא קורא ערך סודי מנתוני ההגדרה של התוסף, שמופעים של הקשר של הזרם יכולים לגשת אליו דרך אובייקט ההקשר הבסיסי.

#include <string>
#include <string_view>

#include "proxy_wasm_intrinsics.h"

class MyRootContext : public RootContext {
 public:
  explicit MyRootContext(uint32_t id, std::string_view root_id)
      : RootContext(id, root_id) {}

  bool onConfigure(size_t config_len) override {
    auto buffer = getBufferBytes(WasmBufferType::PluginConfiguration, 0, config_len);
    if (!buffer) {
      LOG_ERROR("Failed to retrieve plugin configuration");
      return false;
    }
    secret_ = buffer->toString();
    return true;
  }

  const std::string& secret() const { return secret_; }

 private:
  std::string secret_;
};

class MyHttpContext : public Context {
 public:
  explicit MyHttpContext(uint32_t id, RootContext* root)
      : Context(id, root),
        secret_(static_cast<MyRootContext*>(root)->secret()) {}

  FilterHeadersStatus onRequestHeaders(uint32_t headers,
                                       bool end_of_stream) override {
    // Use secret here...
    LOG_INFO("secret: " + secret_);
    return FilterHeadersStatus::Continue;
  }

 private:
  const std::string& secret_;
};

static RegisterContextFactory register_MyHttpContext(
    CONTEXT_FACTORY(MyHttpContext), ROOT_FACTORY(MyRootContext));

המשך

נתוני ההגדרה נקראים במהלך ההפעלה של OnPluginStart, מקבל שיטה שהסביבה בזמן הריצה מפעילה במבנה PluginContext פעם אחת במהלך הפעלת הפלאגין. נתוני ההגדרה לא משתנים במהלך מחזור החיים של זמן הריצה של Wasm שמארח את הפלאגין. ‫PluginContext שימושי לביצוע לוגיקה של אתחול ולשמירה על מצב בין בקשות רבות.

קוד הפלאגין יכול לקבוע באיזה הקשר ישמש PluginContext על ידי הטמעה של method מסוג NewPluginContext ב-VMContext, שמבצעת יצירה של מופע של PluginContext. ‫PluginContext יוצר מופעים של הקשרים HttpContext.

לדוגמה, קוד הפלאגין הבא רושם את VMContext, שיוצר מופע של PluginContext, ההקשר שאחראי לקריאת נתוני ההגדרה וליצירת מופעים של הקשרים של HttpContext לפי הצורך. ‫PluginContext קורא ערך סודי מנתוני ההגדרה של התוסף, מאחסן אותו בהקשר PluginContext ומעביר אותו אל HttpContext ב-NewHttpContext.

package main

import (
	"fmt"

	"github.com/proxy-wasm/proxy-wasm-go-sdk/proxywasm"
	"github.com/proxy-wasm/proxy-wasm-go-sdk/proxywasm/types"
)

func main() {}
func init() {
	proxywasm.SetVMContext(&vmContext{})
}

type vmContext struct {
	types.DefaultVMContext
}

type pluginContext struct {
	types.DefaultPluginContext
	secret string
}

type httpContext struct {
	types.DefaultHttpContext
	pluginContext *pluginContext
}

func (*vmContext) NewPluginContext(contextID uint32) types.PluginContext {
	return &pluginContext{}
}

func (ctx *pluginContext) OnPluginStart(int) types.OnPluginStartStatus {
	config, err := proxywasm.GetPluginConfiguration()
	if err != nil {
		proxywasm.LogErrorf("Error reading the configuration: %v", err)
		return types.OnPluginStartStatusFailed
	}
	if config == nil {
		proxywasm.LogError("Configuration is nil")
		return types.OnPluginStartStatusFailed
	}
	ctx.secret = string(config)
	return types.OnPluginStartStatusOK
}

func (ctx *pluginContext) NewHttpContext(uint32) types.HttpContext {
	return &httpContext{pluginContext: ctx}
}

func (ctx *pluginContext) Secret() string {
	return ctx.secret
}

func (ctx *httpContext) OnHttpRequestHeaders(numHeaders int, endOfStream bool) types.Action {
	defer func() {
		err := recover()
		if err != nil {
			proxywasm.SendHttpResponse(500, [][2]string{}, []byte(fmt.Sprintf("%v", err)), 0)
		}
	}()
	// Use secret here...
	proxywasm.LogInfof("secret: %v", ctx.pluginContext.Secret())
	return types.ActionContinue
}

חלודה

נתוני ההגדרות נקראים מRootContextמאפיין (trait), שמופעל פעם אחת בהפעלת התוסף ונשאר פעיל למשך משך החיים של זמן הריצה של Wasm שמארח את התוסף. מאפייני RootContext שימושיים לביצוע פעולות או לשמירת מצב בבקשות רבות.

קוד הפלאגין יכול לקבוע באיזה סיווג משתמשים בהקשר הבסיסי באמצעות השיטה set_root_context, וההקשר הבסיסי יוצר מופעים של הקשרים של הזרם. לדוגמה, קוד הפלאגין הבא רושם את MyRootContext, שיוצר מופע של MyHttpContext לפי הצורך. ההקשר הבסיסי קורא ערך סודי מנתוני ההגדרה של הפלאגין ומעביר אותו להקשרים של הסטרימינג.

use log::info;
use proxy_wasm::traits::*;
use proxy_wasm::types::*;
use std::rc::Rc;

proxy_wasm::main! { {
    proxy_wasm::set_log_level(LogLevel::Trace);
    proxy_wasm::set_root_context(|_| -> Box<dyn RootContext> {
        Box::new(MyRootContext { secret: Rc::new("missing".to_string()) })
    });
} }

struct MyRootContext {
    secret: Rc<String>,
}

impl Context for MyRootContext {}

impl RootContext for MyRootContext {
    fn on_configure(&mut self, _: usize) -> bool {
        if let Some(config_bytes) = self.get_plugin_configuration() {
            self.secret = Rc::new(String::from_utf8(config_bytes).unwrap())
        }
        true
    }

    fn create_http_context(&self, _: u32) -> Option<Box<dyn HttpContext>> {
        Some(Box::new(MyHttpContext {
            secret: self.secret.clone(), // shallow copy, ref count only
        }))
    }

    fn get_type(&self) -> Option<ContextType> {
        Some(ContextType::HttpContext)
    }
}

struct MyHttpContext {
    secret: Rc<String>,
}

impl Context for MyHttpContext {}

impl HttpContext for MyHttpContext {
    fn on_http_request_headers(&mut self, _: usize, _: bool) -> Action {
        // Use secret here...
        info!("secret: {}", self.secret);
        Action::Continue
    }
}