מדיניות AssignMessage

אתם צופים במסמכי העזרה של Apigee Edge.
כניסה למסמכי העזרה של Apigee X. info

מה

המדיניות של AssignMessage משנה או יוצרת הודעות בקשה ותגובה חדשות במהלך תהליך ה-API proxy. המדיניות מאפשרת לבצע את הפעולות הבאות בהודעות האלה:

  • הוספת פרמטרים חדשים של טפסים, כותרות או פרמטרים של שאילתות להודעה
  • העתקה של נכסים קיימים מהודעה אחת להודעה אחרת
  • הסרה של כותרות, פרמטרים של שאילתות, פרמטרים של טפסים ו/או עומסי הודעות מהודעה
  • הגדרה של הערך של מאפיינים קיימים בהודעה

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

המדיניות AssignMessage יכולה ליצור או לשנות משתני תהליך באמצעות הרכיבים הבאים:

רכיב <AssignMessage>

הגדרת מדיניות AssignMessage.

ערך ברירת המחדל בכרטיסייה מדיניות ברירת מחדל שבהמשך
חובה? חובה
סוג אובייקט מורכב
רכיב הורה לא רלוונטי
רכיבי הצאצאים <Add>
<AssignTo>
<AssignVariable>
<Copy>
<DisplayName>
<IgnoreUnresolvedVariables>
<Remove>
<Set>

רכיב <AssignMessage> כולל את התחביר הבא:

תחביר

רכיב <AssignMessage> כולל את התחביר הבא:

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <!-- All AssignMessage child elements are optional -->
  <Add>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Add>

  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>

  <AssignVariable>
    <Name>variable_name</Name>
    <Ref>source_variable</Ref>
    <Template>message_template</Template>
    or
    <Template ref='template_variable'></Template>
    <Value>variable_value</Value>
  </AssignVariable>

  <Copy source="[request|response]">
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>[false|true]</Path>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>[false|true]</ReasonPhrase>
    <StatusCode>[false|true]</StatusCode>
    <Verb>[false|true]</Verb>
    <Version>[false|true]</Version>
  </Copy>

  <DisplayName>policy_display_name</DisplayName>

  <IgnoreUnresolvedVariables>[true|false]</IgnoreUnresolvedVariables>

  <Remove>
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Remove>

  <Set>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>path</Path>
    <Payload contentType="content_type" variablePrefix="prefix"
        variableSuffix="suffix">new_payload</Payload>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>reason_for_error or {variable}</ReasonPhrase>
    <StatusCode>HTTP_status_code or {variable}</StatusCode>
    <Verb>[GET|POST|PUT|PATCH|DELETE|{variable}]</Verb>
    <Version>[1.0|1.1|{variable}]</Verb>
  </Set>

</AssignMessage>

מדיניות ברירת המחדל

בדוגמה הבאה מוצגות הגדרות ברירת המחדל כשמוסיפים מדיניות AssignMessage לתהליך בממשק המשתמש של Edge:

<AssignMessage continueOnError="false" enabled="true" name="assign-message-default">
  <DisplayName>Assign Message-1</DisplayName>
  <Properties/>
  <Copy source="request">
    <Headers/>
    <QueryParams/>
    <FormParams/>
    <Payload/>
    <Verb/>
    <StatusCode/>
    <ReasonPhrase/>
    <Path/>
  </Copy>
  <Remove>
    <Headers>
      <Header name="h1"/>
    </Headers>
    <QueryParams>
      <QueryParam name="q1"/>
    </QueryParams>
    <FormParams>
      <FormParam name="f1"/>
    </FormParams>
    <Payload/>
  </Remove>
  <Add>
    <Headers/>
    <QueryParams/>
    <FormParams/>
  </Add>
  <Set>
    <Headers/>
    <QueryParams/>
    <FormParams/>
    <!-- <Verb>GET</Verb> -->
    <Path/>
  </Set>
  <AssignVariable>
    <Name>name</Name>
    <Value/>
    <Ref/>
  </AssignVariable>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

כשמוסיפים מדיניות AssignMessage חדשה בממשק המשתמש של Edge, התבנית מכילה stubs לכל הפעולות האפשריות. בדרך כלל בוחרים את הפעולות שרוצים לבצע באמצעות המדיניות הזו ומסירים את שאר רכיבי הצאצאים. לדוגמה, אם רוצים לבצע פעולת העתקה, משתמשים ברכיב <Copy> ומסירים מהמדיניות את <Add>,‏ <Remove> ורכיבי צאצא אחרים כדי שהיא תהיה קריאה יותר.

לרכיב הזה יש את המאפיינים הבאים, המשותפים לכל כללי המדיניות:

מאפיין ברירת מחדל חובה? תיאור
name לא רלוונטי נדרש

השם הפנימי של המדיניות. הערך של המאפיין name יכול להכיל אותיות, מספרים, רווחים, מקפים, קווים תחתונים ונקודות. האורך המקסימלי של הערך הוא 255 תווים.

אפשר להשתמש ברכיב <DisplayName> כדי להוסיף תווית למדיניות בכלי לעריכת שרת proxy של ממשק המשתמש לניהול, ולהשתמש בשם אחר בשפה טבעית.
continueOnError false אופציונלי צריך להגדיר את הערך 'False' כדי להחזיר שגיאה כשהמדיניות נכשלת. זו התנהגות צפויה ברוב סוגי המדיניות. הערך של הפרמטר הוא TRUE כדי שביצוע הפעולות יתבצע גם אחרי שמדיניות תיכשל.
enabled true אופציונלי כדי לאכוף את המדיניות צריך להגדיר את הערך True. מגדירים את המדיניות כ-"false" כדי "להשבית" את המדיניות. המדיניות הזו לא תיאכף גם אם היא תצורף לתהליך.
async   false הוצא משימוש המאפיין הזה הוצא משימוש.

בטבלה הבאה מופיע תיאור כללי של רכיבי הצאצא של <AssignMessage>:

רכיב צאצא חובה? תיאור
פעולות נפוצות
<Add> אופציונלי הוספת מידע אל אובייקט ההודעה שצוין על ידי הרכיב <AssignTo>.

<Add> מוסיף להודעה כותרות או פרמטרים שלא קיימים בהודעה המקורית. כדי לשכתב כותרות או פרמטרים קיימים, משתמשים ברכיב <Set>.
<Copy> אופציונלי העתקת מידע מ ההודעה שצוינה במאפיין source אל אובייקט ההודעה שצוין ברכיב <AssignTo>.
<Remove> אופציונלי מחיקה של הרכיבים שצוינו ממשתנה ההודעה שצוין ברכיב <AssignTo>.
<Set> אופציונלי מחליפה ערכים של מאפיינים קיימים בבקשה או בתגובה, כפי שצוין ברכיב <AssignTo>.

<Set> מחליף כותרות או פרמטרים שכבר קיימים בהודעה המקורית. כדי להוסיף כותרות או פרמטרים חדשים, משתמשים ברכיב <Add>.
רכיבי צאצא אחרים
<AssignTo> אופציונלי קובעת על איזו הודעה המדיניות AssignMessage פועלת. אפשר להשתמש בבקשה או בתגובה הרגילה, או להשתמש בהודעה חדשה בהתאמה אישית.
<AssignVariable> אופציונלי הקצאת ערך למשתנה תהליך. אם המשתנה לא קיים, המערכת תיצור אותו באמצעות <AssignVariable>.
<IgnoreUnresolvedVariables> אופציונלי קובעת אם העיבוד יפסק כאשר יתקל במשתנה שלא נפתר.

כל אחד מהרכיבים האלה מתואר בקטעים הבאים.

דוגמאות

בדוגמאות הבאות מפורטות כמה מהדרכים שבהן אפשר להשתמש במדיניות AssignMessage:

1: הוספת כותרת

בדוגמה הבאה מוסיפה כותרת לבקשה עם הרכיב <Add>:

<AssignMessage continueOnError="false" enabled="true" name="add-headers-1">
  <Add>
    <Headers>
      <Header name="user-agent">{request.user.agent}</Header>
    </Headers>
  </Add>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

2: הסרת עומס התועלת

בדוגמה הבאה מוחקים את המטען הייעודי מהתגובה באמצעות הרכיב <Remove>:

<AssignMessage continueOnError="false" enabled="true" name="remove-1">
  <DisplayName>remove-1</DisplayName>
  <Remove>
    <Payload>true</Payload>
  </Remove>
  <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

3: שינוי התשובה

בדוגמה הבאה משנים אובייקט תגובה קיים על ידי הוספת כותרת אליו:

<AssignMessage name="modify-response">
  <Set>
    <Headers>
      <Header name="Cache-Hit">{lookupcache.LookupCache-1.cachehit}</Header>
    </Headers>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" type="response"></AssignTo>
</AssignMessage>

בדוגמה הזו לא נוצרת הודעה חדשה. במקום זאת, הוא משנה הודעת תשובה קיימת על ידי הוספת כותרת HTTP.

מכיוון שבדוגמה הזו לא צוין שם משתנה ברכיב <AssignTo>, וצוין type בתור 'response', המדיניות הזו משנה את אובייקט התגובה שמוחזר על ידי שרת היעד.

כותרת ה-HTTP שנוספת להודעת התגובה על ידי המדיניות הזו נגזרת ממשתנה שמאוכלס על ידי המדיניות של LookupCache. לכן, הודעת התגובה שתשתנה על ידי המדיניות הזו של הקצאת הודעות מכילה כותרת HTTP שמציינת אם התוצאות נשלפו מהמטמון או לא. הגדרת כותרות בתגובה יכולה להיות שימושית לניפוי באגים ולפתרון בעיות.

4: הגדרת תוכן דינמי

אפשר להשתמש ב-Assign Message כדי להטמיע תוכן דינמי במטען הייעודי של הודעות התגובה והבקשה.

כדי להטמיע משתני תהליך Edge בעומס נתונים של XML, צריך לעטוף את המשתנה הייעודי בסוגריים מסולסלים, כך: {prefix.name}.

בדוגמה הבאה, הערך של משתנה התהליך בכותרת ה-HTTP‏ user-agent מוטמע באלמנט XML שנקרא User-agent:

<AssignMessage name="set-dynamic-content">
  <AssignTo createNew="false" type="response"></AssignTo>
  <Set>
    <Payload contentType="text/xml">
      <User-agent>{request.header.user-agent}</User-agent>
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

בעומס נתונים של JSON, אפשר להוסיף משתנים באמצעות המאפיינים variablePrefix ו-variableSuffix עם תווים מפרידים, כפי שמתואר בדוגמה הבאה:

<AssignMessage name="set-payload">
  <Payload contentType="application/json" variablePrefix="@" variableSuffix="#">
  {
     "user-agent": "@request.header.user-agent#"
  }
  </Payload>
</AssignMessage>

רשימה מלאה של משתני תהליך מפורטת במאמר חומר עזר בנושא משתני תהליך.

החל מהגרסה 16.08.17 של Cloud, אפשר להשתמש גם בסוגריים מסולסלים כדי להוסיף משתנים.

5: הסרת פרמטר השאילתה

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

<AssignMessage name="remove-query-param">
  <Remove>
    <QueryParams>
      <QueryParam name="apikey"/>
    </QueryParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

מומלץ להסיר את פרמטר השאילתה apikey מההודעה של הבקשה כשמשתמשים במדיניות VerifyAPIKey לאימות משתמשים. כך אפשר למנוע העברה של מידע רגיש של מפתחות ליעד הקצה העורפי.

6: הגדרה/קבלה של משתנים

בדוגמה הבאה נעשה שימוש בשלושה כללי מדיניות להקצאת הודעות:

  1. יצירת שלושה משתני תהליך בבקשה, עם ערכים סטטיים
  2. אחזור של משתני התהליך באופן דינמי במדיניות שנייה בתהליך הבקשה
  3. מגדיר אותם בעומס העבודה של התגובה
<!-- Policy #1: Set variables in the request -->
<AssignMessage continueOnError="false" enabled="true" name="set-variables">
    <!-- Create a variable named myAppSecret -->
    <AssignVariable>
        <Name>myAppSecret</Name>
        <Value>42</Value>
    </AssignVariable>
    <!-- Create a variable named config.environment -->
    <AssignVariable>
        <Name>config.environment</Name>
        <Value>test</Value>
    </AssignVariable>
    <!-- Create a variable named config.protocol -->
    <AssignVariable>
        <Name>config.protocol</Name>
        <Value>gopher</Value>
    </AssignVariable>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

במדיניות הראשונה, הרכיב <AssignVariable> יוצר שלושה משתנים בבקשה ומגדיר אותם. כל רכיב <Name> מציין שם של משתנה, ורכיב <Value> מציין את הערך.

המדיניות השנייה משתמשת ברכיב <AssignVariable> כדי לקרוא את הערכים וליצור שלושה משתנים חדשים:

<!-- Policy #2: Get variables from the request -->
<AssignMessage continueOnError="false" enabled="true" name="get-variables">
  <AssignTo createNew="false" transport="http" type="request"/>
  <!-- Get the value of myAppSecret and create a new variable, secret -->
  <AssignVariable>
    <Name>secret</Name>
    <Ref>myAppSecret</Ref>
    <Value>0</Value>
  </AssignVariable>
  <!-- Get the value of config.environment and create a new variable, environment -->
  <AssignVariable>
    <Name>environment</Name>
    <Ref>config.environment</Ref>
    <Value>default</Value>
  </AssignVariable>
  <!-- Get the value of config.protocol and create a new variable, protocol -->
  <AssignVariable>
    <Name>protocol</Name>
    <Ref>config.protocol</Ref>
    <Value>default</Value>
  </AssignVariable>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
</AssignMessage>

במדיניות השנייה, הרכיב <Ref> מפנה למשתנה המקור, ורכיבי <Name> מציינים את השמות של המשתנים החדשים. אם אין גישה למשתנה שאליו מפנה הרכיב <Ref>, אפשר להשתמש בערך שצוין ברכיב <Value>.

כדי לנסות את קבוצת כללי המדיניות הזו:

  1. מוסיפים את המדיניות מס' 1 ומס' 2 לתהליך הבקשה. חשוב להוסיף את המדיניות הראשונה לפני המדיניות השנייה.
  2. מוסיפים את המדיניות השלישית בתהליך התגובה.
  3. המדיניות השלישית משתמשת ברכיב <Set> כדי להוסיף את המשתנים לתגובה. בדוגמה הבאה נוצר מטען ייעודי (payload) של XML בתגובה ש-Edge מחזיר ללקוח: 
    <!-- Policy #3: Add variables to the response -->
<AssignMessage continueOnError="false" enabled="true" name="put-em-in-the-payload">
  <DisplayName>put-em-in-the-payload</DisplayName>
  <Set>
    <Payload contentType="application/xml">
      <wrapper>
        <secret>{secret}</secret>
        <config>
          <environment>{environment}</environment>
          <protocol>{protocol}</protocol>
        </config>
      </wrapper>
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

    שימו לב שהתחביר לגישה למשתני תהליך ב-<Set> הוא עטיפה שלהם בסוגריים מסולסלים.

    חשוב להגדיר את המאפיין contentType של הרכיב <Payload> לערך 'application/xml'.

  4. שולחים בקשה לשרת ה-proxy של ה-API. לדוגמה: 
    curl -vL https://ahamilton-eval-test.apigee.net/myproxy

    אפשר גם להעביר את התוצאות דרך כלי כמו xmllint כדי שה-XML יוצג במבנה מעוצב:

    curl -vL https://ahamilton-eval-test.apigee.net/myproxy | xmllint --format -

    גוף התגובה אמור להיראות כך:

    <wrapper>
  <secret>42</secret>
  <config>
    <environment>test</environment>
    <protocol>gopher</protocol>
  </config>
</wrapper>

7: אחזור כותרות התגובה של Service Callout

בדוגמה הבאה, נניח שמדיניות ServiceCallout נמצאת בבקשה של שרת ה-proxy ל-API, ותשובת ה-callout מכילה כמה כותרות עם אותו שם (Set-Cookie). בהנחה שמשתנה התגובה של Service Callout הוא calloutResponse שמוגדרת כברירת מחדל, המדיניות הבאה מקבלת את הערך השני של הכותרת Set-Cookie.

<AssignMessage continueOnError="false" enabled="true" name="get-header">
  <Set>
    <Payload contentType="application/json">
      {"Cookies from Service Callout":" {calloutResponse.header.Set-Cookie.2}"}
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

כדי לרשום את כל ערכי הכותרות, צריך להשתמש במשתנה הבא במקום זאת:

{calloutResponse.header.Set-Cookie.values}

לכל רכיב צאצא במסמך העזרה הזה יש דוגמאות נוספות. דוגמאות נוספות זמינות ב-AssignMessage example ב-GitHub.

הפניה לרכיב הצאצא

בקטע הזה מתוארים רכיבי הצאצאים של <AssignMessage>.

<Add>

הוספת מידע לבקשה או לתגובה, כפי שצוין ברכיב <AssignTo>.

האלמנט <Add> מוסיף להודעה מאפיינים חדשים שלא קיימים בהודעה המקורית. כדי לשנות את הערכים של מאפיינים קיימים, משתמשים ברכיב <Set>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג סוג מורכב
רכיב הורה <AssignMessage>
רכיבי הצאצאים <FormParams>
<Headers>
<QueryParams>

רכיב <Add> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Add>
</AssignMessage>

דוגמה 1

בדוגמה הבאה נעשה שימוש ברכיב <FormParams> כדי לקבל את הערכים של שלושה פרמטרים של מחרוזת שאילתה מהבקשה הראשונית ולהגדיר אותם כפרמטרים של טופס בבקשה לנקודת הקצה היעד:

<AssignMessage continueOnError="false" enabled="true" name="add-formparams-3">
  <Add>
    <FormParams>
      <FormParam name="name">{request.queryparam.name}</FormParam>
      <FormParam name="zip">{request.queryparam.zipCode}</FormParam>
      <FormParam name="lang">{request.queryparam.lang}</FormParam>
    </FormParams>
  </Add>
  <AssignTo transport="http" type="request"/>
</AssignMessage>

דוגמה 2

בדוגמה הבאה נעשה שימוש ברכיב <Headers> כדי להוסיף את הכותרת User-Agent לבקשת נקודת הקצה היעד:

<AssignMessage continueOnError="false" enabled="true" name="add-headers-1">
  <Add>
    <Headers>
      <Header name="user-agent">{request.user.agent}</Header>
    </Headers>
  </Add>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

דוגמה 3

בדוגמה הבאה נעשה שימוש ברכיב <QueryParams> כדי להוסיף לבקשה פרמטר שאילתה יחיד עם ערך סטטי:

<AssignMessage continueOnError="false" enabled="true" name="add-queryparams-1">
  <Add>
    <QueryParams>
      <QueryParam name="myParam">42</QueryParam>
    </QueryParams>
  </Add>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

בדוגמה הזו נעשה שימוש ב-<Add> בתהליך המקדים של הבקשה. אם בודקים את התוצאות בכלי כמו Trace tool, הבקשה אל "http://httpbin.org/get" הופכת ל-"http://httpbin.org/get?myParam=42".

הרכיבים הצאצאים של <Add> תומכים בהחלפת מחרוזות דינמיות, שנקראת יצירת תבניות להודעות.

<FormParams> (צאצא של <Add>)

הוספת פרמטרים חדשים של טופס להודעת הבקשה. לרכיב הזה אין השפעה על הודעת התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של <FormParam> אלמנטים
רכיב הורה <Add>
רכיבי הצאצאים <FormParam>

רכיב <FormParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>
  </Add>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מתווסף לבקשה פרמטר טופס יחיד ("answer") וערך סטטי ("42"):

<AssignMessage continueOnError="false" enabled="true" name="add-formparams-1">
  <Add>
    <FormParams>
      <FormParam name="answer">42</FormParam>
    </FormParams>
  </Add>
  <AssignTo transport="http" type="request"></AssignTo>
</AssignMessage>

דוגמה 2

בדוגמה הבאה מוצגת קבלת הערך של פרמטר מחרוזת השאילתה name והוספתו לבקשה כפרמטר של טופס:

<AssignMessage continueOnError="false" enabled="true" name="add-formparams-2">
  <Add>
    <FormParam name="name">{request.queryparam.name}</FormParam>
  </Add>
</AssignMessage>

שימו לב שבדוגמה הזו לא צוין יעד באמצעות <AssignTo>. המדיניות הזו מוסיפה את הפרמטר לבקשה בלבד.

דוגמה 3

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

<AssignMessage continueOnError="false" enabled="true" name="add-formparams-3">
  <Add>
    <FormParams>
      <FormParam name="name">{request.queryparam.name}</FormParam>
      <FormParam name="zip">{request.queryparam.zipCode}</FormParam>
      <FormParam name="lang">{request.queryparam.lang}</FormParam>
    </FormParams>
  </Add>
  <AssignTo transport="http" type="request"/>
</AssignMessage>

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

אפשר להשתמש בכלי המעקב כדי לבדוק את התהליך. גוף הבקשה מכיל את נתוני הטופס המקודדים בכתובת ה-URL, שהועברו במקור כפרמטרים של מחרוזת השאילתה:

%7Busername%7D=nick&%7Bzip_code%7D=90210&%7Bdefault_language%7D=en

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: POST
  • סוג ההודעה: בקשה
  • אחת (או שתיהן) מהאפשרויות הבאות:
    • נתוני טופס: מוגדר לערך כלשהו, או ל-"" (המחרוזת הריקה). לדוגמה, ב-curl, מוסיפים את -d "" לבקשה.
    • הכותרת Content-Length: מוגדרת ל-0 (אם אין נתונים בבקשה המקורית, אחרת האורך הנוכחי, בייטים). לדוגמה, ב-curl מוסיפים את -H "Content-Length: 0" לבקשה.

לדוגמה:

curl -vL -X POST -d "" -H "Content-Type: application/x-www-form-urlencoded"
  https://ahamilton-eval-test.apigee.net/am-test

כשמוסיפים את <FormParams>, Edge מגדיר את הכותרת Content-Type של הבקשה ל-"application/x-www-form-urlencoded" לפני שליחת ההודעה לשירות היעד.

<Headers> (צאצא של <Add>)

הוספת כותרות חדשות לבקשה או לתגובה שצוינו, כפי שצוין ברכיב <AssignTo>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של <Header> אלמנטים
רכיב הורה <Add>
רכיבי הצאצאים <Header>

רכיב <Headers> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Add>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מתווספת הכותרת user-agent להודעת הבקשה, והערך של משתנה התהליך request.user.agent מוקצה לכותרת הזו.

<AssignMessage continueOnError="false" enabled="true" name="add-headers-1">
  <Add>
    <Headers>
      <Header name="user-agent">{request.user.agent}</Header>
    </Headers>
  </Add>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

<QueryParams> (צאצא של <Add>)

הוספת פרמטרים חדשים של שאילתה לבקשה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של <QueryParam> רכיבים
רכיב הורה <Add>
רכיבי הצאצאים <QueryParam>

רכיב <QueryParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Add>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Add>
</AssignMessage>

דוגמה 1

בדוגמה הבאה נוסף לבקשה פרמטר השאילתה myParam, ומוקצה לו הערך 42:

<AssignMessage continueOnError="false" enabled="true" name="add-queryparams-1">
  <Add>
    <QueryParams>
      <QueryParam name="myParam">42</QueryParam>
    </QueryParams>
  </Add>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: GET
  • סוג ההודעה: בקשה

בנוסף, אפשר להגדיר פרמטרים של שאילתה רק כשהמאפיין type של הרכיב <AssignTo> הוא הודעת בקשה. להגדרה שלהן בתגובה אין השפעה.

אם מגדירים במדיניות מערך ריק של פרמטרים של שאילתות (<Add><QueryParams/></Add>), המדיניות לא מוסיפה פרמטרים של שאילתות. זהו אותו הדבר כמו השמטה של <QueryParams>.

<AssignTo>

קובע על איזה אובייקט המדיניות AssignMessage פועלת. האפשרויות הן:

  • הודעת הבקשה: ה-request שהתקבל על ידי שרת ה-proxy של ה-API
  • הודעת התגובה: ה-response שהוחזר מהשרת היעד
  • הודעה מותאמת אישית: אובייקט בקשה או תגובה בהתאמה אישית

חשוב לזכור שבמקרים מסוימים אי אפשר לשנות את האובייקט שאליו חלה המדיניות AssignMessage. לדוגמה, אי אפשר להשתמש ב-<Add> או ב-<Set> כדי להוסיף או לשנות פרמטרים של שאילתה (<QueryParams>) או פרמטרים של טופס (<FormParams>) בתגובה. אפשר לשנות רק את הפרמטרים של השאילתה ואת הפרמטרים של הטופס בבקשה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <AssignMessage>
רכיבי הצאצאים ללא

אם לא מציינים את <AssignTo>, המדיניות פועלת על הבקשה או התגובה שמוגדרות כברירת מחדל, בהתאם למיקום שבו המדיניות פועלת. אם המדיניות מופעלת בתהליך הבקשה, היא משפיעה על הודעת הבקשה. אם הוא מופעל בתהליך התגובה, המדיניות משפיעה על התגובה כברירת מחדל.

רכיב <AssignTo> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מצוין שהיעד הוא הבקשה המקורית שתישלח לנקודת הקצה של היעד:

<AssignMessage name="assignto-1">
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

כשמגדירים את createNew לערך 'false' (ברירת המחדל), הדוגמה הזו לא יוצרת בקשה חדשה. כל הפעולות במדיניות הזו משפיעות על הבקשה המקורית.

דוגמה 2

בדוגמה הבאה נוצר אובייקט בקשה חדש:

<AssignMessage name="assignto-2">
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

כשיוצרים אובייקט בקשה או תגובה חדש, הרכיבים האחרים של מדיניות AssignMessage (כמו <Add>,‏ <Set> ו-<Set>) פועלים על אובייקט הבקשה החדש.

אפשר לגשת לאובייקט הבקשה החדש במדיניות אחרת בשלב מאוחר יותר בתהליך, או לשלוח את אובייקט הבקשה החדש לשירות חיצוני באמצעות מדיניות ServiceCallout.

דוגמה 3

בדוגמה הבאה נוצר אובייקט בקשה חדש בשם MyRequestObject:

<AssignMessage name="assignto-2">
  <AssignTo createNew="true" transport="http" type="request"&gt;MyRequestObject&lt;/AssignTo>
</AssignMessage>

כשיוצרים אובייקט בקשה או תגובה חדש, הרכיבים האחרים של מדיניות AssignMessage (כמו <Add>,‏ <Set> ו-<Set>) פועלים על אובייקט הבקשה החדש.

אפשר לגשת לאובייקט הבקשה החדש במדיניות אחרת בשלב מאוחר יותר בתהליך, או לשלוח את אובייקט הבקשה החדש לשירות חיצוני באמצעות מדיניות ServiceCallout.

בטבלה הבאה מתוארים המאפיינים של <AssignTo>:

מאפיין תיאור חובה? סוג
createNew

קובע אם המדיניות הזו יוצרת הודעה חדשה כשמקצים ערכים.

אם הערך הוא 'true', המדיניות יוצרת משתנה חדש מהסוג שצוין ב-type ('request' או 'response'). אם לא מציינים את שם המשתנה החדש, המדיניות יוצרת אובייקט בקשה או תגובה חדש על סמך הערך של type.

אם הערך הוא 'false', המדיניות מגיבה באחת משתי דרכים:

  • אם <AssignTo> יכול לפתור את שם המשתנה לבקשה או לתגובה, הוא ממשיך את העיבוד. לדוגמה, אם המדיניות נמצאת בתהליך בקשה, המשתנה הוא אובייקט הבקשה. אם המדיניות נמצאת בתגובה, המשתנה הוא אובייקט התגובה.
  • אם לא ניתן לפתור את <AssignTo> או שהוא מוגדר כסוג שאינו הודעת אימייל, המדיניות תגרום להצגת שגיאה.

אם לא מציינים את createNew, המדיניות מגיבה באחת משתי דרכים:

  • אם <AssignTo> מתייחס להודעה, העיבוד עובר לשלב הבא.
  • אם לא ניתן לפתור את <AssignTo>, או שהוא מוגדר לסוג שאינו הודעה, נוצר משתנה חדש מהסוג שצוין ב-type.
 אופציונלי בוליאני
transport

מציין את סוג התחבורה של סוג ההודעה של הבקשה או התשובה.

ערך ברירת המחדל הוא 'http' (הערך הנתמך היחיד).

 אופציונלי מחרוזת
type מציין את סוג ההודעה החדשה, כשהערך של createNew הוא 'true'. הערכים החוקיים הם 'request' או 'response'.

ערך ברירת המחדל הוא 'request'. אם משמיטים את המאפיין הזה, Edge יוצר בקשה או תשובה, בהתאם למיקום שבו המדיניות הזו מתבצעת בתהליך.

 אופציונלי מחרוזת

<AssignVariable>

הקצאת ערך למשתנה של תהליך היעד (למשל, משתנה שהערך שלו מוגדר על ידי המדיניות AssignMessage). אם משתנה התהליך לא קיים, המערכת תיצור אותו באמצעות <AssignVariable>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג סוג מורכב
רכיב הורה <AssignMessage>
רכיבי הצאצאים <Name> (חובה)
<Ref>
<Template>
<Value>

הערך שמקצים למשתנה של תהליך ההגעה ליעד יכול להיות אחד מהערכים הבאים:

  • מחרוזת לטינית: משתמשים ברכיב הצאצא <Value> כדי לציין ערך של מחרוזת לטינית למשתנה של תהליך היעד.
  • משתנה תהליך: משתמשים ברכיב הצאצא <Ref> כדי לציין את הערך של משתנה תהליך קיים למשתנה התהליך של היעד. רשימה מלאה של משתני תהליך שאפשר להשתמש בהם כמקור מפורטת במאמר חומר עזר בנושא משתני תהליך.
  • תבנית הודעה: משתמשים באלמנט הצאצא <Template> כדי לציין תבנית הודעה למשתנה תהליך היעד.

רכיב <AssignVariable> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
    <Ref>source_variable</Ref>
    <Template>message_template</Template>
    or
    <Template ref='template_variable'></Template>
    <Value>variable_value</Value>
  </AssignVariable>
</AssignMessage>

משתמשים ברכיב <Ref> כדי לציין את משתנה המקור. אם אין גישה למשתנה שאליו מפנה <Ref>, Edge משתמש בערך שצוין על ידי האלמנט <Value>. אם מגדירים את <Template>, הוא מקבל עדיפות על פני שאר אלמנטים הצאצאים.

דוגמה 1

בדוגמה הבאה מוגדר הערך של משתנה חדש, myvar, לערך המילולי "42":

<AssignMessage name="assignvariable-1">
  <AssignVariable>
    <Name>myvar</Name>
    <Value>42</Value>
  </AssignVariable>
</AssignMessage>

דוגמה 2

בדוגמה הבאה, הערך של משתנה התהליך request.header.user-agent מוקצה למשתנה התהליך של היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה התהליך של היעד Country:

<AssignMessage name="assignvariable-2">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
</AssignMessage>

אם אחת מההקצאות נכשלת, Edge מקצה במקום זאת את הערך ErrorOnCopy למשתנה תהליך היעד.

אם משתני התהליך myvar או Country לא קיימים, הפונקציה <AssignVariable> יוצרת אותם.

דוגמה 3

בדוגמה הבאה נעשה שימוש ברכיב הצאצא <Template> כדי לשרשר בין שתי משתני הקשר עם מחרוזת לטינית (קו מפריד) ביניהן:

<AssignMessage name='template-1'>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template>{system.uuid}-{messageid}</Template>
  </AssignVariable>
</AssignMessage>

שימוש נפוץ ב-<AssignVariable> הוא להגדרת ערך ברירת מחדל לפרמטר של שאילתה, לכותרת או לערך אחר שאפשר להעביר עם הבקשה. עושים זאת באמצעות שילוב של רכיבי הצאצא <Ref> ו-<Value>. למידע נוסף, ראו את הדוגמאות ל-<Ref>.

<Name> (צאצא של <AssignVariable>)

שם המשתנה של תהליך היעד (למשל, המשתנה שהערך שלו מוגדר על ידי המדיניות AssignMessage). אם המשתנה ששמו מופיע ב-<AssignVariable> לא קיים, המדיניות יוצרת משתנה בשם הזה.

ערך ברירת המחדל לא רלוונטי
חובה? חובה
סוג מחרוזת
רכיב הורה <AssignVariable>
רכיבי הצאצאים ללא

רכיב <Name> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
  </AssignVariable>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, משתנה היעד נקבע כ-myvar והוא מוגדר לערך הלטרלי '42':

<AssignMessage name="assignvariable-1">
  <AssignVariable>
    <Name>myvar</Name>
    <Value>42</Value>
  </AssignVariable>
</AssignMessage>

אם myvar לא קיים, <AssignVariable> יוצר אותו.

<Ref> (צאצא של <AssignVariable>)

מציין את המקור של ההקצאה כמשתנה תהליך. משתנה התהליך יכול להיות אחד ממשתני התהליך שמוגדרים מראש (כפי שמפורטים בחומר העזר בנושא משתני תהליך), או משתנה תהליך מותאם אישית שיצרתם.

הערך של <Ref> תמיד מפורש כמשתנה תהליך. אי אפשר לציין מחרוזת לטינית כערך. כדי להקצות ערך מחרוזת מילולי, צריך להשתמש ברכיב <Value> במקום זאת.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <AssignVariable>
רכיבי הצאצאים ללא

כשמציינים משתנה תהליך באמצעות <Ref>, צריך להשמיט את סוגרי הסוגריים "{}" שבהם משתמשים בדרך כלל כדי להפנות למשתנה תהליך. לדוגמה, כדי להגדיר את הערך של המשתנה החדש לערך של משתנה התהליך client.host:

Do this (no brackets):
  <Ref>client.host</Ref>

Do NOT do this (brackets):
  <Ref>{client.host}</Ref>

כדי להגדיר ערך ברירת מחדל למשתנה של תהליך היעד, משתמשים ב-<Value> יחד עם <Ref>. אם משתנה התהליך שצוין על ידי <Ref> לא קיים, לא ניתן לקרוא אותו או שהוא null,‏ Edge מקצה את הערך של <Value> למשתנה התהליך של היעד במקום זאת.

רכיב <Ref> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
    <Ref>source_variable</Ref>
  </AssignVariable>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של משתנה התהליך request.header.user-agent מוקצה למשתנה התהליך של היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:

<AssignMessage name="assignvariable-4">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
  </AssignVariable>
</AssignMessage>

בדוגמה הזו, לא הוגדרה ב-Edge ברירת מחדל (או ערך חלופי) לאף אחת מהמשימות.

דוגמה 2

בדוגמה הבאה, הערך של משתנה הזרימה request.header.user-agent מוקצה למשתנה הזרימה של היעד myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:

<AssignMessage name="assignvariable-2">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
</AssignMessage>

בדוגמה הזו, אם הערכים של משתנה התהליך request.header.user-agent או של פרמטר השאילתה Country הם null, לא ניתנים לקריאה או בפורמט שגוי, Edge מקצה את הערך ErrorOnCopy למשתנים החדשים.

דוגמה 3

תרחיש לדוגמה נפוץ ל-<AssignVariable> הוא להגדיר את ערך ברירת המחדל של פרמטר של שאילתה, כותרת או ערך אחר שאפשר להעביר עם הבקשה. לדוגמה, יוצרים שרת proxy של API למזג האוויר שבו הבקשה כוללת פרמטר שאילתה יחיד בשם 'w'. הפרמטר הזה מכיל את המזהה של העיר שעבורה רוצים לקבל את מזג האוויר. כתובת ה-URL של הבקשה היא בפורמט הבא:

http://myCO.com/v1/weather/forecastrss?w=city_ID

כדי להגדיר ערך ברירת מחדל ל-'w', יוצרים מדיניות AssignMessage כמו זו:

<AssignMessage continueOnError="false" enabled="true" name="assignvariable-3">
  <AssignTo createNew="false" transport="http" type="request"/>
  <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>request.queryparam.w</Name>
    <Ref>request.queryparam.w</Ref>
    <Value>12797282</Value>
  </AssignVariable>
</AssignMessage>

בדוגמה הזו, המשתנה <AssignVariable> מקבל את הערך של request.queryparam.w ומקצה אותו לעצמו. אם משתנה התהליך הוא null, כלומר פרמטר השאילתה 'w' לא נכלל בבקשה, בדוגמה הזו נעשה שימוש בערך ברירת המחדל מהרכיב <Value>. לכן, אפשר לשלוח בקשה לשרת proxy של ה-API הזה בלי פרמטר השאילתה 'w':

http://myCO.com/v1/weather/forecastrss

...ועדיין לקבל תוצאה תקינה מהשרת proxy של ה-API.

בניגוד לשימוש ב-<Value>, הערך של <Ref> חייב להיות משתנה תהליך, כמו מאפיין של אובייקט request, response או target. הערך יכול להיות גם משתנה תהליך מותאם אישית שיצרתם.

אם מציינים משתנה תהליך שלא קיים עבור הערך של <Ref>, והערך של <IgnoreUnresolvedVariables> הוא 'true', ‏ Edge יוצר שגיאה.

<Template> (צאצא של <AssignVariable>)

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

משתמשים במאפיין ref כדי לציין משתנה תהליך שבו הערך של המשתנה הוא תבנית הודעה. לדוגמה, אפשר לאחסן תבנית הודעה בתור מאפיין מותאם אישית באפליקציית פיתוח. כש-Edge מזהה את אפליקציית הפיתוח אחרי שהוא מאמת את מפתח ה-API או את אסימון האבטחה (באמצעות מדיניות נוספת), הרכיב <AssignVariable> יכול להשתמש בתבנית ההודעה מהמאפיין המותאם אישית של האפליקציה, שזמין כמשתנה תהליך ממדיניות האבטחה. בדוגמה הבאה נניח שתבנית ההודעה זמינה במאפיין לקוח שנקרא message_template באפליקציית המפתח שמבצעת את קריאת ה-API, שבה נעשה שימוש במדיניות VerifyAPIKey כדי לאמת את מפתח ה-API של האפליקציה:

<AssignVariable ref='verifyapikey.myVerifyAPIKeyPolicy.app.name.message_template'/>

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <AssignVariable>
רכיבי הצאצאים ללא

רכיב <Template> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Template>message_template</Template>
    or
    <Template ref='template_variable'></Template>
  </AssignVariable>
</AssignMessage>

דוגמה 1

בדוגמה הבאה נעשה שימוש בתחביר של תבניות הודעות כדי לשרשר שני משתני הקשר עם מחרוזת לטינית (קו מפריד) ביניהם:

<AssignMessage name='template-1'>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template>{system.uuid}-{messageid}</Template>
  </AssignVariable>
</AssignMessage>

דוגמה 2

בדוגמה הבאה מצוין משתנה תהליך, שבו הערך של המשתנה הוא תבנית הודעה מוגדרת מראש. אפשר להשתמש באפשרות הזו כדי להחדיר תבנית מוגדרת מראש בסביבת זמן הריצה בלי לשנות את המדיניות:

<AssignMessage name='template-2'>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template ref='my_template_variable'/>

  </AssignVariable>
</AssignMessage>

דוגמה 3

בדוגמה הבאה מצוין משתנה תהליך וערך טקסט. במקרה כזה, אם המשתנה שאליו מפנים הוא לא null, המערכת משתמשת בערך הזה בתור התבנית. אם הערך שאליו מתייחסים הוא null, המערכת משתמשת בערך הטקסט (במקרה הזה, {system.uuid}-{messageid}) בתור התבנית. התבנית הזו שימושית כדי לספק ערך 'שינוי', במקרים שבהם רוצים לשנות את תבנית ברירת המחדל (חלק הטקסט) לערכים שמוגדרים באופן דינמי. לדוגמה, משפט מותנה יכול לאחזר ערך ממפה של מפתח/ערך ולהגדיר את המשתנה שמצוין לערך הזה:

<AssignMessage name='template-2'>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <AssignVariable>
    <Name>my_destination_variable</Name>
    <Value>BADDBEEF</Value>
    <Template ref='my_variable'>{system.uuid}-{messageid}</Template>
  </AssignVariable>
</AssignMessage>

<Value> (צאצא של <AssignVariable>)

מגדיר את הערך של משתנה תהליך היעד שהוגדר באמצעות <AssignVariable>. הערך תמיד מפורש כמחרוזת לינארית. אי אפשר להשתמש במשתנה תהליך בתור הערך, גם אם עוטפים את הערך בסוגריים ("{}"). כדי להשתמש במשתנה תהליך, צריך להשתמש ב-<Ref> במקום זאת.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <AssignVariable>
רכיבי הצאצאים ללא

כשמשתמשים בו בשילוב עם האלמנט <Ref>, הערך <Value> משמש כערך ברירת המחדל (או הערך החלופי). אם לא צוין ערך ל-<Ref>, אם לא ניתן לפתור אותו או אם הוא null, המערכת תשתמש בערך של <Value>.

רכיב <Value> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <AssignVariable>
    <Name>variable_name</Name>
    <Value>variable_value</Value>
  </AssignVariable>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר הערך של משתנה תעבורת היעד, myvar, לערך הלטרלי '42':

<AssignMessage name="assignvariable-1">
  <AssignVariable>
    <Name>myvar</Name>
    <Value>42</Value>
  </AssignVariable>
</AssignMessage>

דוגמה 2

בדוגמה הבאה, הערך של משתנה התהליך request.header.user-agent מוקצה למשתנה התהליך myvar, והערך של פרמטר השאילתה country מוקצה למשתנה Country:

<AssignMessage name="assignvariable-2">
  <AssignVariable>
    <Name>myvar</Name>
    <Ref>request.header.user-agent</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>Country</Name>
    <Ref>request.queryparam.country</Ref>
    <Value>ErrorOnCopy</Value>
  </AssignVariable>
</AssignMessage>

אם אחת מההקצאות נכשלת, <AssignVariable> מקצה במקום זאת את הערך ErrorOnCopy למשתנה תהליך היעד.

<Copy>

מעתיק ערכים מ ההודעה שצוינה במאפיין source אל ההודעה שצוינה ברכיב <AssignTo>. אם לא מציינים יעד באמצעות <AssignTo>, המדיניות הזו מעתיקה את הערכים לבקשה או לתגובה, בהתאם למיקום שבו המדיניות הזו פועלת בתהליך.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <AssignMessage>
רכיבי הצאצאים <FormParams>
<Headers>
<Path>
<Payload>
<QueryParams>
<ReasonPhrase>
<StatusCode>
<Verb>
<Version>

רכיב <Copy> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
    <Copy source="[request|response]">
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>[false|true]</Path>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>[false|true]</ReasonPhrase>
    <StatusCode>[false|true]</StatusCode>
    <Verb>[false|true]</Verb>
    <Version>[false|true]</Version>
  </Copy>
  <!-- Used as the destination for the <Copy> values -->
  <AssignTo createNew="[true|false]" transport="http"
    type="[request|response]">destination_variable_name</AssignTo>
</AssignMessage>

דוגמה 1

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

<AssignMessage continueOnError="false" enabled="true" name="copy-1">
  <Copy source="request">
    <Headers>
      <Header name="Header_Name_1">Header value 1</Header>
    </Headers>
    <FormParams>
      <FormParam name="Form_Param_Name_1">Form param value 1</FormParam>
      <FormParam name="Form_Param_Name_2">Form param value 1</FormParam>
      <FormParam name="Form_Param_Name_3">Form param value 1</FormParam>
    </FormParams>
    <Payload>false</Payload>
    <Path>true</Path>
    <QueryParams/>
    <ReasonPhrase>false</ReasonPhrase>
    <StatusCode>false</StatusCode>
    <Verb>false</Verb>
    <Version>false</Version>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

לרכיב <Copy> יש את המאפיינים הבאים:

מאפיין תיאור חובה? סוג
source

מציין את אובייקט המקור של העותק.

  • אם לא מציינים את source, הוא מטופל כהודעה פשוטה. לדוגמה, אם המדיניות נמצאת בתהליך הבקשה, ברירת המחדל של המקור היא האובייקט request. אם המדיניות נמצאת בתהליך התגובה, ברירת המחדל היא אובייקט response. אם משמיטים את source, אפשר להשתמש בהפניה אבסולטית למשתנה תהליך בתור המקור של העותק. לדוגמה, מציינים את הערך בתור {request.header.user-agent}.
  • אם לא ניתן לפתור את משתנה המקור, או שהוא מוגדר כסוג שאינו הודעה, <Copy> לא יגיב.
 אופציונלי מחרוזת

<FormParams> (צאצא של <Copy>)

הפונקציה מעתיקה את הפרמטרים של הטופס מהבקשה שצוינה במאפיין source של הרכיב <Copy> אל הבקשה שצוינה ברכיב <AssignTo>. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של רכיבי <FormParam> או מערך ריק
רכיב הורה <Copy>
רכיבי הצאצאים <FormParam>

רכיב <FormParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, פרמטר טופס אחד מועתק מהבקשה לבקשה בהתאמה אישית בשם MyCustomRequest:

<AssignMessage name="copy-formparams-1">
  <Copy source="request">
    <FormParams>
      <FormParam name="paramName">Form param value 1</FormParam>
    </FormParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 2

בדוגמה הבאה כל הפרמטרים של הטופס מועתקים לבקשה בהתאמה אישית 'MyCustomRequest':

<AssignMessage name="copy-formparams-2">
  <Copy source="request">
    <FormParams/>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 3

בדוגמה הבאה מועתקים שלושה פרמטרים של טופס לבקשה בהתאמה אישית בשם MyCustomRequest:

<AssignMessage name="copy-formparams-3">
  <Copy source="request">
    <FormParams>
      <FormParam name="paramName1"/>
      <FormParam name="paramName2"/>
      <FormParam name="paramName3"/>
    </FormParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 4

אם יש כמה פרמטרים של טופס עם אותו שם, צריך להשתמש בסינטקס הבא:

<AssignMessage name="copy-formparams-4">
  <Copy source="request">
    <FormParams>
      <FormParam name="f1"/>
      <FormParam name="f2"/>
      <FormParam name="f3.2"/>
    </FormParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

בדוגמה הזו, מתבצעת העתקה של 'f1', 'f2' והערך השני של 'f3'. אם למשתנה f3 יש רק ערך אחד, הוא לא יועתק.

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: POST
  • סוג ההודעה: תגובה
  • אחת (או שתיהן) מהאפשרויות הבאות:
    • נתוני טופס: מוגדר לערך כלשהו, או ל-"" (המחרוזת הריקה). לדוגמה, ב-curl, מוסיפים את -d "" לבקשה.
    • כותרת Content-Length: מגדירים ל-0 (אם אין נתונים בבקשה המקורית, אחרת מגדירים את האורך הנוכחי. לדוגמה, ב-curl מוסיפים את -H "Content-Length: 0" לבקשה.

כשמעתיקים את <FormParams>, <Copy> מגדיר את Content-Type של ההודעה לערך ‎"application/x-www-form-urlencoded"‎ לפני שליחת ההודעה לשירות היעד.

<Headers> (צאצא של <Copy>)

הפונקציה מעתיקה כותרות HTTP מ הודעת הבקשה או התגובה שצוינה במאפיין source של האלמנט <Copy> אל הודעת הבקשה או התגובה שצוינה באלמנט <AssignTo>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של רכיבי <Header> או מערך ריק
רכיב הורה <Copy>
רכיבי הצאצאים <Header>

רכיב <Headers> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה הכותרת user-agent מועתקת מהבקשה לאובייקט הבקשה החדש המותאם אישית:

<AssignMessage name="copy-headers-1">
  <Copy source="request">
    <Headers>
      <Header name="user-agent"/>
    </Headers>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 2

כדי להעתיק את כל הכותרות, משתמשים ברכיב <Headers> ריק, כפי שמתואר בדוגמה הבאה:

<AssignMessage name="copy-headers-2">
  <Copy source="request">
    <Headers/>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 3

אם יש כמה כותרות עם אותו שם, צריך להשתמש בסינטקס הבא:

<AssignMessage name="copy-headers-3">
  <Copy source="request">
    <Headers>
      <Header name="h1"/>
      <Header name="h2"/>
      <Header name="h3.2"/>
    </Headers>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

בדוגמה הזו, מתבצעת העתקה של 'h1', 'h2' והערך השני של 'h3'. אם למשתנה 'h3' יש רק ערך אחד, הוא לא יועתק.

<Path> (צאצא של <Copy>)

קובע אם צריך להעתיק את הנתיב מהבקשה המקורית לבקשת היעד. לרכיב הזה אין השפעה על התגובה.

אם הערך הוא 'true', המדיניות הזו מעתיקה את הנתיב מ הודעת הבקשה שצוינה במאפיין source של הרכיב <Copy> אל הודעת הבקשה שצוינה ברכיב <AssignTo>.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Copy>
רכיבי הצאצאים ללא

רכיב <Path> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Path>[false|true]</Path>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוצג שהמדיניות של AssignMessage צריכה להעתיק את הנתיב מהבקשה המקורית לאובייקט הבקשה החדש בהתאמה אישית:

<AssignMessage name="copy-path-1">
  <Copy source="request">
    <Path>true</Path>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Path> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: בקשה

<Payload> (צאצא של <Copy>)

קובע אם יש להעתיק את עומס העבודה מהמקור ליעד. המקור והיעד יכולים להיות בקשות או תשובות.

אם הערך הוא 'true', המדיניות הזו מעתיקה את עומס העבודה מ ההודעה שצוינה במאפיין source של הרכיב <Copy> אל ההודעה שצוינה ברכיב <AssignTo>.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Copy>
רכיבי הצאצאים ללא

רכיב <Payload> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Payload>[false|true]</Payload>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <Payload> מוגדר ל-true כדי שהמטען הייעודי של הבקשה יועתק מהבקשה לתגובה:

<AssignMessage name="copy-payload-1">
  <Copy source="request">
    <Payload>true</Payload>
  </Copy>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

<QueryParams> (צאצא של <Copy>)

הקוד מעתיק את הפרמטרים של מחרוזת השאילתה מ הבקשה שצוינה במאפיין source של האלמנט <Copy> אל הבקשה שצוינה באלמנט <AssignTo>. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של רכיבי <QueryParam> או מערך ריק
רכיב הורה <QueryParam>
רכיבי הצאצאים ללא

רכיב <QueryParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, פרמטר השאילתה my_param מועתק מהבקשה לאובייקט בקשה חדש בהתאמה אישית:

<AssignMessage name="copy-queryparams-1">
  <Copy source="request">
    <QueryParams>
      <QueryParam name="my_param"/>
    </QueryParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 2

בדוגמה הבאה כל פרמטרי השאילתה מהבקשה מועתקים לאובייקט בקשה חדש בהתאמה אישית:

<AssignMessage name="copy-queryparams-2">
  <Copy source="request">
    <QueryParams/>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

דוגמה 3

אם יש כמה פרמטרים של שאילתה עם אותו שם, צריך להשתמש בתחביר הבא:

<AssignMessage name="copy-queryparams-3">
  <Copy source="request">
    <QueryParams>
      <QueryParam name="qp1"/>
      <QueryParam name="qp2"/>
      <QueryParam name="qp3.2"/>
    </QueryParams>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

בדוגמה הזו, מתבצעת העתקה של 'qp1', 'qp2' והערך השני של 'qp3'. אם למשתנה qp3 יש רק ערך אחד, הוא לא יועתק.

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: GET
  • סוג ההודעה: בקשה

<ReasonPhrase> (צאצא של <Copy>)

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

אם הערך הוא 'true', המדיניות הזו מעתיקה את ReasonPhrase מ התגובה שצוינה במאפיין source של הרכיב <Copy> אל התגובה שצוינה ברכיב <AssignTo>.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Copy>
רכיבי הצאצאים ללא

רכיב <ReasonPhrase> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <ReasonPhrase>[false|true]</ReasonPhrase>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <ReasonPhrase> מוגדר ל-true, וכתוצאה מכך הפונקציה <Copy> מעתיקה את ביטוי הסיבה מהתגובה שמוגדרת כברירת מחדל לאובייקט תגובה מותאם אישית:

<AssignMessage name="copy-reasonphrase-1">
  <Copy source="response">
    <ReasonPhrase>true</ReasonPhrase>
  </Copy>
  <AssignTo createNew="trie" transport="http" type="response">MyCustomResponse</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<ReasonPhrase> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: תגובה

<StatusCode> (צאצא של <Copy>)

קובע אם קוד הסטטוס יועתק מהתגובה של המקור לתגובה של היעד. לרכיב הזה אין השפעה על בקשה.

אם הערך הוא 'true', המדיניות הזו מעתיקה את קוד הסטטוס מ הודעת התגובה שצוינה במאפיין source של הרכיב <Copy> אל הודעת התגובה שצוינה ברכיב <AssignTo>.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Copy>
רכיבי הצאצאים ללא

רכיב <StatusCode> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <StatusCode>[false|true]</StatusCode>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <StatusCode> מוגדר ל-true, וכתוצאה מכך קוד הסטטוס מעתיק מאובייקט התגובה שמוגדר כברירת מחדל לאובייקט תגובה חדש בהתאמה אישית:

<AssignMessage name="copy-statuscode-1">
  <Copy source="response">
    <StatusCode>true</StatusCode>
  </Copy>
  <AssignTo createNew="true" transport="http" type="response">MyCustomResponse</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<StatusCode> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: תגובה

שימוש נפוץ ב-<StatusCode> הוא כדי לוודא שלתשובה מה-proxy יש את אותו סטטוס כמו התשובה שהתקבלה מהיעד, כשהמאפיין createNew של <AssignTo> מוגדר כ-true.

<Verb> (צאצא של <Copy>)

הפונקציה קובעת אם פעולת ה-HTTP מועתקת מהבקשה המקורית לבקשת היעד. לרכיב הזה אין השפעה על התגובה.

אם הערך הוא 'true', הפונקציה מעתיקה את הפועל שנמצא במאפיין source של הרכיב <Copy> לבקשה שצוינה ברכיב <AssignTo>.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Copy>
רכיבי הצאצאים ללא

רכיב <Verb> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Verb>[false|true]</Verb>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <Verb> מוגדר כ-true, וכך הפועל מועתק מהבקשה שמוגדרת כברירת מחדל לבקשה חדשה בהתאמה אישית:

<AssignMessage name="copy-verb-1">
  <Copy source="request">
    <Verb>true</Verb>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Verb> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: בקשה

<Version> (צאצא של <Copy>)

קובעת אם גרסת ה-HTTP תועתק מבקשת המקור לבקשת היעד. לרכיב הזה אין השפעה על התגובה.

אם הערך הוא 'true', מתבצע העתקה של גרסת ה-HTTP שנמצאת במאפיין source של האלמנט <Copy> לאובייקט שצוין על ידי האלמנט <AssignTo>.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Copy>
רכיבי הצאצאים ללא

רכיב <Version> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Copy source="[request|response]">
    <Version>[false|true]</Version>
  </Copy>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <Version> מוגדר ל-'true' בבקשה, וכתוצאה מכך הגרסה מועתקת מאובייקט הבקשה שמוגדר כברירת מחדל לאובייקט בקשה חדש בהתאמה אישית:

<AssignMessage name="copy-version-1">
  <Copy source="request">
    <Version>true</Version>
  </Copy>
  <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<Version> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: בקשה

<DisplayName>

אפשר להשתמש במאפיין name כדי לתייג את המדיניות בכלי העריכה של שרת ה-proxy בממשק המשתמש לניהול, בשם שונה שנשמע טבעי יותר.

הרכיב <DisplayName> הוא משותף לכל כללי המדיניות.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי. אם משמיטים את <DisplayName>, המערכת משתמשת בערך של המאפיין name של המדיניות
סוג מחרוזת
רכיב הורה <PolicyElement>
רכיבי הצאצאים ללא

רכיב <DisplayName> כולל את התחביר הבא:

תחביר

<PolicyElement>
  <DisplayName>policy_display_name</DisplayName>
  ...
</PolicyElement>

דוגמה

<PolicyElement>
  <DisplayName>My Validation Policy</DisplayName>
</PolicyElement>

לאלמנט <DisplayName> אין מאפיינים או רכיבי צאצא.

<IgnoreUnresolvedVariables>

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

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <AssignMessage>
רכיבי הצאצאים ללא

מגדירים את הערך true כדי להתעלם משתנים שלא נפתרו ולהמשיך בעיבוד. אחרת, מגדירים את הערך false. ערך ברירת המחדל הוא false.

ההגדרה של <IgnoreUnresolvedVariables> לערך true שונה מהגדרה של continueOnError של <AssignMessage> לערך true, כי היא ספציפית להגדרה ולקבלה של ערכים של משתנים. אם מגדירים את continueOnError לערך true, דפדפן Edge מתעלם מכל השגיאות, ולא רק מהשגיאות שנתקלים בהן בזמן השימוש במשתנים.

רכיב <IgnoreUnresolvedVariables> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <IgnoreUnresolvedVariables>[true|false]</IgnoreUnresolvedVariables>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <IgnoreUnresolvedVariables> מוגדר כ-true:

<AssignMessage name="ignoreunresolvedvariables">
  <Copy source="response">
    ...
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
  </Copy>
</AssignMessage>

<Remove>

הסרת כותרות, פרמטרים של שאילתות, פרמטרים של טפסים ו/או את עומס העבודה של ההודעה. ההודעה יכולה להיות בקשה או תשובה. כדי לציין על איזו הודעה <Remove> יפעל, משתמשים ברכיב <AssignTo>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג סוג מורכב
רכיב הורה <AssignMessage>
רכיבי הצאצאים <FormParams>
<Headers>
<Payload>
<QueryParams>

תרחיש לדוגמה נפוץ ל-<Remove> הוא מחיקה של פרמטר שאילתה שמכיל מידע אישי רגיש מאובייקט הבקשה הנכנס, כדי להימנע מהעברתו לשרת הקצה העורפי.

רכיב <Remove> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Payload>[false|true]</Payload>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Remove>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, גוף ההודעה מוסר מהתגובה:

<AssignMessage continueOnError="false" enabled="true" name="remove-1">
  <DisplayName>remove-1</DisplayName>
  <Remove>
    <Payload>true</Payload>
  </Remove>
  <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

בתהליך התגובה, המדיניות הזו מסירה את גוף התגובה ומחזירה ללקוח רק כותרות HTTP.

דוגמה 2

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

<AssignMessage continueOnError="false" enabled="true" name="remove-2">
  <Remove>
    <!-- Empty (<FormParams/>) removes all form parameters -->
    <FormParams/>
    <QueryParams>
      <QueryParam name="qp1"/>
    </QueryParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

<FormParams> (צאצא של <Remove>)

הסרת פרמטרים של טפסים שצוינו מהבקשה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של רכיבי <FormParam> או מערך ריק
רכיב הורה <Remove>
רכיבי הצאצאים <FormParam>

רכיב <FormParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<FormParams/>) -->
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  </Remove>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מסירים מהבקשה שלושה פרמטרים של טופס:

<AssignMessage name="remove-formparams-1">
  <Remove>
    <FormParams>
      <FormParam name="form_param_1"/>
      <FormParam name="form_param_2"/>
      <FormParam name="form_param_3"/>
    </FormParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="application/x-www-form-urlencoded"/>
</AssignMessage>

דוגמה 2

בדוגמה הבאה כל פרמטר הטופס הוסר מהבקשה:

<AssignMessage name="remove-formparams-2">
  <Remove>
    <FormParams/>
  </Remove>
  <AssignTo createNew="false" transport="http" type="application/x-www-form-urlencoded"/>
</AssignMessage>

דוגמה 3

אם יש כמה פרמטרים של טופס עם אותו שם, צריך להשתמש בסינטקס הבא:

<AssignMessage name="remove-formparams-3">
  <Remove>
    <FormParams>
      <FormParam name="f1"/>
      <FormParam name="f2"/>
      <FormParam name="f3.2"/>
    </FormParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="application/x-www-form-urlencoded"/>
</AssignMessage>

בדוגמה הזו, המערכת מסירה את 'f1', את 'f2' ואת הערך השני של 'f3'. אם ל-"f3" יש רק ערך אחד, הוא לא יוסר.

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: בקשה
  • Content-Type: ‎"application/x-www-form-urlencoded"‎

<Headers> (צאצא של <Remove>)

הסרה של כותרות ה-HTTP שצוינו מהבקשה או מהתגובה, כפי שצוין ברכיב <AssignTo>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של רכיבי <Header> או מערך ריק
רכיב הורה <Remove>
רכיבי הצאצאים <Header>

רכיב <Headers> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<Headers/>) -->
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Remove>
</AssignMessage>

דוגמה 1

בדוגמה הבאה הכותרת user-agent מסירה מהבקשה:

<AssignMessage name="remove-headers-1">
  <Remove>
    <Headers>
      <Header name="user-agent"/>
    </Headers>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

דוגמה 2

בדוגמה הבאה כל הכותרות יוסרו מהבקשה:

<AssignMessage name="remove-headers-2">
  <Remove>
    <Headers/>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

דוגמה 3

אם יש כמה כותרות עם אותו שם, צריך להשתמש בסינטקס הבא:

<AssignMessage name="remove-headers-3">
  <Remove>
    <Headers>
      <Header name="h1"/>
      <Header name="h2"/>
      <Header name="h3.2"/>
    </Headers>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

בדוגמה הזו, המערכת מסירה מהבקשה את השדות 'h1', 'h2' ואת הערך השני של 'h3'. אם ל-'h3' יש רק ערך אחד, הוא לא יוסר.

<Payload> (צאצא של <Remove>)

קובע אם <Remove> מוחקת את עומס העבודה בבקשה או בתגובה, שצוין על ידי האלמנט <AssignTo>. מגדירים את הערך 'true' כדי לנקות את עומס העבודה, אחרת מגדירים את הערך 'false'. ערך ברירת המחדל הוא 'false'.

ערך ברירת המחדל לא נכון
חובה? אופציונלי
סוג בוליאני
רכיב הורה <Remove>
רכיבי הצאצאים ללא

רכיב <Payload> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <Payload>[false|true]</Payload>
  </Remove>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הערך של <Payload> מוגדר ל-true כדי לנקות את עומס העבודה של הבקשה:

<AssignMessage name="remove-payload-1">
  <Remove>
    <Payload>true</Payload>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

<QueryParams> (צאצא של <Remove>)

הסרת פרמטרים של שאילתות שצוינו מהבקשה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של רכיבי <QueryParam> או מערך ריק
רכיב הורה <Remove>
רכיבי הצאצאים <QueryParam>

רכיב <QueryParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Remove>
    <!-- Can also be an empty array (<QueryParams/>) -->
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Remove>
</AssignMessage>

דוגמה 1

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

<AssignMessage name="remove-queryparams-1">
  <Remove>
      <QueryParams>
        <QueryParam name="qp1"/>
      </QueryParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

דוגמה 2

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

<AssignMessage name="remove-queryparams-2">
  <Remove>
      <QueryParams/>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

דוגמה 3

אם יש כמה פרמטרים של שאילתה עם אותו שם, צריך להשתמש בתחביר הבא:

<AssignMessage name="remove-queryparams-3">
  <Remove>
      <QueryParams>
        <QueryParam name="qp1"/>
        <QueryParam name="qp2"/>
        <QueryParam name="qp3.2"/>
      </QueryParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

בדוגמה הזו, המערכת מסירה מהבקשה את 'qp1', את 'qp2' ואת הערך השני של 'qp3'. אם ל-qp3 יש רק ערך אחד, הוא לא יוסר.

דוגמה 4

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

<AssignMessage name="remove-query-param">
  <Remove>
    <QueryParams>
      <QueryParam name="apikey"/>
    </QueryParams>
  </Remove>
  <AssignTo createNew="false" transport="http" type="request"/>
</AssignMessage>

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: GET
  • סוג ההודעה: בקשה

<Set>

מגדיר מידע בהודעת הבקשה או התגובה, שצוין על ידי הרכיב <AssignTo>. <Set> מחליף כותרות או פרמטרים שכבר קיימים בהודעה המקורית. כדי ליצור כותרת או פרמטר חדשים, משתמשים במקום זאת ברכיב <Add>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג סוג מורכב
רכיב הורה <AssignMessage>
רכיבי הצאצאים <FormParams>
<Headers>
<Payload>
<Path>
<QueryParams>
<ReasonPhrase>
<StatusCode>
<Verb>
<Version>

רכיב <Set> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
    <Path>path</Path>
    <Payload contentType="content_type" variablePrefix="prefix"
        variableSuffix="suffix">new_payload</Payload>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
    <ReasonPhrase>reason_for_error or {variable}</ReasonPhrase>
    <StatusCode>HTTP_status_code or {variable}</StatusCode>
    <Verb>[GET|POST|PUT|PATCH|DELETE|{variable}]</Verb>
    <Version>[1.0|1.1|{variable}]</Verb>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוצג האלמנט <Set>:

<AssignMessage continueOnError="false" enabled="true" name="set-1">
  <Set>
    <FormParams>
      <FormParam name="myparam">{request.header.myparam}</FormParam>
    </FormParams>
    <Headers>
        <Header name="user-agent">{request.header.user-agent}</Header>
    </Headers>
    <QueryParams>
      <QueryParam name="name">{request.header.name}</QueryParam>
      <QueryParam name="address">{request.header.address}</QueryParam>
    </QueryParams>
    <!-- <Verb>GET</Verb> -->
    <Payload contentType="text/plain">42</Payload>
    <Path/>
    <ReasonPhrase>Bad request</ReasonPhrase>
    <StatusCode>400</StatusCode>
    <Verb>POST</Verb>
    <Verb>{my_variable}</Verb>
    <Version>1.1</Version>
  </Set>
  <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

<FormParams> (צאצא של <Set>)

הרכיב הזה מחליף את הפרמטרים הקיימים של הטופס בבקשה ומחליף אותם בערכים החדשים שציינתם באמצעות הרכיב הזה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של <FormParam> אלמנטים
רכיב הורה <Set>
רכיבי הצאצאים <FormParam>

רכיב <FormParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <FormParams>
      <FormParam name="formparam_name">formparam_value</FormParam>
      ...
    </FormParams>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר פרמטר טופס שנקרא myparam לערך של המשתנה request.header.myparam בבקשה חדשה בהתאמה אישית:

<AssignMessage name="set-formparams-1">
  <Set>
    <FormParams>
      <FormParam name="myparam">{request.header.myparam}</FormParam>
    </FormParams>
  </Set>
    <AssignTo createNew="true" transport="http" type="request">MyCustomRequest</AssignTo>
</AssignMessage>

אפשר להשתמש ב-<FormParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: POST
  • סוג ההודעה: בקשה

אם מגדירים פרמטרים ריקים של טפסים במדיניות (<Add><FormParams/></Add>), המדיניות לא מוסיפה פרמטרים של טפסים. זהו אותו הדבר כמו השמטת <FormParams>.

<Set> משנה את Content-Type של ההודעה ל-"application/x-www-form-urlencoded" לפני השליחה לנקודת הקצה של היעד.

<Headers> (צאצא של <Set>)

מחליף את כותרות ה-HTTP הקיימות בבקשה או בתגובה, כפי שמצוין ברכיב <AssignTo>.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של <Header> אלמנטים
רכיב הורה <Set>
רכיבי הצאצאים <Header>

רכיב <Headers> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Headers>
      <Header name="header_name">header_value</Header>
      ...
    </Headers>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, הכותרת user-agent מוגדרת לערך של המשתנה request.header.user-agent:

<AssignMessage name="set-headers-1">
  <Set>
    <Headers>
      <Header name="user-agent">{request.header.user-agent}</Header>
    </Headers>
  </Set>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

אם מגדירים כותרות ריקות במדיניות (<Add><Headers/></Add>), המדיניות לא מוסיפה כותרות. זהו אותו הדבר כמו השמטה של <Headers>.

<Path> (צאצא של <Set>)

<Payload> (צאצא של <Set>)

הגדרת גוף ההודעה של בקשה או תשובה, שמצוין על ידי הרכיב <AssignTo>. המטען הייעודי יכול להיות כל סוג תוכן חוקי, כמו טקסט פשוט, JSON או XML.

ערך ברירת המחדל מחרוזת ריקה
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <Set>
רכיבי הצאצאים ללא

רכיב <Payload> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Payload contentType="content_type" variablePrefix="prefix"
        variableSuffix="suffix">new_payload</Payload>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר מטען ייעודי (payload) של טקסט פשוט:

<AssignMessage name="set-payload-1">
  <Set>
    <Payload contentType="text/plain">42</Payload>
  </Set>
</AssignMessage>

דוגמה 2

בדוגמה הבאה מוגדר מטען ייעודי (payload) של JSON:

<AssignMessage name="set-payload-2">
  <Set>
    <Payload contentType="application/json">
      {"name":"foo", "type":"bar"}
    </Payload>
  </Set>
</AssignMessage>

דוגמה 3

בדוגמה הבאה, ערכי המשתנים מוכנסים למילוי החבילה על ידי עטיפה של שמות המשתנים בסוגריים מסולסלים:

<AssignMessage name="set-payload-3">
  <Set>
    <Payload contentType="application/json">
      {"name":"foo", "type":"{variable_name}"}
    </Payload>
  </Set>
</AssignMessage>

בגרסאות ישנות יותר של Apigee Edge – לדוגמה, לפני הגרסה 16.08.17 לענן – לא ניתן היה להשתמש בסוגריים מסולסלים כדי לציין הפניות למשתנים בתוך עומסי נתונים של JSON. בגרסאות האלה, צריך להשתמש במאפיינים variablePrefix ו-variableSuffix כדי לציין תווים מפרידים, ולהשתמש בהם כדי לעטוף את שמות המשתנים, כך:

<AssignMessage name="set-payload-3b">
  <Set>
    <Payload contentType="application/json" variablePrefix="@" variableSuffix="#">
      {"name":"foo", "type":"@variable_name#"}
    </Payload>
  </Set>
</AssignMessage>

אפשר עדיין להשתמש בתחביר הישן.

דוגמה 4

התוכן של <Payload> מטופל כתבנית של הודעה. המשמעות היא שהמדיניות של AssignMessage מחליפה משתנים שמקובצים בסוגריים מסולסלים בערך של המשתנים שצוינו בזמן הריצה.

בדוגמה הבאה נעשה שימוש בתחביר של סוגריים מסולסלים כדי להגדיר חלק ממטען הייעודי לערך משתנה:

<AssignMessage name="set-payload-4">
  <Set>
    <Payload contentType="text/xml">
      <root>
        <e1>sunday</e1>
        <e2>funday</e2>
        <e3>{var1}</e3>
      </root>
    </Payload>
  </Set>
</AssignMessage>

בטבלה הבאה מתוארים המאפיינים של <Payload>:

מאפיין תיאור נוכחות סוג
contentType

אם מצוין, הערך של contentType יוקצה לכותרת ה-HTTP‏ Content-Type.

 אופציונלי מחרוזת
variablePrefix אפשר לציין את התו המפריד המוביל במשתנה תהליך. ברירת המחדל היא '{'. למידע נוסף, ראו חומר עזר בנושא משתני תהליך. אופציונלי Char
variableSuffix אפשר לציין את התו המפריד בסוף משתנה תהליך. ברירת המחדל היא "‎}". למידע נוסף, ראו חומר עזר בנושא משתני תהליך. אופציונלי Char

<QueryParams> (צאצא של <Set>)

מחליף ערכים חדשים במקום פרמטרי השאילתה הקיימים בבקשה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מערך של <QueryParam> רכיבים
רכיב הורה <Set>
רכיבי הצאצאים <QueryParam>

רכיב <QueryParams> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <QueryParams>
      <QueryParam name="queryparam_name">queryparam_value</QueryParam>
      ...
    </QueryParams>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, פרמטר השאילתה 'address' מוגדר לערך של המשתנה request.header.address:

<AssignMessage continueOnError="false" enabled="true" name="set-queryparams-1">
  <Set>
    <QueryParams>
      <QueryParam name="address">{request.header.address}</QueryParam>
    </QueryParams>
  </Set>
</AssignMessage>

אפשר להשתמש ב-<QueryParams> רק אם מתקיימים הקריטריונים הבאים:

  • פעולת HTTP: GET
  • סוג ההודעה: בקשה

אם מגדירים פרמטרים ריקים של שאילתות במדיניות (<Set><QueryParams/></Set>), המדיניות לא מגדירה פרמטרים של שאילתות. זהו אותו הדבר כמו השמטה של <QueryParams>.

<ReasonPhrase> (צאצא של <Set>)

מגדיר את ביטוי הסיבה בתגובה. בדרך כלל עושים זאת לצורך ניפוי באגים בשילוב עם <StatusCode>. לרכיב הזה אין השפעה על בקשה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת
רכיב הורה <Set>
רכיבי הצאצאים ללא

רכיב <ReasonPhrase> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <ReasonPhrase>reason_for_error or {variable}</ReasonPhrase>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדרת ביטוי סיבה פשוט:

<AssignMessage name="set-reasonphrase-1">
  <Set>
    <ReasonPhrase>Bad medicine</ReasonPhrase>
  </Set>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

דוגמה 2

התוכן של <ReasonPhrase> מטופל כתבנית של הודעה. המשמעות היא ששם משתנה שמוקף בסוגריים מסולסלים יוחלף במהלך זמן הריצה בערך של המשתנה שאליו הופנה, כפי שמוצג בדוגמה הבאה:

<AssignMessage name="set-reasonphrase-2">
  <Set>
    <ReasonPhrase>{calloutresponse.reason.phrase}</ReasonPhrase>
  </Set>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

אפשר להשתמש ב-<ReasonPhrase> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: תגובה

<StatusCode> (צאצא של <Set>)

הגדרת קוד הסטטוס בתגובה. לרכיב הזה אין השפעה על בקשה.

ערך ברירת המחדל '200' (כשהערך של המאפיין createNew של <AssignTo> מוגדר כ-'true')
חובה? אופציונלי
סוג מחרוזת או variable
רכיב הורה <Set>
רכיבי הצאצאים ללא

רכיב <StatusCode> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <StatusCode>HTTP_status_code or {variable}</StatusCode>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר קוד סטטוס פשוט:

<AssignMessage name="set-statuscode-1">
  <Set>
    <StatusCode>404</StatusCode>
  </Set>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

דוגמה 2

התוכן של <StatusCode> מטופל כתבנית של הודעה. כלומר, שם משתנה שמוקף בסוגריים מסולסלים יוחלף במהלך זמן הריצה בערך של המשתנה שאליו הופנה, כפי שמוצג בדוגמה הבאה:

<AssignMessage name="set-statuscode-2">
  <Set>
    <StatusCode>{calloutresponse.status.code}</StatusCode>
  </Set>
  <AssignTo createNew="true" transport="http" type="response"/>
</AssignMessage>

אפשר להשתמש ב-<StatusCode> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: תגובה

<Verb> (צאצא של <Set>)

הגדרת הפועל ב-HTTP בבקשה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת או variable
רכיב הורה <Set>
רכיבי הצאצאים ללא

רכיב <Verb> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Verb>[GET|POST|PUT|PATCH|DELETE|{variable}]</Verb>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה מוגדר פועל פשוט בבקשה:

<AssignMessage name="set-verb-1">
  <Set>
    <Verb>POST</Verb>
  </Set>
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

דוגמה 2

התוכן של <Verb> מטופל כתבנית של הודעה. המשמעות היא ששם משתנה שמוקף בסוגריים מסולסלים יוחלף במהלך זמן הריצה בערך של המשתנה שאליו הוא מפנה.

בדוגמה הבאה נעשה שימוש במשתנה כדי לאכלס פועל:

<AssignMessage name="set-verb-2">
  <Set>
    <Verb>{my_variable}</Verb>
  </Set>
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

אפשר להשתמש ב-<Verb> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: בקשה

<Version> (צאצא של <Set>)

הגדרת גרסת ה-HTTP בבקשה. לרכיב הזה אין השפעה על התגובה.

ערך ברירת המחדל לא רלוונטי
חובה? אופציונלי
סוג מחרוזת או variable
רכיב הורה <Set>
רכיבי הצאצאים ללא

רכיב <Version> כולל את התחביר הבא:

תחביר

<AssignMessage
    continueOnError="[false|true]"
    enabled="[true|false]"
    name="policy_name" >
  <Set>
    <Version>[1.0|1.1|{variable}]</Verb>
  </Set>
</AssignMessage>

דוגמה 1

בדוגמה הבאה, מספר הגרסה מוגדר ל-'1.1':

<AssignMessage name="set-version-1">
  <Set>
    <Version>1.1</Version>
  </Set>
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

דוגמה 2

בקוד הבא נעשה שימוש במשתנה בסוגריים מסולסלים כדי להגדיר את מספר הגרסה:

<AssignMessage name="set-version-2">
  <Set>
    <Version>{my_version}</Version>
  </Set>
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

התוכן של <Version> מטופל כתבנית של הודעה. המשמעות היא ששם משתנה שמוקף בסוגריים מסולסלים יוחלף במהלך זמן הריצה בערך של המשתנה שאליו הוא מפנה.

אפשר להשתמש ב-<Version> רק אם מתקיימים הקריטריונים הבאים:

  • סוג ההודעה: בקשה

יצירת הודעות בקשה בהתאמה אישית

אפשר להשתמש במדיניות AssignMessage כדי ליצור הודעת בקשה בהתאמה אישית. אחרי שיוצרים בקשה בהתאמה אישית, אפשר להשתמש בה בדרכים הבאות:

  • לגשת למשתנים שלה במדיניות אחרת
  • העברה לשירות חיצוני

כדי ליצור הודעת בקשה בהתאמה אישית, משתמשים ברכיב <AssignTo> במדיניות של AssignMessage. מגדירים את createNew לערך 'true' ומציינים את השם של ההודעה החדשה בגוף הרכיב, כפי שמתואר בדוגמה הבאה:

<AssignMessage name="assignto-2">
  <AssignTo createNew="true" transport="http" type="request"/>
</AssignMessage>

כברירת מחדל, Edge לא עושה שום דבר עם הודעת הבקשה בהתאמה אישית. אחרי היצירה, Edge ימשיך בתהליך עם הבקשה המקורית. כדי להשתמש בבקשה בהתאמה אישית, צריך להוסיף לשרת ה-proxy מדיניות כמו ServiceCallout policy, שיכולה להעביר את הבקשה בהתאמה אישית לשירות חיצוני.

בדוגמאות הבאות נוצרות הודעות בקשה בהתאמה אישית:

דוגמה 1

בדוגמה הבאה נוצר אובייקט בקשה בהתאמה אישית באמצעות Assign Message:

<AssignMessage name="AssignMessage-3">
  <AssignTo createNew="true" type="request">MyCustomRequest</AssignTo>
  <Copy>
    <Headers>
     <Header name="user-agent"/>
    </Headers>
  </Copy>
  <Set>
    <QueryParams>
      <QueryParam name="address">{request.queryparam.addy}</QueryParam>
    </QueryParams>
    <Verb>GET</Verb>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

בדוגמה הזו:

  • יצירת אובייקט חדש של הודעת בקשה בשם MyCustomRequest.
  • ב-MyCustomRequest, המדיניות הזו:
    • העתקת הערך של כותרת ה-HTTP user-agent מהבקשה הנכנסת להודעה החדשה. מכיוון ש-<Copy> משתמש בהפניה מוחלטת למשתנה התהליך user-agent, אין צורך לציין את המאפיין source ל-<Copy>.
    • הגדרת פרמטר השאילתה address בהודעה בהתאמה אישית לערך של פרמטר השאילתה addy בבקשה הנכנסת.
    • מגדיר את פעולת ה-HTTP כ-GET.
  • ההגדרה של <IgnoreUnresolvedVariables> היא 'false'. כשהערך של <IgnoreUnresolvedVariables> הוא false, אם אחד המשתנים שהמדיניות מנסה להוסיף לא קיים, Edge יפסיק את העיבוד בתהליך ה-API.

דוגמה 2

דוגמה נוספת ליצירת אובייקט בקשה בהתאמה אישית באמצעות AssignMessage:

<AssignMessage name="AssignMessage-2">
  <AssignTo createNew="true" type="request">partner.request</AssignTo>
  <Set>
    <Verb>POST</Verb>
    <Payload contentType="text/xml">
      <request><operation>105</operation></request>
    </Payload>
  </Set>
</AssignMessage>

בדוגמה הזו נוצרת בקשה מותאמת אישית חדשה בשם partner.request. לאחר מכן הוא מגדיר את הערכים <Verb> ו-<Payload> בבקשה החדשה.

אפשר לגשת להודעת בקשה בהתאמה אישית במדיניות אחרת של AssignMessage שמופיעה מאוחר יותר בתהליך. בדוגמה הבאה מקבלים את הערך של הכותרת user-agent של הודעת הבקשה בהתאמה אישית:

<AssignMessage name="custom-request-1-access">
  <DisplayName>custom-request-1-access</DisplayName>
  <AssignTo createNew="false" type="request"></AssignTo>
  <Set>
    <Headers>
      <Header name="user-agentCopyCustomRequest">{MyCustomRequest.header.user-agent}</Header>
    </Headers>
  </Set>
</AssignMessage>

סרטונים

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

וידאו תיאור
למה כדאי להקצות מדיניות הודעות? כאן מוסבר על היתרונות של שימוש במדיניות AssignMessage כדי לשנות את הבקשה או התשובה של ה-API בלי לשנות את הקוד לקצה העורפי.
העתקת רכיבי API באמצעות המדיניות AssignMessage העתקת רכיבים מבקשות או מתשובות של API ויצירת אובייקט בקשה או תגובה חדש באמצעות המדיניות AssignMessage.
הסרת רכיבי API באמצעות המדיניות AssignMessage הסרת רכיבי API ושינוי ה-API לפני שהוא מגיע לקצה העורפי של היעד באמצעות המדיניות AssignMessage.
הוספה והגדרה של רכיבי API באמצעות המדיניות AssignMessage שינוי הבקשה או התשובה של ה-API באמצעות הוספת פרמטרים של שאילתות, כותרות, פרמטרים של טפסים או עומסי נתונים (payloads) באמצעות המדיניות AssignMessage.
יצירת משתנים מותאמים אישית באמצעות המדיניות AssignMessage הגדרת משתני תהליך מותאמים אישית באמצעות המדיניות AssignMessage, ושימוש במשתנים במדיניות אחרת בשרת ה-proxy של ה-API.
יצירת אובייקטים חדשים של בקשות או תשובות באמצעות המדיניות AssignMessage יצירה של אובייקטים חדשים של בקשות או תגובות API באמצעות המדיניות AssignMessage בסביבת זמן הריצה של ה-API.
יצירת API מדומה באמצעות המדיניות AssignMessage כדי ליצור API ל-REST מדומה, מוסיפים את המדיניות AssignMessage בתהליך התגובה.
הגדרה או שינוי של עומס העבודה באמצעות מדיניות AssignMessage כדי להמיר בקשת REST לבקשת SOAP, מגדירים את SOAP Payload באמצעות מדיניות AssignMessage בזמן הריצה של ה-API.

קודי שגיאה

בקטע הזה מתוארים קודי השגיאה והודעות השגיאה שהוחזרו, ומשתני התקלה שמוגדרים על ידי Edge כשהמדיניות הזו גורמת לשגיאה. חשוב לדעת את המידע הזה אם אתם מפתחים כללי כשל כדי לטפל בתקלות. מידע נוסף זמין במאמר מה צריך לדעת? מידע על שגיאות שקשורות למדיניות וטיפול פגמים.

שגיאות זמן ריצה

השגיאות האלה עשויות להתרחש כשהמדיניות מופעלת.

קוד תקלה סטטוס HTTP סיבה תיקון
steps.assignmessage.SetVariableFailed 500 המדיניות לא הצליחה להגדיר משתנה. לראות את מחרוזת השגיאה של שם ה- משתנה שלא נפתר.
steps.assignmessage.VariableOfNonMsgType 500

השגיאה הזו מתקבלת אם המאפיין source ברכיב <Copy> מוגדר כמשתנה שאינו מסוג message.

משתנים של סוגי הודעות מייצגים את כל הבקשות והתשובות של HTTP. אפליקציית Edge המובנית משתני הזרימה request, response ו-message הם מסוג הודעה. מידע נוסף על משתני הודעות קראו את חומר העזר בנושא משתנים.
steps.assignmessage.UnresolvedVariable 500

השגיאה הזו מתקבלת אם המשתנה שצוין במדיניות 'הקצאת הודעה' הוא:

  • לא בהיקף (לא זמין בתהליך הספציפי שבו המדיניות מופעלת)
    • או
  • לא ניתן לפתרון (לא מוגדר)

שגיאות פריסה

השגיאות האלה עשויות להתרחש כאשר פורסים שרת proxy שמכיל את המדיניות הזו.

שם השגיאה סיבה תיקון
InvalidIndex אם האינדקס שצוין ברכיבים <Copy> ו/או <Remove> של הקצאת ההודעה היא 0 או מספר שלילי, אז הפריסה של שרת ה-proxy ל-API נכשלת.
InvalidVariableName אם רכיב הצאצא <Name> ריק או לא צוין ברכיב <AssignVariable>, הפריסה של שרת ה-proxy ל-API נכשלת כי אין שם משתנה חוקי שצריך להקצות לו ערך. צריך להזין שם משתנה חוקי.
InvalidPayload מטען ייעודי (payload) שצוין במדיניות אינו חוקי.

משתני כשל

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

משתנים איפה דוגמה
fault.name="fault_name" fault_name הוא שם השגיאה, כפי שמצוין בטבלה שגיאות זמן ריצה שלמעלה. שם השגיאה הוא החלק האחרון בקוד השגיאה. fault.name Matches "UnresolvedVariable"
assignmessage.policy_name.failed policy_name הוא השם שצוין על ידי המשתמש של המדיניות שגרמה לבעיה. assignmessage.AM-SetResponse.failed = true

דוגמה לתגובת שגיאה

{  
   "fault":{  
      "detail":{  
         "errorcode":"steps.assignmessage.VariableOfNonMsgType"
      },
      "faultstring":"AssignMessage[AM-SetResponse]: value of variable is not of type Message"
   }
}

דוגמה לכלל שגוי

<faultrule name="VariableOfNonMsgType"></faultrule><FaultRule name="Assign Message Faults">
    <Step>
        <Name>AM-CustomNonMessageTypeErrorResponse</Name>
        <Condition>(fault.name Matches "VariableOfNonMsgType") </Condition>
    </Step>
    <Step>
        <Name>AM-CustomSetVariableErrorResponse</Name>
        <Condition>(fault.name = "SetVariableFailed")</Condition>
    </Step>
    <Condition>(assignmessage.failed = true) </Condition>
</FaultRule>

סכימות

כל סוג מדיניות מוגדר על ידי סכימת XML (.xsd). לידיעתכם, סכמות המדיניות זמינות ב-GitHub.

נושאים קשורים

דוגמאות פעילות של מדיניות AssignMessage זמינות בדוגמאות של פלטפורמת ה-API.

דוגמה מתקדמת יותר לאופן שבו משנים את הערך של target.url מ-ProxyEndpoint מופיעה במאמר הזה בקהילה של Apigee.

כדי לראות את הפעולה של 'הגדרת נתיב' במדיניות ServiceCallout, אפשר לעיין בדוגמה הזו ללמידה מעשית בדוגמאות של Apigee ב-GitHub. פשוט משכפלים את המאגר ופועלים לפי ההוראות בנושא הזה. בדוגמה הזו נעשה שימוש במדיניות AssignMessage כדי להגדיר נתיב בקשה, ואז נעשה שימוש במדיניות Service Callout כדי לשלוח את הבקשה לשירות חיצוני.