Struct OpenWhiskPlugin 

pub struct OpenWhiskPlugin {
    api_host: Template,
    authorization: String,
    namespace: Template,
    package: Option<Template>,
    action: Template,
    result: bool,
    ssl_verify: bool,
    timeout: Duration,
    timeout_ms: u64,
    client: Arc<OutboundClient>,
}

Invokes an OpenWhisk action and maps its reply into Context.response.

Fields

api_host: Template

Supports {{namespace.path}} references — resolved per request when building the endpoint URL. No legacy $var interpolation (endpoint fields never supported it, so this sweep must not start).

Warning: unlike namespace/package/action, the rendered value is spliced into the URL unencoded (it’s the origin + scheme, not a path segment — percent-encoding would corrupt it). Templating this field from request-controlled data lets a client redirect the entire outbound call to an arbitrary host (SSRF); prefer a static value or one derived only from {{env.*}}.

authorization: String

Pre-computed Basic <base64(service_token)> header value. Never templated — a credential, not an endpoint field.

namespace: Template

Supports {{namespace.path}} references, same as api_host. Unlike api_host, the rendered value is percent-encoded (encode_path_segment) before insertion into the URL path — safe to template from request data.

package: Option<Template>

Supports {{namespace.path}} references, same as namespace (percent-encoded at render time).

action: Template

Supports {{namespace.path}} references, same as namespace (percent-encoded at render time).

result: bool

ssl_verify: bool

timeout: Duration

timeout_ms: u64

timeout in milliseconds, passed through as the action query param.

client: Arc<OutboundClient>

Implementations

impl OpenWhiskPlugin

pub fn from_config( config: &HashMap<String, Value>, resources: &Arc<PluginResources>, ) -> Result<Self, String>

Builds the plugin from node config.

Accepted keys:

• api_host (string, required): the OpenWhisk API host (e.g. https://ow.example.com). Missing/empty is a config error. Supports {{namespace.path}} references, rendered per request when building the endpoint URL (a trailing / is trimmed after render).
• service_token (string, required): user:pass action token, sent base64-encoded as HTTP Basic auth. Missing/empty is a config error. Never templated — a credential, not an endpoint field.
• action (string, required): the action name to invoke; supports {{namespace.path}} references.
• namespace (string, default _): the OpenWhisk namespace; supports {{namespace.path}} references.
• package (string, optional): the package the action belongs to; supports {{namespace.path}} references.
• result (bool, default true): request result=true (inline the action result rather than the full activation record).
• ssl_verify (bool, default true): verify TLS certificates.
• timeout (integer ms, default 3000): whole-call deadline, also passed as the action timeout query parameter.

type: openwhisk
config:
  api_host: https://ow.example.com
  service_token: ${OPENWHISK_TOKEN}
  namespace: guest
  action: hello
  result: true
  ssl_verify: true
  timeout: 3000

fn endpoint(&self, ctx: &Context) -> String

Builds the OpenWhisk action-invocation URL, rendering api_host / namespace / package / action against ctx so each field’s {{namespace.path}} references resolve per request.

namespace/package/action are percent-encoded (encode_path_segment) after rendering: since these fields are templatable from request data (e.g. a header), an unescaped / or ? in the rendered value would otherwise break out of its path segment or inject extra query parameters ahead of the plugin’s own blocking/result/timeout. api_host is deliberately not encoded — see the warning on its field doc.

fn build_request(&self, ctx: &Context) -> OutboundRequest

Builds the outbound POST request carrying the client body as the action parameters.

Trait Implementations

impl Plugin for OpenWhiskPlugin

fn plugin_type(&self) -> &str

Unique identifier for the plugin type (e.g., “proxy-rewrite”, “upstream”). This is also the key its PortSpec is registered under in port_spec.

fn execute<'life0, 'async_trait>( &'life0 self, ctx: Context, ) -> Pin<Box<dyn Future<Output = Result<PluginOutput, PluginExecutionError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes the plugin logic against the request/response context.

fn reads_response_body(&self) -> bool

Whether this configured instance reads context.response.body.

fn cache_target(&self) -> Option<CacheTarget>

The cache backend this node writes to, if it is a proxy-cache half.