Questa pagina è stata tradotta dall'API Cloud Translation.

Risoluzione dei problemi relativi agli errori di deployment del criterio di protezione delle espressioni regolari

Stai visualizzando la documentazione di Apigee e Apigee hybrid.
Visualizza la documentazione di Apigee Edge.

InvalidRegularExpression

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Invalid Regular Expression com.apigee.steps.regexprotection.RegularExpressionProtectionBean$RegexPattern@f4ecb23, Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Esempio di messaggio di errore

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Invalid Regular Expression com.apigee.steps.regexprotection.RegularExpressionProtectionBean$RegexPattern@f4ecb23, Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di esempio dell'errore

InvalidRegularExpression error text

Causa

Se l'espressione regolare nell'elemento <Pattern> del criterio RegularExpressionProtection non è valida, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection dal messaggio di errore. Ad esempio, nel seguente errore, il nome della policy RegularExpressionProtection è Regular-Expression-Protection-1:

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Invalid Regular Expression com.apigee.steps.regexprotection.RegularExpressionProtectionBean$RegexPattern@f4ecb23, Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Esamina tutti gli elementi <Pattern> nel file XML del criterio di protezione delle espressioni regolari non riuscito. Controlla se uno degli elementi <Pattern> contiene un'espressione regolare non valida. Se uno degli elementi <Pattern> contiene un'espressione regolare non valida, questo è il motivo dell'errore.

Ad esempio, i seguenti criteri specificano il valore di Pattern> di foo){2}, che è considerato un'espressione regolare non valida:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <URIPath>
            <Pattern>foo){2}</Pattern>
        </URIPath>
        <Source>request</Source>
    </RegularExpressionProtection>
```
Nell'esempio riportato sopra, l'espressione regolare specificata in <Pattern> non ha una parentesi di apertura. Pertanto, è considerata un'espressione regolare non valida. Pertanto, il deployment del proxy API non riesce.

Risoluzione

Assicurati che ogni elemento <Pattern> nel criterio RegularExpressionProtection contenga un'espressione regolare valida. Puoi cercare diversi strumenti regex online o offline per eseguire il debug delle espressioni regolari. Per correggere la policy di protezione delle espressioni regolari di esempio mostrata sopra, aggiungi le parentesi mancanti:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <URIPath>
            <Pattern>(foo){2}</Pattern>
        </URIPath>
        <Source>request</Source>
    </RegularExpressionProtection>

XPathCompilationFailed

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Failed to compile xpath xpath_expression. Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Esempio di messaggio di errore

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile xpath /notapigee:foo/notapigee:bar. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di esempio dell'errore

Testo dell'errore XPathCompilationFailed

Causa

Se il prefisso o il valore utilizzato nell'elemento <XPath> non fa parte di nessuno degli spazi dei nomi dichiarati nel criterio RegularExpressionProtection, il deployment del proxy API non va a buon fine.

Puoi trovare maggiori informazioni su spazi dei nomi, XPath e prefisso in XML Namespaces and How They Affect XPath and XSLT.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore e l'espressione XPath utilizzata. Puoi trovare entrambi gli elementi nel messaggio di errore.

Ad esempio, nel seguente errore , il nome della policy è Regular-Expression-Protection-1 e l'espressione XPath è /notapigee:foo/notapigee:bar:
```
Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile xpath /notapigee:foo/notapigee:bar. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.
```

Nel codice XML della policy di protezione delle espressioni regolari non riuscita, verifica che l'XPath impostato nell'elemento Expression corrisponda all'XPath identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, la seguente policy specifica XPath come /notapigee:foo/notapigee:bar, che corrisponde a quanto riportato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
     <XMLPayload>
         <Namespaces>
             <Namespace prefix="apigee">http://www.apigee.com</Namespace>
         </Namespaces>
         <XPath>
             <Expression>/notapigee:foo/notapigee:bar</Expression>
             <Type>nodeset</Type>
             <Pattern>pattern</Pattern>
             <Pattern>pattern2</Pattern>
         </XPath>
     </XMLPayload>
</RegularExpressionProtection>

Esamina gli elementi <Namespaces> e <Expression> nel criterio RegularExpressionProtection. Se lo specifico <Expression> indicato nel messaggio di errore utilizza un prefisso o un valore che non fa parte degli spazi dei nomi dichiarati nel criterio RegularExpressionProtection, questo è il motivo dell'errore.
Tieni presente che <XPath> specifico utilizza il prefisso notapigee nell'esempio di criterio RegularExpressionProtection:
```
<Expression>/notapigee:foo/notapigee:bar</Expression>
```
Tuttavia, il prefisso notapigee non è definito in nessuno degli elementi <Namespace>, pertanto la compilazione di <XPath> non va a buon fine e il deployment non viene eseguito.

Risoluzione

Assicurati che tutti gli spazi dei nomi utilizzati negli elementi <Expression> negli elementi <XPath> siano dichiarati nel criterio RegularExpressionProtection. Per correggere l'esempio precedente, puoi sostituire il prefisso notapigee con apigee, dichiarato negli spazi dei nomi:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
     <XMLPayload>
         <Namespaces>
             <Namespace prefix="apigee">http://www.apigee.com</Namespace>
         </Namespaces>
         <XPath>
             <Expression>/apigee:foo/apigee:bar</Expression>
             <Type>nodeset</Type>
             <Pattern>pattern</Pattern>
             <Pattern>pattern2</Pattern>
         </XPath>
     </XMLPayload>
</RegularExpressionProtection>

CannotBeConvertedToNodeset

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Result of xpath xpath_expression cannot be converted to nodeset. Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Esempio di messaggio di errore

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Result of xpath count(//apigee:foo) cannot be converted to nodeset. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di esempio dell'errore

CannotBeConvertedToNodeset error text

Causa

Se il criterio Espressione regolare ha un'espressione <XPath> in cui l'elemento <Type> è definito come nodeset, ma l'espressione non può essere convertita in nodeset, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il criterio RegularExpressionProtection in cui si è verificato l'errore e l'espressione XPath che non può essere convertita in un insieme di nodi. Puoi trovare entrambi gli elementi nel messaggio di errore.

Ad esempio, nel seguente errore , il nome della policy è Regular-Expression-Protection-1 e l'espressione XPath è count(//apigee:foo):
```
Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Result of xpath count(//apigee:foo) cannot be converted to nodeset. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.
```

Nel file XML della policy di protezione delle espressioni regolari non riuscita, verifica che l'XPath impostato nell'elemento <Expression> dell'elemento <XPath> corrisponda all'XPath identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, la seguente policy specifica count(//apigee:foo), che corrisponde a quanto riportato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <Source>request</Source>
         <XMLPayload>
             <Namespaces>
                 <Namespace prefix="apigee">http://www.apigee.com</Namespace>
             </Namespaces>
             <XPath>
                 <Expression>count(//apigee:foo)</Expression>
                 <Type>nodeset</Type>
                 <Pattern>pattern</Pattern>
                 <Pattern>pattern2</Pattern>
             </XPath>
         </XMLPayload>
    </RegularExpressionProtection>

Esamina il valore impostato nell'elemento <Type> sotto l'elemento <XPath>. Se l'elemento <Type> è nodeset, questo è il motivo dell'errore.

In questo esempio, l'espressione XPath è count(), che non restituisce uno o più nodi. Pertanto, il deployment del proxy API non riesce.

Risoluzione

Se l'elemento <Type> è impostato su nodeset, assicurati che il risultato dell'elemento <Expression> impostato in <XPath> sia uno o più nodi. In alternativa, modifica l'elemento <Type> con un valore più appropriato in base al tuo caso d'uso.

Per correggere l'esempio precedente, puoi modificare l'elemento <Expression> con un valore diverso che può restituire nodi:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
     <XMLPayload>
         <Namespaces>
             <Namespace prefix="apigee">http://www.apigee.com</Namespace>
         </Namespaces>
         <XPath>
             <Expression>/apigee:foo/apigee:bar</Expression>
             <Type>nodeset</Type>
             <Pattern>pattern</Pattern>
             <Pattern>pattern2</Pattern>
         </XPath>
     </XMLPayload>
</RegularExpressionProtection>

JSONPathCompilationFailed

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Failed to compile jsonpath jsonpath_expression Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Esempio di messaggio di errore

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile jsonpath $.store.book[*.author. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di esempio dell'errore

Testo dell'errore JSONPathCompilationFailed

Causa

Se l'elemento <Expression> nell'elemento <JSONPath> di una policy di protezione delle espressioni regolari è impostato su un'espressione JSONPath non valida, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore ed è stata utilizzata l'espressione JSONPath non valida. Puoi trovare entrambi gli elementi nel messaggio di errore.

Ad esempio, nel seguente errore , il nome della norma è Regular-Expression-Protection-1 e l'espressione JSONPath è $.store.book[*.author:
```
Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile jsonpath $.store.book[*.author. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.
```

Nel file XML della policy di protezione delle espressioni regolari non riuscita, verifica che il JSONPath impostato nell'elemento Expression corrisponda al JSONPath identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, la seguente policy specifica l'elemento Expression nell'elemento <JSONPath> come $.store.book[*.author, che corrisponde a quanto riportato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <Source>request</Source>
        <JSONPayload>
             <JSONPath>
                 <Expression>$.store.book[*.author</Expression>
                 <Pattern>REGEX PATTERN</Pattern>
                 <Pattern>REGEX PATTERN</Pattern>
             </JSONPath>
            </JSONPayload>
    </RegularExpressionProtection>

Esamina l'elemento <Expression> all'interno dell'elemento <JSONPath> nelle norme. Se non corrisponde alla sintassi JSONPath, questo è il motivo dell'errore. Nell'esempio precedente, manca la parentesi quadra chiusa, il che rende l'espressione non valida.

Poiché l'espressione JSON Path non è valida, il deployment del proxy API non va a buon fine.

Risoluzione

Assicurati che il valore dell'elemento <Expression> all'interno dell'elemento <JSONPath> nel criterio di protezione delle espressioni regolari sia un'espressione JSONPath valida.

Per correggere l'esempio mostrato sopra, potresti aggiungere la parentesi quadra chiusa mancante al valore dell'elemento <Expression>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
    <JSONPayload>
         <JSONPath>
             <Expression>$.store.book[*].author</Expression>
             <Pattern>REGEX PATTERN</Pattern>
             <Pattern>REGEX PATTERN</Pattern>
         </JSONPath>
        </JSONPayload>
</RegularExpressionProtection>

NothingToEnforce

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory.

Esempio di messaggio di errore

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory.

Screenshot di esempio dell'errore

Testo dell'errore NothingToEnforce

Causa

Se il criterio RegularExpressionProtection non contiene gli elementi <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>, il deployment del proxy API non va a buon fine.

Come indicato nel messaggio di errore, il criterio RegularExpressionProtection deve includere almeno uno di questi elementi: <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore. Puoi trovarlo nel messaggio di errore. Ad esempio, nel seguente errore , il nome della policy è Regular-Expression-Protection-1:
```
RegularExpressionProtection Regular-Expression-Protection-1: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory.
```
Esamina il criterio di protezione delle espressioni regolari non riuscito (identificato nel passaggio 1 riportato sopra). Se i criteri non includono nemmeno uno dei seguenti elementi: <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>, questa è la causa dell'errore.

Ad esempio, la seguente norma di protezione delle espressioni regolari non contiene nessuno degli elementi menzionati sopra:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <Source>request</Source>
    </RegularExpressionProtection>
```
Poiché nessuno degli elementi obbligatori è presente nella policy Estrai variabili, il deployment del proxy API non va a buon fine.

Risoluzione

Assicurati che i criteri RegularExpressionProtection includano almeno uno di questi elementi obbligatori: <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
    <JSONPayload>
        <JSONPath>
            <Expression>$.store.book[*].author</Expression>
            <Pattern>REGEX PATTERN</Pattern>
            <Pattern>REGEX PATTERN</Pattern>
        </JSONPath>
    </JSONPayload>
</RegularExpressionProtection>

NoPatternsToEnforce

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: No patterns to enforce in payload_name.

Esempio di messaggio di errore

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: No patterns to enforce in XPath.

Screenshot di esempio dell'errore

Testo dell'errore NoPatternsToEnforce

Causa

Se uno degli elementi di primo livello (<URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>) non ha l'elemento <Pattern> definito nelle norme RegularExpressionProtection, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore e l'elemento secondario che non ha l'elemento <Pattern>. Puoi trovare entrambi gli elementi nel messaggio di errore.

Ad esempio, nel seguente errore, il nome della policy è Regular-Expression-Protection-1 e l'elemento secondario è XPath:
```
RegularExpressionProtection Regular-Expression-Protection-1: No patterns to enforce in XPath.
```

Esamina il criterio di protezione delle espressioni regolari non riuscito e verifica se l'elemento secondario identificato nel passaggio 1 non ha l'elemento <Pattern>. Se l'elemento <Pattern> non è presente, questo è il motivo dell'errore.

Ad esempio, la seguente policy non ha l'elemento <Pattern> all'interno di <XPath>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

Poiché l'elemento <XPath> non ha l'elemento <Pattern>, il deployment del proxy API non va a buon fine.

Risoluzione

Assicurati che almeno uno degli elementi <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload> abbia specificato almeno un <Pattern>. Per informazioni su come specificare correttamente l'elemento, consulta le norme RegularExpressionProtection.

Per correggere l'esempio precedente, potremmo semplicemente aggiungere l'elemento <Pattern> all'elemento <XPath> sotto <XMLPayload>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression>/apigee:Greeting/apigee:User</Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

NONEmptyPrefixMappedToEmptyURI

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Non-empty prefix prefix_name cannot be mapped to empty uri.

Esempio di messaggio di errore

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Non-empty prefix apigee cannot be mapped to empty uri.

Screenshot di esempio dell'errore

Testo dell'errore NONEmptyPrefixMappedToEmptyURI

Causa

Questo errore si verifica se il criterio RegularExpressionProtection ha un prefisso definito nell'elemento <Namespace> sotto l'elemento <XMLPayload>, ma non è definito alcun URI.

Diagnosi

Identifica il criterio RegularExpressionProtection in cui si è verificato l'errore e il nome del prefisso non mappato all'URI. Puoi trovare entrambi gli elementi nel messaggio di errore.

Ad esempio, nel seguente errore, il nome della policy è Regular Expression Protection-1 e il prefisso è apigee:
```
RegularExpressionProtection Regular-Expression-Protection-1: Non-empty prefix apigee cannot be mapped to empty uri.
```

Nel file XML della policy di protezione delle espressioni regolari non riuscita, verifica che il nome del prefisso impostato nell'elemento <Namespace> sotto l'elemento <XMLPayload> corrisponda al nome del prefisso identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, la seguente policy specifica un prefisso denominato apigee nell'elemento <Namespace> , che corrisponde a quello del messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee"/>
          <Namespace prefix="gmail">http://mail.google.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
          <Pattern>REGEX PATTERN</Pattern>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

Verifica se l'elemento <Namespace> con il prefisso specifico identificato nel passaggio 2 ha un URI valido. Se l'URI non è presente, questo è il motivo dell'errore.

Nell'esempio di policy di protezione delle espressioni regolari mostrato sopra, nota che non esiste alcun URI corrispondente all'elemento <Namespace> con il prefisso apigee; pertanto, viene visualizzato l'errore:
```
Non-empty prefix apigee cannot be mapped to empty uri.
```

Risoluzione

Assicurati che tutti gli elementi <Namespace> definiti con un prefisso abbiano un URI corrispondente nella policy Estrai variabili. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
      <Namespace prefix="gmail">http://mail.google.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression>/apigee:Greeting/apigee:User</Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

DuplicatePrefix

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Duplicate prefix prefix_name.

Esempio di messaggio di errore

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Duplicate prefix apigee.

Screenshot di esempio dell'errore

DuplicatePrefix error text

Causa

Questo errore si verifica se il criterio RegularExpressionProtection ha lo stesso prefisso definito più di una volta nell'elemento <Namespace> sotto l'elemento <XMLPayload>.

Ad esempio, questo errore si verifica perché il prefisso apigee è definito due volte, come mostrato di seguito:

<Namespace prefix="apigee">http://www.apigee.com</Namespace>
<Namespace prefix="apigee">http://www.apigee.com</Namespace>

Diagnosi

Identifica il RegularExpressionProtection policy in cui si è verificato l'errore e il nome del prefisso. Puoi trovare entrambi gli elementi nel messaggio di errore.

Ad esempio, nel seguente errore, il nome della policy è Regular Expression Protection-1 e il prefisso è apigee:
```
RegularExpressionProtection Regular-Expression-Protection-1: Duplicate prefix apigee.
```

Ad esempio, la seguente policy specifica un prefisso denominato apigee nell'elemento <Namespace> , che corrisponde a quanto riportato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
          <Pattern>REGEX PATTERN</Pattern>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

Determina se l'elemento <Namespace> con il prefisso specifico, identificato nel passaggio 2, è stato definito più di una volta. Se è definito più di una volta, questa è la causa dell'errore.

Nell'esempio di policy di protezione delle espressioni regolari mostrato sopra, nota che l'elemento <Namespace> con il prefisso apigee è stato definito due volte, pertanto viene visualizzato l'errore:
```
Duplicate prefix apigee.
```

Risoluzione

Assicurati che ci sia una sola definizione per ogni prefisso negli elementi <Namespace> nel criterio RegularExpressionProtection. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
          <Pattern>REGEX PATTERN</Pattern>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

EmptyXPathExpression

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Empty XPath expression.

Esempio di messaggio di errore

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Empty XPath expression.

Screenshot di esempio dell'errore

EmptyXPathExpression error text

Causa

Se il criterio RegularExpressionProtection non ha alcun elemento <Expression> impostato all'interno dell'elemento <XPath>, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il criterio di protezione delle espressioni regolari non riuscito dal messaggio di errore. Ad esempio, nel seguente errore, il nome della policy è Regular-Expression-Protection-1:
```
RegularExpressionProtection Regular-Expression-Protection-1: Empty XPath expression.
```

Nel file XML del criterio di protezione delle espressioni regolari non riuscito, determina se è presente un elemento <XMLPayload> con un elemento secondario <XPath> che non ha alcun elemento <Expression> definito o se l'elemento <Expression> non è impostato su alcun valore. In questo caso, la causa dell'errore è proprio questa.

Ad esempio, ecco un criterio di protezione delle espressioni regolari che include un elemento <XMLPayload>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression></Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

Poiché è presente un elemento <Expression> vuoto all'interno dell'elemento <XPath>, il deployment del proxy API non riesce.

Risoluzione

Assicurati che il criterio RegularExpressionProtection abbia un elemento <Expression> non vuoto e valido definito nell'elemento <XPath>. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression>/apigee:Greeting/apigee:User</Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

EmptyJSONPathExpression

Messaggio di errore

Il deployment del proxy API tramite l'API o la UI Apigee non riesce e viene visualizzato questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Empty JSONPath expression.

Esempio di messaggio di errore

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Empty JSONPath expression.

Screenshot di esempio dell'errore

EmptyJSONPathExpression error text

Causa

Se il criterio RegularExpressionProtection non ha alcun elemento <Expression> impostato all'interno dell'elemento <JSONPath>, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il criterio di protezione delle espressioni regolari non riuscito dal messaggio di errore. Ad esempio, nel seguente errore, il nome della policy è Regular-Expression-Protection-1:
```
Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Empty JSONPath expression.
```

Nel file XML dei criteri di protezione delle espressioni regolari non riuscita, determina se è presente un elemento <JSONPayload> con un elemento secondario <JSONPath> che non ha alcun elemento <Expression> definito o se l'elemento <Expression> non è impostato su alcun valore. In questo caso, la causa dell'errore è proprio questa.

Ad esempio, ecco un criterio di protezione delle espressioni regolari che include un elemento <JSONPayload>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <JSONPayload>
        <JSONPath>
          <Expression></Expression>
          <Pattern>REGEX PATTERN</Pattern>
          <Pattern>REGEX PATTERN</Pattern>
        </JSONPath>
      </JSONPayload>
    </RegularExpressionProtection>

Poiché è presente un elemento <Expression> vuoto all'interno dell'elemento <JSONPath>, il deployment del proxy API non riesce.

Risoluzione

Assicurati che il criterio RegularExpressionProtection abbia un elemento <Expression> non vuoto e valido definito nell'elemento <JSONPath>. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <JSONPayload>
    <JSONPath>
      <Expression>$.store.book[*].author</Expression>
      <Pattern>REGEX PATTERN</Pattern>
      <Pattern>REGEX PATTERN</Pattern>
    </JSONPath>
  </JSONPayload>
</RegularExpressionProtection>

Risoluzione dei problemi relativi agli errori di deployment del criterio di protezione delle espressioni regolari Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

InvalidRegularExpression

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

XPathCompilationFailed

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

CannotBeConvertedToNodeset

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

JSONPathCompilationFailed

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

NothingToEnforce

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

NoPatternsToEnforce

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

NONEmptyPrefixMappedToEmptyURI

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

DuplicatePrefix

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

EmptyXPathExpression

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

EmptyJSONPathExpression

Messaggio di errore

Esempio di messaggio di errore

Screenshot di esempio dell'errore

Causa

Diagnosi

Risoluzione

Risoluzione dei problemi relativi agli errori di deployment del criterio di protezione delle espressioni regolari