Skip to content
2023 API Summit Hackathon: Experiment with AI for APIs (August 28 - September 27) Learn More →
Kong Logo | Kong Docs Logo
search
  • We're Hiring!
  • Docs
    • Kong Gateway
      Lightweight, fast, and flexible cloud-native API gateway
      Kong Konnect
      Single platform for SaaS end-to-end connectivity
      Kong Mesh
      Enterprise service mesh based on Kuma and Envoy
      decK
      Helps manage Kong’s configuration in a declarative fashion
      Kong Ingress Controller
      Works inside a Kubernetes cluster and configures Kong to proxy traffic
      Kong Gateway Operator
      Manage your Kong deployments on Kubernetes using YAML Manifests
      Insomnia
      Collaborative API development platform
      Kuma
      Open-source distributed control plane with a bundled Envoy Proxy integration
  • API Specs
  • Plugin Hub
    • Explore the Plugin Hub
      View all plugins View all plugins View all plugins arrow image
    • Functionality View all View all arrow image
      View all plugins
      Authentication's icon
      Authentication
      Protect your services with an authentication layer
      Security's icon
      Security
      Protect your services with additional security layer
      Traffic Control's icon
      Traffic Control
      Manage, throttle and restrict inbound and outbound API traffic
      Serverless's icon
      Serverless
      Invoke serverless functions in combination with other plugins
      Analytics & Monitoring's icon
      Analytics & Monitoring
      Visualize, inspect and monitor APIs and microservices traffic
      Transformations's icon
      Transformations
      Transform request and responses on the fly on Kong
      Logging's icon
      Logging
      Log request and response data using the best transport for your infrastructure
  • Support
  • Community
  • Kong Academy
Get a Demo Start Free Trial
Kong Gateway
3.1.x
  • Home icon
  • Kong Gateway
  • Plugin Development
  • PDK
  • kong.websocket.upstream
github-edit-pageEdit this page
report-issueReport an issue
  • Kong Gateway
  • Kong Konnect
  • Kong Mesh
  • Plugin Hub
  • decK
  • Kong Ingress Controller
  • Kong Gateway Operator
  • Insomnia
  • Kuma

  • Docs contribution guidelines
  • 3.4.x (latest)
  • 3.3.x
  • 3.2.x
  • 3.1.x
  • 3.0.x
  • 2.8.x
  • 2.7.x
  • 2.6.x
  • Archive (pre-2.6)
enterprise-switcher-icon Switch to OSS
On this pageOn this page
  • kong.websocket.upstream.get_frame()
  • kong.websocket.upstream.set_frame_data(data)
  • kong.websocket.upstream.set_status(status)
  • kong.websocket.upstream.drop_frame()
  • kong.websocket.upstream.close([status[, message[, client_status[, client_payload]]]])
  • kong.set_max_payload_size
You are browsing documentation for an outdated version. See the latest documentation here.

kong.websocket.upstream

Upstream WebSocket PDK functions.

Warning: The WebSocket PDK is under active development and is considered unstable at this time. Backwards-incompatible changes may be made to these functions.

kong.websocket.upstream.get_frame()

Retrieve the current frame.

This returns the payload, type, and status code (for close frames) of the in-flight frame/message.

This function is useful in contexts like the pre-function or post-function plugins where execution is sandboxed, and the caller has no access to these variables in the plugin handler scope.

Phases

  • ws_upstream_frame

Returns

  • string: The frame payload.

  • string: The frame type (one of “text”, “binary”, “ping”, “pong”, or “close”)

  • number: The frame status code (only returned for close frames)

Usage

local data, typ, status = kong.websocket.upstream.get_frame()

kong.websocket.upstream.set_frame_data(data)

Set the current frame’s payload.

This allows the caller to overwrite the contents of the in-flight WebSocket frame before it is forwarded to the client.

Plugin handlers that execute after this has been called will see the updated version of the frame.

Phases

  • ws_upstream_frame

Parameters

  • data (string): The desired frame payload

Usage

kong.websocket.upstream.set_frame_data("updated!")

kong.websocket.upstream.set_status(status)

Set the status code for a close frame.

This allows the caller to overwrite the status code of close frame before it is forwarded to the client.

See the WebSocket RFC for a list of valid status codes.

Plugin handlers that execute after this has been called will see the updated version of the status code.

Calling this function when the in-flight frame is not a close frame will result in an exception.

Parameters

  • status (number): The desired status code

Usage

-- overwrite the payload and status before forwarding
local data, typ, status = kong.websocket.upstream.get_frame()
if typ == "close" then
  kong.websocket.upstream.set_frame_data("goodbye!")
  kong.websocket.upstream.set_status(1000)
end

kong.websocket.upstream.drop_frame()

Drop the current frame.

This causes the in-flight frame to be dropped, meaning it will not be forwarded to the client.

Plugin handlers that are set to execute after this one will be skipped.

Close frames cannot be dropped. Calling this function for a close frame will result in an exception.

Usage

kong.websocket.upstream.drop_frame()

kong.websocket.upstream.close([status[, message[, client_status[, client_payload]]]])

Close the WebSocket connection.

Calling this function immediately sends a close frame to the client and the upstream before terminating the connection.

The in-flight frame will not be forwarded to the client, and plugin handlers that are set to execute after the current one will not be executed.

Parameters

  • status (number, optional): Status code of the upstream close frame
  • message (string, optional): Payload of the upstream close frame
  • client_status (number, optional): Status code of the client close frame
  • client_payload (string, optional): Payload of the client close frame

Usage

kong.websocket.upstream.close(1009, "Invalid message",
                              1001, "Upstream is going away")

kong.set_max_payload_size

Set the maximum allowed payload size for upstream frames.

This limit is applied to all data frame types:

  • text
  • binary
  • continuation

The limit is also assessed during aggregation of frames. For example, if the limit is 1024, and a upstream sends 3 continuation frames of size 500 each, the third frame will exceed the limit.

If a upstream sends a message that exceeds the limit, a close frame with status code 1009 is sent to the upstream, and the connection is closed.

This limit does not apply to control frames (close/ping/pong).

  • size (integer): The limit (0 resets to the default limit)

Usage

-- set a max payload size of 1KB
kong.websocket.upstream.set_max_payload_size(1024)
-- Restore the default limit
kong.websocket.upstream.set_max_payload_size(0)
Thank you for your feedback.
Was this page useful?
Too much on your plate? close cta icon
More features, less infrastructure with Kong Konnect. 1M requests per month for free.
Try it for Free
  • Kong
    THE CLOUD CONNECTIVITY COMPANY

    Kong powers reliable digital connections across APIs, hybrid and multi-cloud environments.

    • Company
    • Customers
    • Events
    • Investors
    • Careers Hiring!
    • Partners
    • Press
    • Contact
  • Products
    • Kong Konnect
    • Kong Gateway
    • Kong Mesh
    • Get Started
    • Pricing
  • Resources
    • eBooks
    • Webinars
    • Briefs
    • Blog
    • API Gateway
    • Microservices
  • Open Source
    • Install Kong Gateway
    • Kong Community
    • Kubernetes Ingress
    • Kuma
    • Insomnia
  • Solutions
    • Decentralize
    • Secure & Govern
    • Create a Dev Platform
    • API Gateway
    • Kubernetes
    • Service Mesh
Star
  • Terms•Privacy
© Kong Inc. 2023