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} {
        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} {
        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} {
        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} {
        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} {
        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