Class ::nsmcp::RequestRoutingTool (public)

 ::nx::Class ::nsmcp::RequestRoutingTool

Defined in /usr/local/ns/tcl/nsmcp/traffic-tools.tcl

Testcases:

No testcase defined.

Source code:

    :property {name server_request_routing}
    :property {permission diagnostics.runtime.read}
    :property {description {Inspect effective connection-pool mappings and registered filters for the authenticated server. Runtime ns_server data, not configuration guesses. Filter registrations include authentication, request processing and other purposes; names do not establish behavior. Does not execute filters or read implementation files.}}
    :property redactor:required

    :public method snapshot {server} {
        #
        # Capture configured request-pool and filter routing information.
        #
        # Record unavailable runtime observations explicitly instead of inferring
        # missing routes.
        #
        # @param server Selected NaviServer virtual-server name.
        #
        # @return The routing snapshot dictionary with pools, filters and
        #         availability metadata.
        #

        set pools {}
        set filters {}
        set errors {}
        if {[catch {
            ns_server -server $server pools
        } names]} {
            dict set errors pools unavailable
        } else {
            foreach pool $names {
                if {[catch {
                    ns_server -server $server -pool $pool map
                } maps]} {
                    dict set errors $pool unavailable
                } else {
                    dict set pools [expr {$pool eq "" ? "default" : $pool}] $maps
                }
            }
        }
        if {[catch {
            ns_server -server $server filters
        } filters]} {
            set filters {}
            dict set errors filters unavailable
        }
        return [dict create pools $pools filters $filters availability $errors]
    }

    # Probe the operation, not a NaviServer version string. This also supports
    # installations that backport -context independently of a release number.
    :public method contextSupported {server} {
        #
        # Probe whether native routing supports a request-context ns_set.
        #
        # Use a temporary context and release it even when the capability probe
        # fails.
        #
        # @param server Selected NaviServer virtual-server name.
        #
        # @return True when contextual routing lookup is supported, otherwise false.
        #

        set context [ns_set create]
        try {
            return [expr {![catch {
                ns_server -server $server mapped -context $context {GET /}
            }]}]
        } finally {
            ns_set free $context
        }
    }

    :public method mapped {server record} {
        #
        # Resolve one request against native pool mapping.
        #
        # Populate a temporary request context from available record fields, perform
        # the lookup and release the ns_set.
        #
        # @param server Selected NaviServer virtual-server name.
        # @param record Recorded request fields or routing-evidence dictionary.
        #
        # @return The native mapping result for the request.
        #

        set context [ns_set create]
        try {
            if {[dict exists $record userAgent]} {
                ns_set put $context user-agent [dict get $record userAgent]
            }
            set peer [dict get $record peerAddress]
            if {[ns_ip valid $peer]} {
                ns_set put $context x-ns-ip $peer
            }
            set pool [ns_server -server $server mapped -context $context  [list [dict get $record method] [dict get $record path]]]
            return [expr {$pool eq "" ? "default" : $pool}]
        } finally {
            ns_set free $context
        }
    }

    :public method encodeSnapshot {snapshot} {
        #
        # Encode a routing snapshot as typed JSON fields.
        #
        # Retain route order and availability metadata while converting Tcl
        # containers to arrays and objects.
        #
        # @param snapshot Routing snapshot with availability metadata.
        #
        # @return The field triples for the encoded routing snapshot.
        #

        set pools {}
        dict for {pool maps} [dict get $snapshot pools] {
            set rows {}
            set i 0
            foreach row $maps {
                lappend rows $i string [${:redactor} message $row]
                incr i
            }
            lappend pools $pool array $rows
        }
        set filters {}
        set i 0
        foreach row [dict get $snapshot filters] {
            lappend filters $i string [${:redactor} message $row]
            incr i
        }
        set errors {}
        dict for {key value} [dict get $snapshot availability] {
            lappend errors $key string $value
        }
        return [list mappings object $pools filters array $filters availability object $errors]
    }

    :public method execute {context arguments} {
        #
        # Describe the selected server's request-routing configuration.
        #
        # Capture pool/filter maps and whether native contextual lookup is
        # supported.
        #
        # @param context Authenticated request context carrying the principal,
        #        grants and selected server.
        # @param arguments Rooted ns_json typed triples for the tool's JSON argument
        #        object.
        #
        # @return A rooted JSON tool-result object, including availability or job
        #         metadata as appropriate.
        #

        set server [$context server]
        return [list {} object [list server string $server observedAt number [clock seconds]  source string ns_server nativeContextLookup boolean [:contextSupported $server] {*}[:encodeSnapshot [:snapshot $server]]]]
    }

XQL Not present:

Generic, PostgreSQL, Oracle