webapis

package
v2.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 27, 2026 License: Apache-2.0 Imports: 43 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	WellKnownEstCaCerts = "/.well-known/est/cacerts"
	VersionPath         = "/version"
	RootPath            = "/"
)
View Source 
const (
	VersionV1 = "v1"

	RestApiV1 = "/" + VersionV1

	FabricRestApiRootPath = "/fabric"
	RestApiRootPath       = "/edge"
	ClientRestApiBase     = "/edge/client"
	ManagementRestApiBase = "/edge/management"
	ControllerHealthCheck = "/health-checks"

	LegacyClientRestApiBaseUrlV1      = RestApiRootPath + RestApiV1
	ClientRestApiBaseUrlV1            = ClientRestApiBase + RestApiV1
	ManagementRestApiBaseUrlV1        = ManagementRestApiBase + RestApiV1
	ControllerHealthCheckApiBaseUrlV1 = ControllerHealthCheck + RestApiV1
	OidcRestApiBaseUrl                = "/oidc"

	ClientRestApiBaseUrlLatest     = ClientRestApiBaseUrlV1
	ManagementRestApiBaseUrlLatest = ManagementRestApiBaseUrlV1

	ClientRestApiSpecUrl     = ClientRestApiBaseUrlLatest + "/swagger.json"
	ManagementRestApiSpecUrl = ManagementRestApiBaseUrlLatest + "/swagger.json"

	FabricRestApiBaseUrlV1 = FabricRestApiRootPath + RestApiV1

	MetricApiBinding                = "metrics"
	FabricApiBinding                = "fabric"
	LegacyClientApiBinding          = "edge"
	ClientApiBinding                = "edge-client"
	ManagementApiBinding            = "edge-management"
	OidcApiBinding                  = "edge-oidc"
	ControllerHealthCheckApiBinding = "health-checks"
)
View Source 
const LegacyZacBinding = "zac"

LegacyZacBinding is the historical binding name for the Ziti Admin Console SPA. It is kept as a back-compat shim so existing controller configs using `binding: zac` continue to load without modification. New configs should prefer `binding: spa` with an explicit `path`.

View Source 
const (
	SpaBinding = "spa"
)
View Source 
const ZitiInstanceId = "ziti-instance-id"

Variables

View Source 
var AllApiBindingVersions = map[string]map[string]string{
	FabricApiBinding: {
		VersionV1: FabricRestApiBaseUrlV1,
	},
	ClientApiBinding: {
		VersionV1: ClientRestApiBaseUrlV1,
	},
	ManagementApiBinding: {
		VersionV1: ManagementRestApiBaseUrlV1,
	},
	OidcApiBinding: {
		VersionV1: OidcRestApiBaseUrl,
	},
	ControllerHealthCheckApiBinding: {
		VersionV1: ControllerHealthCheckApiBaseUrlV1,
	},
}

AllApiBindingVersions is a map of: API Binding -> Api Version -> API Path Adding values here will add them to the /versions REST API endpoint

Functions

func SpaHandler 

func SpaHandler(location string, contextRoot string, indexFile string) http.Handler

SpaHandler returns a request handler (http.Handler) that serves a single page application from a given public directory (location).

Types

type ClientApiFactory 

type ClientApiFactory struct {
	InitFunc func(clientApi *ClientApiHandler) error
	// contains filtered or unexported fields
}

func NewClientApiFactory 

func NewClientApiFactory(appEnv *env.AppEnv) *ClientApiFactory

func (ClientApiFactory) Binding 

func (factory ClientApiFactory) Binding() string

func (ClientApiFactory) New 

func (factory ClientApiFactory) New(_ *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (ClientApiFactory) Validate 

func (factory ClientApiFactory) Validate(config *xweb.InstanceConfig) error

type ClientApiHandler 

type ClientApiHandler struct {
	// contains filtered or unexported fields
}

func NewClientApiHandler 

func NewClientApiHandler(ae *env.AppEnv, options map[interface{}]interface{}) (*ClientApiHandler, error)

func (ClientApiHandler) Binding 

func (clientApi ClientApiHandler) Binding() string

func (ClientApiHandler) IsDefault 

func (clientApi ClientApiHandler) IsDefault() bool

func (ClientApiHandler) IsHandler 

func (clientApi ClientApiHandler) IsHandler(r *http.Request) bool

func (ClientApiHandler) Options 

func (clientApi ClientApiHandler) Options() map[interface{}]interface{}

func (ClientApiHandler) RootPath 

func (clientApi ClientApiHandler) RootPath() string

func (ClientApiHandler) ServeHTTP 

func (clientApi ClientApiHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

type ControllerHealthCheckApiFactory 

type ControllerHealthCheckApiFactory struct {
	// contains filtered or unexported fields
}

func NewControllerHealthCheckApiFactory 

func NewControllerHealthCheckApiFactory(appEnv *env.AppEnv, healthChecker gosundheit.Health) *ControllerHealthCheckApiFactory

func (ControllerHealthCheckApiFactory) Binding 

func (factory ControllerHealthCheckApiFactory) Binding() string

func (ControllerHealthCheckApiFactory) New 

func (factory ControllerHealthCheckApiFactory) New(_ *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (ControllerHealthCheckApiFactory) Validate 

func (factory ControllerHealthCheckApiFactory) Validate(config *xweb.InstanceConfig) error

type ControllerHealthCheckApiHandler 

type ControllerHealthCheckApiHandler struct {
	// contains filtered or unexported fields
}

func NewControllerHealthCheckApiHandler 

func NewControllerHealthCheckApiHandler(healthChecker gosundheit.Health, appEnv *env.AppEnv, options map[interface{}]interface{}) (*ControllerHealthCheckApiHandler, error)

func (ControllerHealthCheckApiHandler) Binding 

func (self ControllerHealthCheckApiHandler) Binding() string

func (ControllerHealthCheckApiHandler) IsDefault 

func (self ControllerHealthCheckApiHandler) IsDefault() bool

func (ControllerHealthCheckApiHandler) IsHandler 

func (self ControllerHealthCheckApiHandler) IsHandler(r *http.Request) bool

func (ControllerHealthCheckApiHandler) Options 

func (self ControllerHealthCheckApiHandler) Options() map[interface{}]interface{}

func (ControllerHealthCheckApiHandler) RootPath 

func (self ControllerHealthCheckApiHandler) RootPath() string

func (*ControllerHealthCheckApiHandler) ServeHTTP 

func (self *ControllerHealthCheckApiHandler) ServeHTTP(w http.ResponseWriter, request *http.Request)

type FabricManagementApiFactory 

type FabricManagementApiFactory struct {
	InitFunc func(managementApi *FabricManagementApiHandler) error

	MakeDefault bool
	// contains filtered or unexported fields
}

func NewFabricManagementApiFactory 

func NewFabricManagementApiFactory(nodeId identity.Identity, env *env.AppEnv, network *network.Network, xmgmts *concurrenz.CopyOnWriteSlice[xmgmt.Xmgmt]) *FabricManagementApiFactory

func (*FabricManagementApiFactory) Binding 

func (factory *FabricManagementApiFactory) Binding() string

func (*FabricManagementApiFactory) New 

func (factory *FabricManagementApiFactory) New(_ *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (*FabricManagementApiFactory) Validate 

func (factory *FabricManagementApiFactory) Validate(_ *xweb.InstanceConfig) error

type FabricManagementApiHandler 

type FabricManagementApiHandler struct {
	// contains filtered or unexported fields
}

func NewFabricManagementApiHandler 

func NewFabricManagementApiHandler(ae *env.AppEnv, isDefault bool, options map[interface{}]interface{}) (*FabricManagementApiHandler, error)

func (*FabricManagementApiHandler) Binding 

func (self *FabricManagementApiHandler) Binding() string

func (*FabricManagementApiHandler) IsDefault 

func (self *FabricManagementApiHandler) IsDefault() bool

func (*FabricManagementApiHandler) IsHandler 

func (self *FabricManagementApiHandler) IsHandler(r *http.Request) bool

func (*FabricManagementApiHandler) Options 

func (self *FabricManagementApiHandler) Options() map[interface{}]interface{}

func (*FabricManagementApiHandler) RootPath 

func (self *FabricManagementApiHandler) RootPath() string

func (*FabricManagementApiHandler) ServeHTTP 

func (self *FabricManagementApiHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

func (*FabricManagementApiHandler) WrapHttpHandler 

func (self *FabricManagementApiHandler) WrapHttpHandler(handler http.Handler) http.Handler

func (*FabricManagementApiHandler) WrapWsHandler 

func (self *FabricManagementApiHandler) WrapWsHandler(handler http.Handler) http.Handler

type GenericHttpHandler 

type GenericHttpHandler struct {
	HttpHandler http.Handler
	BindingKey  string
	ContextRoot string
	// ExtraPrefixes lets a SPA claim additional URL prefixes outside its context root.
	// Used by the legacy ZAC handler to keep matching absolute "/assets" URLs from bundles
	// that weren't built with a base href.
	ExtraPrefixes []string
}

func (*GenericHttpHandler) Binding 

func (spa *GenericHttpHandler) Binding() string

func (*GenericHttpHandler) IsHandler 

func (spa *GenericHttpHandler) IsHandler(r *http.Request) bool

func (*GenericHttpHandler) Options 

func (spa *GenericHttpHandler) Options() map[interface{}]interface{}

func (*GenericHttpHandler) RootPath 

func (spa *GenericHttpHandler) RootPath() string

func (*GenericHttpHandler) ServeHTTP 

func (spa *GenericHttpHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

type ManagementApiFactory 

type ManagementApiFactory struct {
	InitFunc func(managementApi *ManagementApiHandler) error
	// contains filtered or unexported fields
}

func NewManagementApiFactory 

func NewManagementApiFactory(appEnv *env.AppEnv) *ManagementApiFactory

func (ManagementApiFactory) Binding 

func (factory ManagementApiFactory) Binding() string

func (ManagementApiFactory) New 

func (factory ManagementApiFactory) New(_ *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (ManagementApiFactory) Validate 

func (factory ManagementApiFactory) Validate(_ *xweb.InstanceConfig) error

type ManagementApiHandler 

type ManagementApiHandler struct {
	// contains filtered or unexported fields
}

func NewManagementApiHandler 

func NewManagementApiHandler(ae *env.AppEnv, options map[interface{}]interface{}) (*ManagementApiHandler, error)

func (ManagementApiHandler) Binding 

func (managementApi ManagementApiHandler) Binding() string

func (ManagementApiHandler) IsHandler 

func (managementApi ManagementApiHandler) IsHandler(r *http.Request) bool

func (ManagementApiHandler) Options 

func (managementApi ManagementApiHandler) Options() map[interface{}]interface{}

func (ManagementApiHandler) RootPath 

func (managementApi ManagementApiHandler) RootPath() string

func (ManagementApiHandler) ServeHTTP 

func (managementApi ManagementApiHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

type MetricsApiFactory 

type MetricsApiFactory struct {
	// contains filtered or unexported fields
}

func NewMetricsApiFactory 

func NewMetricsApiFactory(nodeId identity.Identity, network *network.Network) *MetricsApiFactory

func (*MetricsApiFactory) Binding 

func (factory *MetricsApiFactory) Binding() string

func (*MetricsApiFactory) New 

func (factory *MetricsApiFactory) New(_ *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (*MetricsApiFactory) Validate 

func (factory *MetricsApiFactory) Validate(_ *xweb.InstanceConfig) error

type MetricsApiHandler 

type MetricsApiHandler struct {
	// contains filtered or unexported fields
}

func NewMetricsApiHandler 

func NewMetricsApiHandler(n *network.Network, options map[interface{}]interface{}) (*MetricsApiHandler, error)

func (*MetricsApiHandler) Binding 

func (metricsApi *MetricsApiHandler) Binding() string

func (*MetricsApiHandler) IsHandler 

func (metricsApi *MetricsApiHandler) IsHandler(r *http.Request) bool

func (*MetricsApiHandler) Options 

func (metricsApi *MetricsApiHandler) Options() map[interface{}]interface{}

func (*MetricsApiHandler) RootPath 

func (metricsApi *MetricsApiHandler) RootPath() string

func (*MetricsApiHandler) ServeHTTP 

func (metricsApi *MetricsApiHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

type MetricsModelMapper 

type MetricsModelMapper interface {
	MapInspectResultToMetricsResult(inspectResult *network.InspectResult) (*string, error)
	MapInspectResultValueToMetricsResult(inspectResultValue *network.InspectResultValue) (any, error)
}

func NewMetricsModelMapper 

func NewMetricsModelMapper(n *network.Network, format string, includeTimestamps bool) MetricsModelMapper

type OidcApiFactory 

type OidcApiFactory struct {
	InitFunc func(*OidcApiHandler) error
	// contains filtered or unexported fields
}

func NewOidcApiFactory 

func NewOidcApiFactory(appEnv *env.AppEnv) *OidcApiFactory

func (OidcApiFactory) Binding 

func (factory OidcApiFactory) Binding() string

func (OidcApiFactory) New 

func (factory OidcApiFactory) New(serverConfig *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (OidcApiFactory) Validate 

func (factory OidcApiFactory) Validate(config *xweb.InstanceConfig) error

type OidcApiHandler 

type OidcApiHandler struct {
	// contains filtered or unexported fields
}

func NewOidcApiHandler 

func NewOidcApiHandler(serverConfig *xweb.ServerConfig, ae *env.AppEnv, options map[interface{}]interface{}) (*OidcApiHandler, error)

func (OidcApiHandler) Binding 

func (h OidcApiHandler) Binding() string

func (OidcApiHandler) IsDefault 

func (h OidcApiHandler) IsDefault() bool

func (OidcApiHandler) IsHandler 

func (h OidcApiHandler) IsHandler(r *http.Request) bool

func (OidcApiHandler) Options 

func (h OidcApiHandler) Options() map[interface{}]interface{}

func (OidcApiHandler) RootPath 

func (h OidcApiHandler) RootPath() string

func (OidcApiHandler) ServeHTTP 

func (h OidcApiHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request)

type SpaFactory 

type SpaFactory struct {
}

func NewSpaFactory 

func NewSpaFactory() *SpaFactory

func (*SpaFactory) Binding 

func (factory *SpaFactory) Binding() string

func (*SpaFactory) New 

func (factory *SpaFactory) New(_ *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (*SpaFactory) Validate 

func (factory *SpaFactory) Validate(*xweb.InstanceConfig) error

type ZitiAdminConsoleFactory 

type ZitiAdminConsoleFactory struct {
	// contains filtered or unexported fields
}

func NewZitiAdminConsoleFactory 

func NewZitiAdminConsoleFactory() *ZitiAdminConsoleFactory

func (*ZitiAdminConsoleFactory) Binding 

func (factory *ZitiAdminConsoleFactory) Binding() string

func (*ZitiAdminConsoleFactory) New 

func (factory *ZitiAdminConsoleFactory) New(serverConfig *xweb.ServerConfig, options map[interface{}]interface{}) (xweb.ApiHandler, error)

func (*ZitiAdminConsoleFactory) Validate 

func (factory *ZitiAdminConsoleFactory) Validate(c *xweb.InstanceConfig) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.