webapis

Feb 26, 2025

Changes in this version

+ const OidcRestApiBaseUrl

Jan 23, 2025

Changes in this version

+ const Binding

+ const ControllerHealthCheck

+ const ControllerHealthCheckApiBaseUrlV1

+ const ControllerHealthCheckApiBinding

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

+ type ControllerHealthCheckApiFactory struct

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

+ func (factory ControllerHealthCheckApiFactory) Binding() string

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

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

+ type ControllerHealthCheckApiHandler struct

+ func NewControllerHealthCheckApiHandler(healthChecker gosundheit.Health, appEnv *env.AppEnv, ...) (*ControllerHealthCheckApiHandler, error)

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

+ func (self ControllerHealthCheckApiHandler) Binding() string

+ func (self ControllerHealthCheckApiHandler) IsDefault() bool

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

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

+ func (self ControllerHealthCheckApiHandler) RootPath() string

+ type GenericHttpHandler struct

+ BindingKey string

+ ContextRoot string

+ HttpHandler http.Handler

+ func (spa *GenericHttpHandler) Binding() string

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

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

+ func (spa *GenericHttpHandler) RootPath() string

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

+ type ZitiAdminConsoleFactory struct

+ func NewZitiAdminConsoleFactory() *ZitiAdminConsoleFactory

+ func (factory *ZitiAdminConsoleFactory) Binding() string

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

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

Sep 20, 2024

Changes in this version

type FabricManagementApiFactory

+ MakeDefault bool

type FabricManagementApiHandler

+ func (managementApi *FabricManagementApiHandler) IsDefault() bool

Aug 22, 2024

Changes in this version

+ const ClientApiBinding

+ const ClientRestApiBase

+ const ClientRestApiBaseUrlLatest

+ const ClientRestApiBaseUrlV1

+ const ClientRestApiSpecUrl

+ const LegacyClientApiBinding

+ const LegacyClientRestApiBaseUrlV1

+ const ManagementApiBinding

+ const ManagementRestApiBase

+ const ManagementRestApiBaseUrlLatest

+ const ManagementRestApiBaseUrlV1

+ const ManagementRestApiSpecUrl

+ const OidcApiBinding

+ const RestApiRootPath

+ const RestApiV1

+ const RootPath

+ const ServerHeader

+ const VersionPath

+ const VersionV1

+ const WellKnownEstCaCerts

+ const ZitiInstanceId

+ var AllApiBindingVersions = map[string]map[string]string

+ func NewFabricApiWrapper(ae *env.AppEnv) api_impl.RequestWrapper

+ func OverrideRequestWrapper(rw api_impl.RequestWrapper)

+ type ClientApiFactory struct

+ InitFunc func(clientApi *ClientApiHandler) error

+ func NewClientApiFactory(appEnv *env.AppEnv) *ClientApiFactory

+ func (factory ClientApiFactory) Binding() string

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

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

+ type ClientApiHandler struct

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

+ func (clientApi ClientApiHandler) Binding() string

+ func (clientApi ClientApiHandler) IsDefault() bool

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

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

+ func (clientApi ClientApiHandler) RootPath() string

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

+ type FabricManagementApiFactory struct

+ InitFunc func(managementApi *FabricManagementApiHandler) error

+ func NewFabricManagementApiFactory(nodeId identity.Identity, network *network.Network, ...) *FabricManagementApiFactory

+ func (factory *FabricManagementApiFactory) Binding() string

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

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

+ type FabricManagementApiHandler struct

+ func NewFabricManagementApiHandler(fabricApi *operations.ZitiFabricAPI, options map[interface{}]interface{}) (*FabricManagementApiHandler, error)

+ func (managementApi *FabricManagementApiHandler) Binding() string

+ func (managementApi *FabricManagementApiHandler) IsHandler(r *http.Request) bool

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

+ func (managementApi *FabricManagementApiHandler) RootPath() string

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

+ type FabricRequestWrapper struct

+ func (self *FabricRequestWrapper) WrapHttpHandler(handler http.Handler) http.Handler

+ func (self *FabricRequestWrapper) WrapRequest(handler api_impl.RequestHandler, request *http.Request, ...) openApiMiddleware.Responder

+ func (self *FabricRequestWrapper) WrapWsHandler(handler http.Handler) http.Handler

+ type ManagementApiFactory struct

+ InitFunc func(managementApi *ManagementApiHandler) error

+ func NewManagementApiFactory(appEnv *env.AppEnv) *ManagementApiFactory

+ func (factory ManagementApiFactory) Binding() string

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

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

+ type ManagementApiHandler struct

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

+ func (managementApi ManagementApiHandler) Binding() string

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

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

+ func (managementApi ManagementApiHandler) RootPath() string

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

+ type MetricsApiFactory struct

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

+ func (factory *MetricsApiFactory) Binding() string

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

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

+ type MetricsApiHandler struct

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

+ func (metricsApi *MetricsApiHandler) Binding() string

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

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

+ func (metricsApi *MetricsApiHandler) RootPath() string

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

+ type OidcApiFactory struct

+ InitFunc func(*OidcApiHandler) error

+ func NewOidcApiFactory(appEnv *env.AppEnv) *OidcApiFactory

+ func (factory OidcApiFactory) Binding() string

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

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

+ type OidcApiHandler struct

+ func NewOidcApiHandler(serverConfig *xweb.ServerConfig, ae *env.AppEnv, ...) (*OidcApiHandler, error)

+ func (h OidcApiHandler) Binding() string

+ func (h OidcApiHandler) IsDefault() bool

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

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

+ func (h OidcApiHandler) RootPath() string

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