From 386c41f41a8c6dfb78b6fdc2ca53f1a0991c2c25 Mon Sep 17 00:00:00 2001 From: Michael Quigley Date: Thu, 1 Sep 2022 17:39:02 -0400 Subject: [PATCH] /disable endpoint in openapi definition (#30) --- .../identity/create_account_parameters.go | 8 +- .../identity/create_account_responses.go | 99 ++++++++- .../identity/disable_parameters.go | 150 +++++++++++++ .../identity/disable_responses.go | 210 ++++++++++++++++++ .../identity/enable_parameters.go | 8 +- rest_client_zrok/identity/enable_responses.go | 130 ++++++++++- rest_client_zrok/identity/identity_client.go | 47 +++- rest_client_zrok/identity/login_parameters.go | 8 +- rest_client_zrok/identity/login_responses.go | 65 +++++- rest_client_zrok/metadata/metadata_client.go | 4 +- .../metadata/overview_parameters.go | 8 +- .../metadata/overview_responses.go | 66 +++++- .../metadata/version_parameters.go | 8 +- .../metadata/version_responses.go | 33 ++- rest_client_zrok/tunnel/tunnel_client.go | 4 +- rest_client_zrok/tunnel/tunnel_parameters.go | 8 +- rest_client_zrok/tunnel/tunnel_responses.go | 99 ++++++++- .../tunnel/untunnel_parameters.go | 8 +- rest_client_zrok/tunnel/untunnel_responses.go | 98 +++++++- rest_client_zrok/zrok_client.go | 2 +- rest_model_zrok/disable_request.go | 50 +++++ rest_server_zrok/doc.go | 20 +- rest_server_zrok/embedded_spec.go | 88 ++++++++ .../operations/identity/create_account.go | 6 +- .../identity/create_account_parameters.go | 3 +- .../identity/create_account_responses.go | 9 +- .../operations/identity/disable.go | 71 ++++++ .../operations/identity/disable_parameters.go | 76 +++++++ .../operations/identity/disable_responses.go | 107 +++++++++ .../operations/identity/disable_urlbuilder.go | 87 ++++++++ .../operations/identity/enable.go | 6 +- .../operations/identity/enable_parameters.go | 3 +- .../operations/identity/enable_responses.go | 12 +- rest_server_zrok/operations/identity/login.go | 6 +- .../operations/identity/login_parameters.go | 3 +- .../operations/identity/login_responses.go | 6 +- .../operations/metadata/overview.go | 6 +- .../operations/metadata/overview_responses.go | 6 +- .../operations/metadata/version.go | 6 +- .../operations/metadata/version_responses.go | 3 +- rest_server_zrok/operations/tunnel/tunnel.go | 6 +- .../operations/tunnel/tunnel_parameters.go | 3 +- .../operations/tunnel/tunnel_responses.go | 9 +- .../operations/tunnel/untunnel.go | 6 +- .../operations/tunnel/untunnel_parameters.go | 3 +- .../operations/tunnel/untunnel_responses.go | 9 +- rest_server_zrok/operations/zrok_api.go | 12 + rest_server_zrok/server.go | 19 +- specs/zrok.yml | 28 +++ ui/src/api/identity.js | 26 +++ ui/src/api/types.js | 7 + 51 files changed, 1649 insertions(+), 116 deletions(-) create mode 100644 rest_client_zrok/identity/disable_parameters.go create mode 100644 rest_client_zrok/identity/disable_responses.go create mode 100644 rest_model_zrok/disable_request.go create mode 100644 rest_server_zrok/operations/identity/disable.go create mode 100644 rest_server_zrok/operations/identity/disable_parameters.go create mode 100644 rest_server_zrok/operations/identity/disable_responses.go create mode 100644 rest_server_zrok/operations/identity/disable_urlbuilder.go diff --git a/rest_client_zrok/identity/create_account_parameters.go b/rest_client_zrok/identity/create_account_parameters.go index 55751309..61d3e63e 100644 --- a/rest_client_zrok/identity/create_account_parameters.go +++ b/rest_client_zrok/identity/create_account_parameters.go @@ -54,10 +54,12 @@ func NewCreateAccountParamsWithHTTPClient(client *http.Client) *CreateAccountPar } } -/* CreateAccountParams contains all the parameters to send to the API endpoint - for the create account operation. +/* +CreateAccountParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the create account operation. + + Typically these are written to a http.Request. */ type CreateAccountParams struct { diff --git a/rest_client_zrok/identity/create_account_responses.go b/rest_client_zrok/identity/create_account_responses.go index 80766ed2..6dbd59cf 100644 --- a/rest_client_zrok/identity/create_account_responses.go +++ b/rest_client_zrok/identity/create_account_responses.go @@ -51,7 +51,8 @@ func NewCreateAccountCreated() *CreateAccountCreated { return &CreateAccountCreated{} } -/* CreateAccountCreated describes a response with status code 201, with default header values. +/* +CreateAccountCreated describes a response with status code 201, with default header values. account created */ @@ -59,9 +60,39 @@ type CreateAccountCreated struct { Payload *rest_model_zrok.AccountResponse } +// IsSuccess returns true when this create account created response has a 2xx status code +func (o *CreateAccountCreated) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this create account created response has a 3xx status code +func (o *CreateAccountCreated) IsRedirect() bool { + return false +} + +// IsClientError returns true when this create account created response has a 4xx status code +func (o *CreateAccountCreated) IsClientError() bool { + return false +} + +// IsServerError returns true when this create account created response has a 5xx status code +func (o *CreateAccountCreated) IsServerError() bool { + return false +} + +// IsCode returns true when this create account created response a status code equal to that given +func (o *CreateAccountCreated) IsCode(code int) bool { + return code == 201 +} + func (o *CreateAccountCreated) Error() string { return fmt.Sprintf("[POST /account][%d] createAccountCreated %+v", 201, o.Payload) } + +func (o *CreateAccountCreated) String() string { + return fmt.Sprintf("[POST /account][%d] createAccountCreated %+v", 201, o.Payload) +} + func (o *CreateAccountCreated) GetPayload() *rest_model_zrok.AccountResponse { return o.Payload } @@ -83,7 +114,8 @@ func NewCreateAccountBadRequest() *CreateAccountBadRequest { return &CreateAccountBadRequest{} } -/* CreateAccountBadRequest describes a response with status code 400, with default header values. +/* +CreateAccountBadRequest describes a response with status code 400, with default header values. account not created (already exists) */ @@ -91,9 +123,39 @@ type CreateAccountBadRequest struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this create account bad request response has a 2xx status code +func (o *CreateAccountBadRequest) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this create account bad request response has a 3xx status code +func (o *CreateAccountBadRequest) IsRedirect() bool { + return false +} + +// IsClientError returns true when this create account bad request response has a 4xx status code +func (o *CreateAccountBadRequest) IsClientError() bool { + return true +} + +// IsServerError returns true when this create account bad request response has a 5xx status code +func (o *CreateAccountBadRequest) IsServerError() bool { + return false +} + +// IsCode returns true when this create account bad request response a status code equal to that given +func (o *CreateAccountBadRequest) IsCode(code int) bool { + return code == 400 +} + func (o *CreateAccountBadRequest) Error() string { return fmt.Sprintf("[POST /account][%d] createAccountBadRequest %+v", 400, o.Payload) } + +func (o *CreateAccountBadRequest) String() string { + return fmt.Sprintf("[POST /account][%d] createAccountBadRequest %+v", 400, o.Payload) +} + func (o *CreateAccountBadRequest) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } @@ -113,7 +175,8 @@ func NewCreateAccountInternalServerError() *CreateAccountInternalServerError { return &CreateAccountInternalServerError{} } -/* CreateAccountInternalServerError describes a response with status code 500, with default header values. +/* +CreateAccountInternalServerError describes a response with status code 500, with default header values. internal server error */ @@ -121,9 +184,39 @@ type CreateAccountInternalServerError struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this create account internal server error response has a 2xx status code +func (o *CreateAccountInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this create account internal server error response has a 3xx status code +func (o *CreateAccountInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this create account internal server error response has a 4xx status code +func (o *CreateAccountInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this create account internal server error response has a 5xx status code +func (o *CreateAccountInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this create account internal server error response a status code equal to that given +func (o *CreateAccountInternalServerError) IsCode(code int) bool { + return code == 500 +} + func (o *CreateAccountInternalServerError) Error() string { return fmt.Sprintf("[POST /account][%d] createAccountInternalServerError %+v", 500, o.Payload) } + +func (o *CreateAccountInternalServerError) String() string { + return fmt.Sprintf("[POST /account][%d] createAccountInternalServerError %+v", 500, o.Payload) +} + func (o *CreateAccountInternalServerError) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } diff --git a/rest_client_zrok/identity/disable_parameters.go b/rest_client_zrok/identity/disable_parameters.go new file mode 100644 index 00000000..be942d00 --- /dev/null +++ b/rest_client_zrok/identity/disable_parameters.go @@ -0,0 +1,150 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package identity + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + "net/http" + "time" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + cr "github.com/go-openapi/runtime/client" + "github.com/go-openapi/strfmt" + + "github.com/openziti-test-kitchen/zrok/rest_model_zrok" +) + +// NewDisableParams creates a new DisableParams object, +// with the default timeout for this client. +// +// Default values are not hydrated, since defaults are normally applied by the API server side. +// +// To enforce default values in parameter, use SetDefaults or WithDefaults. +func NewDisableParams() *DisableParams { + return &DisableParams{ + timeout: cr.DefaultTimeout, + } +} + +// NewDisableParamsWithTimeout creates a new DisableParams object +// with the ability to set a timeout on a request. +func NewDisableParamsWithTimeout(timeout time.Duration) *DisableParams { + return &DisableParams{ + timeout: timeout, + } +} + +// NewDisableParamsWithContext creates a new DisableParams object +// with the ability to set a context for a request. +func NewDisableParamsWithContext(ctx context.Context) *DisableParams { + return &DisableParams{ + Context: ctx, + } +} + +// NewDisableParamsWithHTTPClient creates a new DisableParams object +// with the ability to set a custom HTTPClient for a request. +func NewDisableParamsWithHTTPClient(client *http.Client) *DisableParams { + return &DisableParams{ + HTTPClient: client, + } +} + +/* +DisableParams contains all the parameters to send to the API endpoint + + for the disable operation. + + Typically these are written to a http.Request. +*/ +type DisableParams struct { + + // Body. + Body *rest_model_zrok.DisableRequest + + timeout time.Duration + Context context.Context + HTTPClient *http.Client +} + +// WithDefaults hydrates default values in the disable params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *DisableParams) WithDefaults() *DisableParams { + o.SetDefaults() + return o +} + +// SetDefaults hydrates default values in the disable params (not the query body). +// +// All values with no default are reset to their zero value. +func (o *DisableParams) SetDefaults() { + // no default values defined for this parameter +} + +// WithTimeout adds the timeout to the disable params +func (o *DisableParams) WithTimeout(timeout time.Duration) *DisableParams { + o.SetTimeout(timeout) + return o +} + +// SetTimeout adds the timeout to the disable params +func (o *DisableParams) SetTimeout(timeout time.Duration) { + o.timeout = timeout +} + +// WithContext adds the context to the disable params +func (o *DisableParams) WithContext(ctx context.Context) *DisableParams { + o.SetContext(ctx) + return o +} + +// SetContext adds the context to the disable params +func (o *DisableParams) SetContext(ctx context.Context) { + o.Context = ctx +} + +// WithHTTPClient adds the HTTPClient to the disable params +func (o *DisableParams) WithHTTPClient(client *http.Client) *DisableParams { + o.SetHTTPClient(client) + return o +} + +// SetHTTPClient adds the HTTPClient to the disable params +func (o *DisableParams) SetHTTPClient(client *http.Client) { + o.HTTPClient = client +} + +// WithBody adds the body to the disable params +func (o *DisableParams) WithBody(body *rest_model_zrok.DisableRequest) *DisableParams { + o.SetBody(body) + return o +} + +// SetBody adds the body to the disable params +func (o *DisableParams) SetBody(body *rest_model_zrok.DisableRequest) { + o.Body = body +} + +// WriteToRequest writes these params to a swagger request +func (o *DisableParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { + + if err := r.SetTimeout(o.timeout); err != nil { + return err + } + var res []error + if o.Body != nil { + if err := r.SetBodyParam(o.Body); err != nil { + return err + } + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/rest_client_zrok/identity/disable_responses.go b/rest_client_zrok/identity/disable_responses.go new file mode 100644 index 00000000..cbcb7d06 --- /dev/null +++ b/rest_client_zrok/identity/disable_responses.go @@ -0,0 +1,210 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package identity + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "fmt" + "io" + + "github.com/go-openapi/runtime" + "github.com/go-openapi/strfmt" + + "github.com/openziti-test-kitchen/zrok/rest_model_zrok" +) + +// DisableReader is a Reader for the Disable structure. +type DisableReader struct { + formats strfmt.Registry +} + +// ReadResponse reads a server response into the received o. +func (o *DisableReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { + switch response.Code() { + case 200: + result := NewDisableOK() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return result, nil + case 401: + result := NewDisableUnauthorized() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + case 500: + result := NewDisableInternalServerError() + if err := result.readResponse(response, consumer, o.formats); err != nil { + return nil, err + } + return nil, result + default: + return nil, runtime.NewAPIError("response status code does not match any response statuses defined for this endpoint in the swagger spec", response, response.Code()) + } +} + +// NewDisableOK creates a DisableOK with default headers values +func NewDisableOK() *DisableOK { + return &DisableOK{} +} + +/* +DisableOK describes a response with status code 200, with default header values. + +environment disabled +*/ +type DisableOK struct { +} + +// IsSuccess returns true when this disable o k response has a 2xx status code +func (o *DisableOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this disable o k response has a 3xx status code +func (o *DisableOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this disable o k response has a 4xx status code +func (o *DisableOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this disable o k response has a 5xx status code +func (o *DisableOK) IsServerError() bool { + return false +} + +// IsCode returns true when this disable o k response a status code equal to that given +func (o *DisableOK) IsCode(code int) bool { + return code == 200 +} + +func (o *DisableOK) Error() string { + return fmt.Sprintf("[POST /disable][%d] disableOK ", 200) +} + +func (o *DisableOK) String() string { + return fmt.Sprintf("[POST /disable][%d] disableOK ", 200) +} + +func (o *DisableOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} + +// NewDisableUnauthorized creates a DisableUnauthorized with default headers values +func NewDisableUnauthorized() *DisableUnauthorized { + return &DisableUnauthorized{} +} + +/* +DisableUnauthorized describes a response with status code 401, with default header values. + +invalid environment +*/ +type DisableUnauthorized struct { +} + +// IsSuccess returns true when this disable unauthorized response has a 2xx status code +func (o *DisableUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this disable unauthorized response has a 3xx status code +func (o *DisableUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this disable unauthorized response has a 4xx status code +func (o *DisableUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this disable unauthorized response has a 5xx status code +func (o *DisableUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this disable unauthorized response a status code equal to that given +func (o *DisableUnauthorized) IsCode(code int) bool { + return code == 401 +} + +func (o *DisableUnauthorized) Error() string { + return fmt.Sprintf("[POST /disable][%d] disableUnauthorized ", 401) +} + +func (o *DisableUnauthorized) String() string { + return fmt.Sprintf("[POST /disable][%d] disableUnauthorized ", 401) +} + +func (o *DisableUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + return nil +} + +// NewDisableInternalServerError creates a DisableInternalServerError with default headers values +func NewDisableInternalServerError() *DisableInternalServerError { + return &DisableInternalServerError{} +} + +/* +DisableInternalServerError describes a response with status code 500, with default header values. + +internal server error +*/ +type DisableInternalServerError struct { + Payload rest_model_zrok.ErrorMessage +} + +// IsSuccess returns true when this disable internal server error response has a 2xx status code +func (o *DisableInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this disable internal server error response has a 3xx status code +func (o *DisableInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this disable internal server error response has a 4xx status code +func (o *DisableInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this disable internal server error response has a 5xx status code +func (o *DisableInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this disable internal server error response a status code equal to that given +func (o *DisableInternalServerError) IsCode(code int) bool { + return code == 500 +} + +func (o *DisableInternalServerError) Error() string { + return fmt.Sprintf("[POST /disable][%d] disableInternalServerError %+v", 500, o.Payload) +} + +func (o *DisableInternalServerError) String() string { + return fmt.Sprintf("[POST /disable][%d] disableInternalServerError %+v", 500, o.Payload) +} + +func (o *DisableInternalServerError) GetPayload() rest_model_zrok.ErrorMessage { + return o.Payload +} + +func (o *DisableInternalServerError) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { + + // response payload + if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { + return err + } + + return nil +} diff --git a/rest_client_zrok/identity/enable_parameters.go b/rest_client_zrok/identity/enable_parameters.go index a44f9b83..f7a87a3c 100644 --- a/rest_client_zrok/identity/enable_parameters.go +++ b/rest_client_zrok/identity/enable_parameters.go @@ -54,10 +54,12 @@ func NewEnableParamsWithHTTPClient(client *http.Client) *EnableParams { } } -/* EnableParams contains all the parameters to send to the API endpoint - for the enable operation. +/* +EnableParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the enable operation. + + Typically these are written to a http.Request. */ type EnableParams struct { diff --git a/rest_client_zrok/identity/enable_responses.go b/rest_client_zrok/identity/enable_responses.go index 9577ac04..3a9338a4 100644 --- a/rest_client_zrok/identity/enable_responses.go +++ b/rest_client_zrok/identity/enable_responses.go @@ -57,7 +57,8 @@ func NewEnableCreated() *EnableCreated { return &EnableCreated{} } -/* EnableCreated describes a response with status code 201, with default header values. +/* +EnableCreated describes a response with status code 201, with default header values. environment enabled */ @@ -65,9 +66,39 @@ type EnableCreated struct { Payload *rest_model_zrok.EnableResponse } +// IsSuccess returns true when this enable created response has a 2xx status code +func (o *EnableCreated) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this enable created response has a 3xx status code +func (o *EnableCreated) IsRedirect() bool { + return false +} + +// IsClientError returns true when this enable created response has a 4xx status code +func (o *EnableCreated) IsClientError() bool { + return false +} + +// IsServerError returns true when this enable created response has a 5xx status code +func (o *EnableCreated) IsServerError() bool { + return false +} + +// IsCode returns true when this enable created response a status code equal to that given +func (o *EnableCreated) IsCode(code int) bool { + return code == 201 +} + func (o *EnableCreated) Error() string { return fmt.Sprintf("[POST /enable][%d] enableCreated %+v", 201, o.Payload) } + +func (o *EnableCreated) String() string { + return fmt.Sprintf("[POST /enable][%d] enableCreated %+v", 201, o.Payload) +} + func (o *EnableCreated) GetPayload() *rest_model_zrok.EnableResponse { return o.Payload } @@ -89,17 +120,47 @@ func NewEnableUnauthorized() *EnableUnauthorized { return &EnableUnauthorized{} } -/* EnableUnauthorized describes a response with status code 401, with default header values. +/* +EnableUnauthorized describes a response with status code 401, with default header values. invalid api key */ type EnableUnauthorized struct { } +// IsSuccess returns true when this enable unauthorized response has a 2xx status code +func (o *EnableUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this enable unauthorized response has a 3xx status code +func (o *EnableUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this enable unauthorized response has a 4xx status code +func (o *EnableUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this enable unauthorized response has a 5xx status code +func (o *EnableUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this enable unauthorized response a status code equal to that given +func (o *EnableUnauthorized) IsCode(code int) bool { + return code == 401 +} + func (o *EnableUnauthorized) Error() string { return fmt.Sprintf("[POST /enable][%d] enableUnauthorized ", 401) } +func (o *EnableUnauthorized) String() string { + return fmt.Sprintf("[POST /enable][%d] enableUnauthorized ", 401) +} + func (o *EnableUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { return nil @@ -110,17 +171,47 @@ func NewEnableNotFound() *EnableNotFound { return &EnableNotFound{} } -/* EnableNotFound describes a response with status code 404, with default header values. +/* +EnableNotFound describes a response with status code 404, with default header values. account not found */ type EnableNotFound struct { } +// IsSuccess returns true when this enable not found response has a 2xx status code +func (o *EnableNotFound) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this enable not found response has a 3xx status code +func (o *EnableNotFound) IsRedirect() bool { + return false +} + +// IsClientError returns true when this enable not found response has a 4xx status code +func (o *EnableNotFound) IsClientError() bool { + return true +} + +// IsServerError returns true when this enable not found response has a 5xx status code +func (o *EnableNotFound) IsServerError() bool { + return false +} + +// IsCode returns true when this enable not found response a status code equal to that given +func (o *EnableNotFound) IsCode(code int) bool { + return code == 404 +} + func (o *EnableNotFound) Error() string { return fmt.Sprintf("[POST /enable][%d] enableNotFound ", 404) } +func (o *EnableNotFound) String() string { + return fmt.Sprintf("[POST /enable][%d] enableNotFound ", 404) +} + func (o *EnableNotFound) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { return nil @@ -131,7 +222,8 @@ func NewEnableInternalServerError() *EnableInternalServerError { return &EnableInternalServerError{} } -/* EnableInternalServerError describes a response with status code 500, with default header values. +/* +EnableInternalServerError describes a response with status code 500, with default header values. internal server error */ @@ -139,9 +231,39 @@ type EnableInternalServerError struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this enable internal server error response has a 2xx status code +func (o *EnableInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this enable internal server error response has a 3xx status code +func (o *EnableInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this enable internal server error response has a 4xx status code +func (o *EnableInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this enable internal server error response has a 5xx status code +func (o *EnableInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this enable internal server error response a status code equal to that given +func (o *EnableInternalServerError) IsCode(code int) bool { + return code == 500 +} + func (o *EnableInternalServerError) Error() string { return fmt.Sprintf("[POST /enable][%d] enableInternalServerError %+v", 500, o.Payload) } + +func (o *EnableInternalServerError) String() string { + return fmt.Sprintf("[POST /enable][%d] enableInternalServerError %+v", 500, o.Payload) +} + func (o *EnableInternalServerError) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } diff --git a/rest_client_zrok/identity/identity_client.go b/rest_client_zrok/identity/identity_client.go index 941fbeeb..3a83ff5a 100644 --- a/rest_client_zrok/identity/identity_client.go +++ b/rest_client_zrok/identity/identity_client.go @@ -32,6 +32,8 @@ type ClientOption func(*runtime.ClientOperation) type ClientService interface { CreateAccount(params *CreateAccountParams, opts ...ClientOption) (*CreateAccountCreated, error) + Disable(params *DisableParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DisableOK, error) + Enable(params *EnableParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*EnableCreated, error) Login(params *LoginParams, opts ...ClientOption) (*LoginOK, error) @@ -40,7 +42,7 @@ type ClientService interface { } /* - CreateAccount create account API +CreateAccount create account API */ func (a *Client) CreateAccount(params *CreateAccountParams, opts ...ClientOption) (*CreateAccountCreated, error) { // TODO: Validate the params before sending @@ -78,7 +80,46 @@ func (a *Client) CreateAccount(params *CreateAccountParams, opts ...ClientOption } /* - Enable enable API +Disable disable API +*/ +func (a *Client) Disable(params *DisableParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DisableOK, error) { + // TODO: Validate the params before sending + if params == nil { + params = NewDisableParams() + } + op := &runtime.ClientOperation{ + ID: "disable", + Method: "POST", + PathPattern: "/disable", + ProducesMediaTypes: []string{"application/zrok.v1+json"}, + ConsumesMediaTypes: []string{"application/zrok.v1+json"}, + Schemes: []string{"http"}, + Params: params, + Reader: &DisableReader{formats: a.formats}, + AuthInfo: authInfo, + Context: params.Context, + Client: params.HTTPClient, + } + for _, opt := range opts { + opt(op) + } + + result, err := a.transport.Submit(op) + if err != nil { + return nil, err + } + success, ok := result.(*DisableOK) + if ok { + return success, nil + } + // unexpected success response + // safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue + msg := fmt.Sprintf("unexpected success response for disable: API contract not enforced by server. Client expected to get an error, but got: %T", result) + panic(msg) +} + +/* +Enable enable API */ func (a *Client) Enable(params *EnableParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*EnableCreated, error) { // TODO: Validate the params before sending @@ -117,7 +158,7 @@ func (a *Client) Enable(params *EnableParams, authInfo runtime.ClientAuthInfoWri } /* - Login login API +Login login API */ func (a *Client) Login(params *LoginParams, opts ...ClientOption) (*LoginOK, error) { // TODO: Validate the params before sending diff --git a/rest_client_zrok/identity/login_parameters.go b/rest_client_zrok/identity/login_parameters.go index b4d3f9e7..17bfd76b 100644 --- a/rest_client_zrok/identity/login_parameters.go +++ b/rest_client_zrok/identity/login_parameters.go @@ -54,10 +54,12 @@ func NewLoginParamsWithHTTPClient(client *http.Client) *LoginParams { } } -/* LoginParams contains all the parameters to send to the API endpoint - for the login operation. +/* +LoginParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the login operation. + + Typically these are written to a http.Request. */ type LoginParams struct { diff --git a/rest_client_zrok/identity/login_responses.go b/rest_client_zrok/identity/login_responses.go index 3c6f4390..6e2f5e0e 100644 --- a/rest_client_zrok/identity/login_responses.go +++ b/rest_client_zrok/identity/login_responses.go @@ -45,7 +45,8 @@ func NewLoginOK() *LoginOK { return &LoginOK{} } -/* LoginOK describes a response with status code 200, with default header values. +/* +LoginOK describes a response with status code 200, with default header values. login successful */ @@ -53,9 +54,39 @@ type LoginOK struct { Payload rest_model_zrok.LoginResponse } +// IsSuccess returns true when this login o k response has a 2xx status code +func (o *LoginOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this login o k response has a 3xx status code +func (o *LoginOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this login o k response has a 4xx status code +func (o *LoginOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this login o k response has a 5xx status code +func (o *LoginOK) IsServerError() bool { + return false +} + +// IsCode returns true when this login o k response a status code equal to that given +func (o *LoginOK) IsCode(code int) bool { + return code == 200 +} + func (o *LoginOK) Error() string { return fmt.Sprintf("[POST /login][%d] loginOK %+v", 200, o.Payload) } + +func (o *LoginOK) String() string { + return fmt.Sprintf("[POST /login][%d] loginOK %+v", 200, o.Payload) +} + func (o *LoginOK) GetPayload() rest_model_zrok.LoginResponse { return o.Payload } @@ -75,17 +106,47 @@ func NewLoginUnauthorized() *LoginUnauthorized { return &LoginUnauthorized{} } -/* LoginUnauthorized describes a response with status code 401, with default header values. +/* +LoginUnauthorized describes a response with status code 401, with default header values. invalid login */ type LoginUnauthorized struct { } +// IsSuccess returns true when this login unauthorized response has a 2xx status code +func (o *LoginUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this login unauthorized response has a 3xx status code +func (o *LoginUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this login unauthorized response has a 4xx status code +func (o *LoginUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this login unauthorized response has a 5xx status code +func (o *LoginUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this login unauthorized response a status code equal to that given +func (o *LoginUnauthorized) IsCode(code int) bool { + return code == 401 +} + func (o *LoginUnauthorized) Error() string { return fmt.Sprintf("[POST /login][%d] loginUnauthorized ", 401) } +func (o *LoginUnauthorized) String() string { + return fmt.Sprintf("[POST /login][%d] loginUnauthorized ", 401) +} + func (o *LoginUnauthorized) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { return nil diff --git a/rest_client_zrok/metadata/metadata_client.go b/rest_client_zrok/metadata/metadata_client.go index 13bc6c78..a57d3386 100644 --- a/rest_client_zrok/metadata/metadata_client.go +++ b/rest_client_zrok/metadata/metadata_client.go @@ -38,7 +38,7 @@ type ClientService interface { } /* - Overview overview API +Overview overview API */ func (a *Client) Overview(params *OverviewParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*OverviewOK, error) { // TODO: Validate the params before sending @@ -77,7 +77,7 @@ func (a *Client) Overview(params *OverviewParams, authInfo runtime.ClientAuthInf } /* - Version version API +Version version API */ func (a *Client) Version(params *VersionParams, opts ...ClientOption) (*VersionOK, error) { // TODO: Validate the params before sending diff --git a/rest_client_zrok/metadata/overview_parameters.go b/rest_client_zrok/metadata/overview_parameters.go index 7844e1cd..3a1cfde0 100644 --- a/rest_client_zrok/metadata/overview_parameters.go +++ b/rest_client_zrok/metadata/overview_parameters.go @@ -52,10 +52,12 @@ func NewOverviewParamsWithHTTPClient(client *http.Client) *OverviewParams { } } -/* OverviewParams contains all the parameters to send to the API endpoint - for the overview operation. +/* +OverviewParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the overview operation. + + Typically these are written to a http.Request. */ type OverviewParams struct { timeout time.Duration diff --git a/rest_client_zrok/metadata/overview_responses.go b/rest_client_zrok/metadata/overview_responses.go index 797c3f5c..6cfaea4e 100644 --- a/rest_client_zrok/metadata/overview_responses.go +++ b/rest_client_zrok/metadata/overview_responses.go @@ -45,7 +45,8 @@ func NewOverviewOK() *OverviewOK { return &OverviewOK{} } -/* OverviewOK describes a response with status code 200, with default header values. +/* +OverviewOK describes a response with status code 200, with default header values. overview returned */ @@ -53,9 +54,39 @@ type OverviewOK struct { Payload rest_model_zrok.EnvironmentServicesList } +// IsSuccess returns true when this overview o k response has a 2xx status code +func (o *OverviewOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this overview o k response has a 3xx status code +func (o *OverviewOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this overview o k response has a 4xx status code +func (o *OverviewOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this overview o k response has a 5xx status code +func (o *OverviewOK) IsServerError() bool { + return false +} + +// IsCode returns true when this overview o k response a status code equal to that given +func (o *OverviewOK) IsCode(code int) bool { + return code == 200 +} + func (o *OverviewOK) Error() string { return fmt.Sprintf("[GET /overview][%d] overviewOK %+v", 200, o.Payload) } + +func (o *OverviewOK) String() string { + return fmt.Sprintf("[GET /overview][%d] overviewOK %+v", 200, o.Payload) +} + func (o *OverviewOK) GetPayload() rest_model_zrok.EnvironmentServicesList { return o.Payload } @@ -75,7 +106,8 @@ func NewOverviewInternalServerError() *OverviewInternalServerError { return &OverviewInternalServerError{} } -/* OverviewInternalServerError describes a response with status code 500, with default header values. +/* +OverviewInternalServerError describes a response with status code 500, with default header values. internal server error */ @@ -83,9 +115,39 @@ type OverviewInternalServerError struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this overview internal server error response has a 2xx status code +func (o *OverviewInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this overview internal server error response has a 3xx status code +func (o *OverviewInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this overview internal server error response has a 4xx status code +func (o *OverviewInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this overview internal server error response has a 5xx status code +func (o *OverviewInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this overview internal server error response a status code equal to that given +func (o *OverviewInternalServerError) IsCode(code int) bool { + return code == 500 +} + func (o *OverviewInternalServerError) Error() string { return fmt.Sprintf("[GET /overview][%d] overviewInternalServerError %+v", 500, o.Payload) } + +func (o *OverviewInternalServerError) String() string { + return fmt.Sprintf("[GET /overview][%d] overviewInternalServerError %+v", 500, o.Payload) +} + func (o *OverviewInternalServerError) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } diff --git a/rest_client_zrok/metadata/version_parameters.go b/rest_client_zrok/metadata/version_parameters.go index 737e3038..b994442d 100644 --- a/rest_client_zrok/metadata/version_parameters.go +++ b/rest_client_zrok/metadata/version_parameters.go @@ -52,10 +52,12 @@ func NewVersionParamsWithHTTPClient(client *http.Client) *VersionParams { } } -/* VersionParams contains all the parameters to send to the API endpoint - for the version operation. +/* +VersionParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the version operation. + + Typically these are written to a http.Request. */ type VersionParams struct { timeout time.Duration diff --git a/rest_client_zrok/metadata/version_responses.go b/rest_client_zrok/metadata/version_responses.go index a65a69b1..46759dbe 100644 --- a/rest_client_zrok/metadata/version_responses.go +++ b/rest_client_zrok/metadata/version_responses.go @@ -39,7 +39,8 @@ func NewVersionOK() *VersionOK { return &VersionOK{} } -/* VersionOK describes a response with status code 200, with default header values. +/* +VersionOK describes a response with status code 200, with default header values. retrieve the current server version */ @@ -47,9 +48,39 @@ type VersionOK struct { Payload rest_model_zrok.Version } +// IsSuccess returns true when this version o k response has a 2xx status code +func (o *VersionOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this version o k response has a 3xx status code +func (o *VersionOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this version o k response has a 4xx status code +func (o *VersionOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this version o k response has a 5xx status code +func (o *VersionOK) IsServerError() bool { + return false +} + +// IsCode returns true when this version o k response a status code equal to that given +func (o *VersionOK) IsCode(code int) bool { + return code == 200 +} + func (o *VersionOK) Error() string { return fmt.Sprintf("[GET /version][%d] versionOK %+v", 200, o.Payload) } + +func (o *VersionOK) String() string { + return fmt.Sprintf("[GET /version][%d] versionOK %+v", 200, o.Payload) +} + func (o *VersionOK) GetPayload() rest_model_zrok.Version { return o.Payload } diff --git a/rest_client_zrok/tunnel/tunnel_client.go b/rest_client_zrok/tunnel/tunnel_client.go index b91a139b..680262db 100644 --- a/rest_client_zrok/tunnel/tunnel_client.go +++ b/rest_client_zrok/tunnel/tunnel_client.go @@ -38,7 +38,7 @@ type ClientService interface { } /* - Tunnel tunnel API +Tunnel tunnel API */ func (a *Client) Tunnel(params *TunnelParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*TunnelCreated, error) { // TODO: Validate the params before sending @@ -77,7 +77,7 @@ func (a *Client) Tunnel(params *TunnelParams, authInfo runtime.ClientAuthInfoWri } /* - Untunnel untunnel API +Untunnel untunnel API */ func (a *Client) Untunnel(params *UntunnelParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*UntunnelOK, error) { // TODO: Validate the params before sending diff --git a/rest_client_zrok/tunnel/tunnel_parameters.go b/rest_client_zrok/tunnel/tunnel_parameters.go index 566aa7fd..7e2c34e7 100644 --- a/rest_client_zrok/tunnel/tunnel_parameters.go +++ b/rest_client_zrok/tunnel/tunnel_parameters.go @@ -54,10 +54,12 @@ func NewTunnelParamsWithHTTPClient(client *http.Client) *TunnelParams { } } -/* TunnelParams contains all the parameters to send to the API endpoint - for the tunnel operation. +/* +TunnelParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the tunnel operation. + + Typically these are written to a http.Request. */ type TunnelParams struct { diff --git a/rest_client_zrok/tunnel/tunnel_responses.go b/rest_client_zrok/tunnel/tunnel_responses.go index c73137db..22123f03 100644 --- a/rest_client_zrok/tunnel/tunnel_responses.go +++ b/rest_client_zrok/tunnel/tunnel_responses.go @@ -51,7 +51,8 @@ func NewTunnelCreated() *TunnelCreated { return &TunnelCreated{} } -/* TunnelCreated describes a response with status code 201, with default header values. +/* +TunnelCreated describes a response with status code 201, with default header values. tunnel created */ @@ -59,9 +60,39 @@ type TunnelCreated struct { Payload *rest_model_zrok.TunnelResponse } +// IsSuccess returns true when this tunnel created response has a 2xx status code +func (o *TunnelCreated) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this tunnel created response has a 3xx status code +func (o *TunnelCreated) IsRedirect() bool { + return false +} + +// IsClientError returns true when this tunnel created response has a 4xx status code +func (o *TunnelCreated) IsClientError() bool { + return false +} + +// IsServerError returns true when this tunnel created response has a 5xx status code +func (o *TunnelCreated) IsServerError() bool { + return false +} + +// IsCode returns true when this tunnel created response a status code equal to that given +func (o *TunnelCreated) IsCode(code int) bool { + return code == 201 +} + func (o *TunnelCreated) Error() string { return fmt.Sprintf("[POST /tunnel][%d] tunnelCreated %+v", 201, o.Payload) } + +func (o *TunnelCreated) String() string { + return fmt.Sprintf("[POST /tunnel][%d] tunnelCreated %+v", 201, o.Payload) +} + func (o *TunnelCreated) GetPayload() *rest_model_zrok.TunnelResponse { return o.Payload } @@ -83,7 +114,8 @@ func NewTunnelUnauthorized() *TunnelUnauthorized { return &TunnelUnauthorized{} } -/* TunnelUnauthorized describes a response with status code 401, with default header values. +/* +TunnelUnauthorized describes a response with status code 401, with default header values. invalid environment identity */ @@ -91,9 +123,39 @@ type TunnelUnauthorized struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this tunnel unauthorized response has a 2xx status code +func (o *TunnelUnauthorized) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this tunnel unauthorized response has a 3xx status code +func (o *TunnelUnauthorized) IsRedirect() bool { + return false +} + +// IsClientError returns true when this tunnel unauthorized response has a 4xx status code +func (o *TunnelUnauthorized) IsClientError() bool { + return true +} + +// IsServerError returns true when this tunnel unauthorized response has a 5xx status code +func (o *TunnelUnauthorized) IsServerError() bool { + return false +} + +// IsCode returns true when this tunnel unauthorized response a status code equal to that given +func (o *TunnelUnauthorized) IsCode(code int) bool { + return code == 401 +} + func (o *TunnelUnauthorized) Error() string { return fmt.Sprintf("[POST /tunnel][%d] tunnelUnauthorized %+v", 401, o.Payload) } + +func (o *TunnelUnauthorized) String() string { + return fmt.Sprintf("[POST /tunnel][%d] tunnelUnauthorized %+v", 401, o.Payload) +} + func (o *TunnelUnauthorized) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } @@ -113,7 +175,8 @@ func NewTunnelInternalServerError() *TunnelInternalServerError { return &TunnelInternalServerError{} } -/* TunnelInternalServerError describes a response with status code 500, with default header values. +/* +TunnelInternalServerError describes a response with status code 500, with default header values. internal server error */ @@ -121,9 +184,39 @@ type TunnelInternalServerError struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this tunnel internal server error response has a 2xx status code +func (o *TunnelInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this tunnel internal server error response has a 3xx status code +func (o *TunnelInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this tunnel internal server error response has a 4xx status code +func (o *TunnelInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this tunnel internal server error response has a 5xx status code +func (o *TunnelInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this tunnel internal server error response a status code equal to that given +func (o *TunnelInternalServerError) IsCode(code int) bool { + return code == 500 +} + func (o *TunnelInternalServerError) Error() string { return fmt.Sprintf("[POST /tunnel][%d] tunnelInternalServerError %+v", 500, o.Payload) } + +func (o *TunnelInternalServerError) String() string { + return fmt.Sprintf("[POST /tunnel][%d] tunnelInternalServerError %+v", 500, o.Payload) +} + func (o *TunnelInternalServerError) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } diff --git a/rest_client_zrok/tunnel/untunnel_parameters.go b/rest_client_zrok/tunnel/untunnel_parameters.go index 410b3fe6..6e7fa750 100644 --- a/rest_client_zrok/tunnel/untunnel_parameters.go +++ b/rest_client_zrok/tunnel/untunnel_parameters.go @@ -54,10 +54,12 @@ func NewUntunnelParamsWithHTTPClient(client *http.Client) *UntunnelParams { } } -/* UntunnelParams contains all the parameters to send to the API endpoint - for the untunnel operation. +/* +UntunnelParams contains all the parameters to send to the API endpoint - Typically these are written to a http.Request. + for the untunnel operation. + + Typically these are written to a http.Request. */ type UntunnelParams struct { diff --git a/rest_client_zrok/tunnel/untunnel_responses.go b/rest_client_zrok/tunnel/untunnel_responses.go index e4a2eb34..1d527570 100644 --- a/rest_client_zrok/tunnel/untunnel_responses.go +++ b/rest_client_zrok/tunnel/untunnel_responses.go @@ -51,17 +51,47 @@ func NewUntunnelOK() *UntunnelOK { return &UntunnelOK{} } -/* UntunnelOK describes a response with status code 200, with default header values. +/* +UntunnelOK describes a response with status code 200, with default header values. tunnel removed */ type UntunnelOK struct { } +// IsSuccess returns true when this untunnel o k response has a 2xx status code +func (o *UntunnelOK) IsSuccess() bool { + return true +} + +// IsRedirect returns true when this untunnel o k response has a 3xx status code +func (o *UntunnelOK) IsRedirect() bool { + return false +} + +// IsClientError returns true when this untunnel o k response has a 4xx status code +func (o *UntunnelOK) IsClientError() bool { + return false +} + +// IsServerError returns true when this untunnel o k response has a 5xx status code +func (o *UntunnelOK) IsServerError() bool { + return false +} + +// IsCode returns true when this untunnel o k response a status code equal to that given +func (o *UntunnelOK) IsCode(code int) bool { + return code == 200 +} + func (o *UntunnelOK) Error() string { return fmt.Sprintf("[DELETE /untunnel][%d] untunnelOK ", 200) } +func (o *UntunnelOK) String() string { + return fmt.Sprintf("[DELETE /untunnel][%d] untunnelOK ", 200) +} + func (o *UntunnelOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { return nil @@ -72,7 +102,8 @@ func NewUntunnelNotFound() *UntunnelNotFound { return &UntunnelNotFound{} } -/* UntunnelNotFound describes a response with status code 404, with default header values. +/* +UntunnelNotFound describes a response with status code 404, with default header values. not found */ @@ -80,9 +111,39 @@ type UntunnelNotFound struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this untunnel not found response has a 2xx status code +func (o *UntunnelNotFound) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this untunnel not found response has a 3xx status code +func (o *UntunnelNotFound) IsRedirect() bool { + return false +} + +// IsClientError returns true when this untunnel not found response has a 4xx status code +func (o *UntunnelNotFound) IsClientError() bool { + return true +} + +// IsServerError returns true when this untunnel not found response has a 5xx status code +func (o *UntunnelNotFound) IsServerError() bool { + return false +} + +// IsCode returns true when this untunnel not found response a status code equal to that given +func (o *UntunnelNotFound) IsCode(code int) bool { + return code == 404 +} + func (o *UntunnelNotFound) Error() string { return fmt.Sprintf("[DELETE /untunnel][%d] untunnelNotFound %+v", 404, o.Payload) } + +func (o *UntunnelNotFound) String() string { + return fmt.Sprintf("[DELETE /untunnel][%d] untunnelNotFound %+v", 404, o.Payload) +} + func (o *UntunnelNotFound) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } @@ -102,7 +163,8 @@ func NewUntunnelInternalServerError() *UntunnelInternalServerError { return &UntunnelInternalServerError{} } -/* UntunnelInternalServerError describes a response with status code 500, with default header values. +/* +UntunnelInternalServerError describes a response with status code 500, with default header values. internal server error */ @@ -110,9 +172,39 @@ type UntunnelInternalServerError struct { Payload rest_model_zrok.ErrorMessage } +// IsSuccess returns true when this untunnel internal server error response has a 2xx status code +func (o *UntunnelInternalServerError) IsSuccess() bool { + return false +} + +// IsRedirect returns true when this untunnel internal server error response has a 3xx status code +func (o *UntunnelInternalServerError) IsRedirect() bool { + return false +} + +// IsClientError returns true when this untunnel internal server error response has a 4xx status code +func (o *UntunnelInternalServerError) IsClientError() bool { + return false +} + +// IsServerError returns true when this untunnel internal server error response has a 5xx status code +func (o *UntunnelInternalServerError) IsServerError() bool { + return true +} + +// IsCode returns true when this untunnel internal server error response a status code equal to that given +func (o *UntunnelInternalServerError) IsCode(code int) bool { + return code == 500 +} + func (o *UntunnelInternalServerError) Error() string { return fmt.Sprintf("[DELETE /untunnel][%d] untunnelInternalServerError %+v", 500, o.Payload) } + +func (o *UntunnelInternalServerError) String() string { + return fmt.Sprintf("[DELETE /untunnel][%d] untunnelInternalServerError %+v", 500, o.Payload) +} + func (o *UntunnelInternalServerError) GetPayload() rest_model_zrok.ErrorMessage { return o.Payload } diff --git a/rest_client_zrok/zrok_client.go b/rest_client_zrok/zrok_client.go index 4a02b257..8e2109ff 100644 --- a/rest_client_zrok/zrok_client.go +++ b/rest_client_zrok/zrok_client.go @@ -19,7 +19,7 @@ import ( var Default = NewHTTPClient(nil) const ( - // DefaultHost is the default HostHeader + // DefaultHost is the default Host // found in Meta (info) section of spec file DefaultHost string = "localhost" // DefaultBasePath is the default BasePath diff --git a/rest_model_zrok/disable_request.go b/rest_model_zrok/disable_request.go new file mode 100644 index 00000000..912010d2 --- /dev/null +++ b/rest_model_zrok/disable_request.go @@ -0,0 +1,50 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package rest_model_zrok + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "context" + + "github.com/go-openapi/strfmt" + "github.com/go-openapi/swag" +) + +// DisableRequest disable request +// +// swagger:model disableRequest +type DisableRequest struct { + + // identity + Identity string `json:"identity,omitempty"` +} + +// Validate validates this disable request +func (m *DisableRequest) Validate(formats strfmt.Registry) error { + return nil +} + +// ContextValidate validates this disable request based on context it is used +func (m *DisableRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error { + return nil +} + +// MarshalBinary interface implementation +func (m *DisableRequest) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *DisableRequest) UnmarshalBinary(b []byte) error { + var res DisableRequest + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/rest_server_zrok/doc.go b/rest_server_zrok/doc.go index bf1d2dca..aef023ab 100644 --- a/rest_server_zrok/doc.go +++ b/rest_server_zrok/doc.go @@ -2,18 +2,18 @@ // Package rest_server_zrok zrok // -// zrok client access -// Schemes: -// http -// HostHeader: localhost -// BasePath: /api/v1 -// Version: 1.0.0 +// zrok client access +// Schemes: +// http +// Host: localhost +// BasePath: /api/v1 +// Version: 1.0.0 // -// Consumes: -// - application/zrok.v1+json +// Consumes: +// - application/zrok.v1+json // -// Produces: -// - application/zrok.v1+json +// Produces: +// - application/zrok.v1+json // // swagger:meta package rest_server_zrok diff --git a/rest_server_zrok/embedded_spec.go b/rest_server_zrok/embedded_spec.go index cdbe2f05..eaff3d57 100644 --- a/rest_server_zrok/embedded_spec.go +++ b/rest_server_zrok/embedded_spec.go @@ -72,6 +72,42 @@ func init() { } } }, + "/disable": { + "post": { + "security": [ + { + "key": [] + } + ], + "tags": [ + "identity" + ], + "operationId": "disable", + "parameters": [ + { + "name": "body", + "in": "body", + "schema": { + "$ref": "#/definitions/disableRequest" + } + } + ], + "responses": { + "200": { + "description": "environment disabled" + }, + "401": { + "description": "invalid environment" + }, + "500": { + "description": "internal server error", + "schema": { + "$ref": "#/definitions/errorMessage" + } + } + } + } + }, "/enable": { "post": { "security": [ @@ -298,6 +334,14 @@ func init() { } } }, + "disableRequest": { + "type": "object", + "properties": { + "identity": { + "type": "string" + } + } + }, "enableRequest": { "type": "object", "properties": { @@ -535,6 +579,42 @@ func init() { } } }, + "/disable": { + "post": { + "security": [ + { + "key": [] + } + ], + "tags": [ + "identity" + ], + "operationId": "disable", + "parameters": [ + { + "name": "body", + "in": "body", + "schema": { + "$ref": "#/definitions/disableRequest" + } + } + ], + "responses": { + "200": { + "description": "environment disabled" + }, + "401": { + "description": "invalid environment" + }, + "500": { + "description": "internal server error", + "schema": { + "$ref": "#/definitions/errorMessage" + } + } + } + } + }, "/enable": { "post": { "security": [ @@ -761,6 +841,14 @@ func init() { } } }, + "disableRequest": { + "type": "object", + "properties": { + "identity": { + "type": "string" + } + } + }, "enableRequest": { "type": "object", "properties": { diff --git a/rest_server_zrok/operations/identity/create_account.go b/rest_server_zrok/operations/identity/create_account.go index ee141d1b..e0ae5618 100644 --- a/rest_server_zrok/operations/identity/create_account.go +++ b/rest_server_zrok/operations/identity/create_account.go @@ -29,10 +29,10 @@ func NewCreateAccount(ctx *middleware.Context, handler CreateAccountHandler) *Cr return &CreateAccount{Context: ctx, Handler: handler} } -/* CreateAccount swagger:route POST /account identity createAccount +/* + CreateAccount swagger:route POST /account identity createAccount CreateAccount create account API - */ type CreateAccount struct { Context *middleware.Context @@ -45,7 +45,7 @@ func (o *CreateAccount) ServeHTTP(rw http.ResponseWriter, r *http.Request) { *r = *rCtx } var Params = NewCreateAccountParams() - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/identity/create_account_parameters.go b/rest_server_zrok/operations/identity/create_account_parameters.go index f63625d3..4621383c 100644 --- a/rest_server_zrok/operations/identity/create_account_parameters.go +++ b/rest_server_zrok/operations/identity/create_account_parameters.go @@ -6,7 +6,6 @@ package identity // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "github.com/go-openapi/errors" @@ -60,7 +59,7 @@ func (o *CreateAccountParams) BindRequest(r *http.Request, route *middleware.Mat res = append(res, err) } - ctx := validate.WithOperationRequest(context.Background()) + ctx := validate.WithOperationRequest(r.Context()) if err := body.ContextValidate(ctx, route.Formats); err != nil { res = append(res, err) } diff --git a/rest_server_zrok/operations/identity/create_account_responses.go b/rest_server_zrok/operations/identity/create_account_responses.go index a6f6400c..99dbf2ad 100644 --- a/rest_server_zrok/operations/identity/create_account_responses.go +++ b/rest_server_zrok/operations/identity/create_account_responses.go @@ -16,7 +16,8 @@ import ( // CreateAccountCreatedCode is the HTTP code returned for type CreateAccountCreated const CreateAccountCreatedCode int = 201 -/*CreateAccountCreated account created +/* +CreateAccountCreated account created swagger:response createAccountCreated */ @@ -60,7 +61,8 @@ func (o *CreateAccountCreated) WriteResponse(rw http.ResponseWriter, producer ru // CreateAccountBadRequestCode is the HTTP code returned for type CreateAccountBadRequest const CreateAccountBadRequestCode int = 400 -/*CreateAccountBadRequest account not created (already exists) +/* +CreateAccountBadRequest account not created (already exists) swagger:response createAccountBadRequest */ @@ -102,7 +104,8 @@ func (o *CreateAccountBadRequest) WriteResponse(rw http.ResponseWriter, producer // CreateAccountInternalServerErrorCode is the HTTP code returned for type CreateAccountInternalServerError const CreateAccountInternalServerErrorCode int = 500 -/*CreateAccountInternalServerError internal server error +/* +CreateAccountInternalServerError internal server error swagger:response createAccountInternalServerError */ diff --git a/rest_server_zrok/operations/identity/disable.go b/rest_server_zrok/operations/identity/disable.go new file mode 100644 index 00000000..d9c18409 --- /dev/null +++ b/rest_server_zrok/operations/identity/disable.go @@ -0,0 +1,71 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package identity + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the generate command + +import ( + "net/http" + + "github.com/go-openapi/runtime/middleware" + + "github.com/openziti-test-kitchen/zrok/rest_model_zrok" +) + +// DisableHandlerFunc turns a function with the right signature into a disable handler +type DisableHandlerFunc func(DisableParams, *rest_model_zrok.Principal) middleware.Responder + +// Handle executing the request and returning a response +func (fn DisableHandlerFunc) Handle(params DisableParams, principal *rest_model_zrok.Principal) middleware.Responder { + return fn(params, principal) +} + +// DisableHandler interface for that can handle valid disable params +type DisableHandler interface { + Handle(DisableParams, *rest_model_zrok.Principal) middleware.Responder +} + +// NewDisable creates a new http.Handler for the disable operation +func NewDisable(ctx *middleware.Context, handler DisableHandler) *Disable { + return &Disable{Context: ctx, Handler: handler} +} + +/* + Disable swagger:route POST /disable identity disable + +Disable disable API +*/ +type Disable struct { + Context *middleware.Context + Handler DisableHandler +} + +func (o *Disable) ServeHTTP(rw http.ResponseWriter, r *http.Request) { + route, rCtx, _ := o.Context.RouteInfo(r) + if rCtx != nil { + *r = *rCtx + } + var Params = NewDisableParams() + uprinc, aCtx, err := o.Context.Authorize(r, route) + if err != nil { + o.Context.Respond(rw, r, route.Produces, route, err) + return + } + if aCtx != nil { + *r = *aCtx + } + var principal *rest_model_zrok.Principal + if uprinc != nil { + principal = uprinc.(*rest_model_zrok.Principal) // this is really a rest_model_zrok.Principal, I promise + } + + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params + o.Context.Respond(rw, r, route.Produces, route, err) + return + } + + res := o.Handler.Handle(Params, principal) // actually handle the request + o.Context.Respond(rw, r, route.Produces, route, res) + +} diff --git a/rest_server_zrok/operations/identity/disable_parameters.go b/rest_server_zrok/operations/identity/disable_parameters.go new file mode 100644 index 00000000..79c71c24 --- /dev/null +++ b/rest_server_zrok/operations/identity/disable_parameters.go @@ -0,0 +1,76 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package identity + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + + "github.com/go-openapi/errors" + "github.com/go-openapi/runtime" + "github.com/go-openapi/runtime/middleware" + "github.com/go-openapi/validate" + + "github.com/openziti-test-kitchen/zrok/rest_model_zrok" +) + +// NewDisableParams creates a new DisableParams object +// +// There are no default values defined in the spec. +func NewDisableParams() DisableParams { + + return DisableParams{} +} + +// DisableParams contains all the bound params for the disable operation +// typically these are obtained from a http.Request +// +// swagger:parameters disable +type DisableParams struct { + + // HTTP Request Object + HTTPRequest *http.Request `json:"-"` + + /* + In: body + */ + Body *rest_model_zrok.DisableRequest +} + +// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface +// for simple values it will use straight method calls. +// +// To ensure default values, the struct must have been initialized with NewDisableParams() beforehand. +func (o *DisableParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error { + var res []error + + o.HTTPRequest = r + + if runtime.HasBody(r) { + defer r.Body.Close() + var body rest_model_zrok.DisableRequest + if err := route.Consumer.Consume(r.Body, &body); err != nil { + res = append(res, errors.NewParseError("body", "body", "", err)) + } else { + // validate body object + if err := body.Validate(route.Formats); err != nil { + res = append(res, err) + } + + ctx := validate.WithOperationRequest(r.Context()) + if err := body.ContextValidate(ctx, route.Formats); err != nil { + res = append(res, err) + } + + if len(res) == 0 { + o.Body = &body + } + } + } + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} diff --git a/rest_server_zrok/operations/identity/disable_responses.go b/rest_server_zrok/operations/identity/disable_responses.go new file mode 100644 index 00000000..167b7978 --- /dev/null +++ b/rest_server_zrok/operations/identity/disable_responses.go @@ -0,0 +1,107 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package identity + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "net/http" + + "github.com/go-openapi/runtime" + + "github.com/openziti-test-kitchen/zrok/rest_model_zrok" +) + +// DisableOKCode is the HTTP code returned for type DisableOK +const DisableOKCode int = 200 + +/* +DisableOK environment disabled + +swagger:response disableOK +*/ +type DisableOK struct { +} + +// NewDisableOK creates DisableOK with default headers values +func NewDisableOK() *DisableOK { + + return &DisableOK{} +} + +// WriteResponse to the client +func (o *DisableOK) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses + + rw.WriteHeader(200) +} + +// DisableUnauthorizedCode is the HTTP code returned for type DisableUnauthorized +const DisableUnauthorizedCode int = 401 + +/* +DisableUnauthorized invalid environment + +swagger:response disableUnauthorized +*/ +type DisableUnauthorized struct { +} + +// NewDisableUnauthorized creates DisableUnauthorized with default headers values +func NewDisableUnauthorized() *DisableUnauthorized { + + return &DisableUnauthorized{} +} + +// WriteResponse to the client +func (o *DisableUnauthorized) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.Header().Del(runtime.HeaderContentType) //Remove Content-Type on empty responses + + rw.WriteHeader(401) +} + +// DisableInternalServerErrorCode is the HTTP code returned for type DisableInternalServerError +const DisableInternalServerErrorCode int = 500 + +/* +DisableInternalServerError internal server error + +swagger:response disableInternalServerError +*/ +type DisableInternalServerError struct { + + /* + In: Body + */ + Payload rest_model_zrok.ErrorMessage `json:"body,omitempty"` +} + +// NewDisableInternalServerError creates DisableInternalServerError with default headers values +func NewDisableInternalServerError() *DisableInternalServerError { + + return &DisableInternalServerError{} +} + +// WithPayload adds the payload to the disable internal server error response +func (o *DisableInternalServerError) WithPayload(payload rest_model_zrok.ErrorMessage) *DisableInternalServerError { + o.Payload = payload + return o +} + +// SetPayload sets the payload to the disable internal server error response +func (o *DisableInternalServerError) SetPayload(payload rest_model_zrok.ErrorMessage) { + o.Payload = payload +} + +// WriteResponse to the client +func (o *DisableInternalServerError) WriteResponse(rw http.ResponseWriter, producer runtime.Producer) { + + rw.WriteHeader(500) + payload := o.Payload + if err := producer.Produce(rw, payload); err != nil { + panic(err) // let the recovery middleware deal with this + } +} diff --git a/rest_server_zrok/operations/identity/disable_urlbuilder.go b/rest_server_zrok/operations/identity/disable_urlbuilder.go new file mode 100644 index 00000000..8fd837ce --- /dev/null +++ b/rest_server_zrok/operations/identity/disable_urlbuilder.go @@ -0,0 +1,87 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package identity + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the generate command + +import ( + "errors" + "net/url" + golangswaggerpaths "path" +) + +// DisableURL generates an URL for the disable operation +type DisableURL struct { + _basePath string +} + +// WithBasePath sets the base path for this url builder, only required when it's different from the +// base path specified in the swagger spec. +// When the value of the base path is an empty string +func (o *DisableURL) WithBasePath(bp string) *DisableURL { + o.SetBasePath(bp) + return o +} + +// SetBasePath sets the base path for this url builder, only required when it's different from the +// base path specified in the swagger spec. +// When the value of the base path is an empty string +func (o *DisableURL) SetBasePath(bp string) { + o._basePath = bp +} + +// Build a url path and query string +func (o *DisableURL) Build() (*url.URL, error) { + var _result url.URL + + var _path = "/disable" + + _basePath := o._basePath + if _basePath == "" { + _basePath = "/api/v1" + } + _result.Path = golangswaggerpaths.Join(_basePath, _path) + + return &_result, nil +} + +// Must is a helper function to panic when the url builder returns an error +func (o *DisableURL) Must(u *url.URL, err error) *url.URL { + if err != nil { + panic(err) + } + if u == nil { + panic("url can't be nil") + } + return u +} + +// String returns the string representation of the path with query string +func (o *DisableURL) String() string { + return o.Must(o.Build()).String() +} + +// BuildFull builds a full url with scheme, host, path and query string +func (o *DisableURL) BuildFull(scheme, host string) (*url.URL, error) { + if scheme == "" { + return nil, errors.New("scheme is required for a full url on DisableURL") + } + if host == "" { + return nil, errors.New("host is required for a full url on DisableURL") + } + + base, err := o.Build() + if err != nil { + return nil, err + } + + base.Scheme = scheme + base.Host = host + return base, nil +} + +// StringFull returns the string representation of a complete url +func (o *DisableURL) StringFull(scheme, host string) string { + return o.Must(o.BuildFull(scheme, host)).String() +} diff --git a/rest_server_zrok/operations/identity/enable.go b/rest_server_zrok/operations/identity/enable.go index 17e422bc..23f97d91 100644 --- a/rest_server_zrok/operations/identity/enable.go +++ b/rest_server_zrok/operations/identity/enable.go @@ -31,10 +31,10 @@ func NewEnable(ctx *middleware.Context, handler EnableHandler) *Enable { return &Enable{Context: ctx, Handler: handler} } -/* Enable swagger:route POST /enable identity enable +/* + Enable swagger:route POST /enable identity enable Enable enable API - */ type Enable struct { Context *middleware.Context @@ -60,7 +60,7 @@ func (o *Enable) ServeHTTP(rw http.ResponseWriter, r *http.Request) { principal = uprinc.(*rest_model_zrok.Principal) // this is really a rest_model_zrok.Principal, I promise } - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/identity/enable_parameters.go b/rest_server_zrok/operations/identity/enable_parameters.go index 8ce5097e..fd330573 100644 --- a/rest_server_zrok/operations/identity/enable_parameters.go +++ b/rest_server_zrok/operations/identity/enable_parameters.go @@ -6,7 +6,6 @@ package identity // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "github.com/go-openapi/errors" @@ -60,7 +59,7 @@ func (o *EnableParams) BindRequest(r *http.Request, route *middleware.MatchedRou res = append(res, err) } - ctx := validate.WithOperationRequest(context.Background()) + ctx := validate.WithOperationRequest(r.Context()) if err := body.ContextValidate(ctx, route.Formats); err != nil { res = append(res, err) } diff --git a/rest_server_zrok/operations/identity/enable_responses.go b/rest_server_zrok/operations/identity/enable_responses.go index 29916144..0916978e 100644 --- a/rest_server_zrok/operations/identity/enable_responses.go +++ b/rest_server_zrok/operations/identity/enable_responses.go @@ -16,7 +16,8 @@ import ( // EnableCreatedCode is the HTTP code returned for type EnableCreated const EnableCreatedCode int = 201 -/*EnableCreated environment enabled +/* +EnableCreated environment enabled swagger:response enableCreated */ @@ -60,7 +61,8 @@ func (o *EnableCreated) WriteResponse(rw http.ResponseWriter, producer runtime.P // EnableUnauthorizedCode is the HTTP code returned for type EnableUnauthorized const EnableUnauthorizedCode int = 401 -/*EnableUnauthorized invalid api key +/* +EnableUnauthorized invalid api key swagger:response enableUnauthorized */ @@ -84,7 +86,8 @@ func (o *EnableUnauthorized) WriteResponse(rw http.ResponseWriter, producer runt // EnableNotFoundCode is the HTTP code returned for type EnableNotFound const EnableNotFoundCode int = 404 -/*EnableNotFound account not found +/* +EnableNotFound account not found swagger:response enableNotFound */ @@ -108,7 +111,8 @@ func (o *EnableNotFound) WriteResponse(rw http.ResponseWriter, producer runtime. // EnableInternalServerErrorCode is the HTTP code returned for type EnableInternalServerError const EnableInternalServerErrorCode int = 500 -/*EnableInternalServerError internal server error +/* +EnableInternalServerError internal server error swagger:response enableInternalServerError */ diff --git a/rest_server_zrok/operations/identity/login.go b/rest_server_zrok/operations/identity/login.go index e7e9120f..6acf4847 100644 --- a/rest_server_zrok/operations/identity/login.go +++ b/rest_server_zrok/operations/identity/login.go @@ -29,10 +29,10 @@ func NewLogin(ctx *middleware.Context, handler LoginHandler) *Login { return &Login{Context: ctx, Handler: handler} } -/* Login swagger:route POST /login identity login +/* + Login swagger:route POST /login identity login Login login API - */ type Login struct { Context *middleware.Context @@ -45,7 +45,7 @@ func (o *Login) ServeHTTP(rw http.ResponseWriter, r *http.Request) { *r = *rCtx } var Params = NewLoginParams() - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/identity/login_parameters.go b/rest_server_zrok/operations/identity/login_parameters.go index 1802bd96..37b155bb 100644 --- a/rest_server_zrok/operations/identity/login_parameters.go +++ b/rest_server_zrok/operations/identity/login_parameters.go @@ -6,7 +6,6 @@ package identity // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "github.com/go-openapi/errors" @@ -60,7 +59,7 @@ func (o *LoginParams) BindRequest(r *http.Request, route *middleware.MatchedRout res = append(res, err) } - ctx := validate.WithOperationRequest(context.Background()) + ctx := validate.WithOperationRequest(r.Context()) if err := body.ContextValidate(ctx, route.Formats); err != nil { res = append(res, err) } diff --git a/rest_server_zrok/operations/identity/login_responses.go b/rest_server_zrok/operations/identity/login_responses.go index 1e7b1a7e..a0d125ed 100644 --- a/rest_server_zrok/operations/identity/login_responses.go +++ b/rest_server_zrok/operations/identity/login_responses.go @@ -16,7 +16,8 @@ import ( // LoginOKCode is the HTTP code returned for type LoginOK const LoginOKCode int = 200 -/*LoginOK login successful +/* +LoginOK login successful swagger:response loginOK */ @@ -58,7 +59,8 @@ func (o *LoginOK) WriteResponse(rw http.ResponseWriter, producer runtime.Produce // LoginUnauthorizedCode is the HTTP code returned for type LoginUnauthorized const LoginUnauthorizedCode int = 401 -/*LoginUnauthorized invalid login +/* +LoginUnauthorized invalid login swagger:response loginUnauthorized */ diff --git a/rest_server_zrok/operations/metadata/overview.go b/rest_server_zrok/operations/metadata/overview.go index 23cd4a05..b478c0ef 100644 --- a/rest_server_zrok/operations/metadata/overview.go +++ b/rest_server_zrok/operations/metadata/overview.go @@ -31,10 +31,10 @@ func NewOverview(ctx *middleware.Context, handler OverviewHandler) *Overview { return &Overview{Context: ctx, Handler: handler} } -/* Overview swagger:route GET /overview metadata overview +/* + Overview swagger:route GET /overview metadata overview Overview overview API - */ type Overview struct { Context *middleware.Context @@ -60,7 +60,7 @@ func (o *Overview) ServeHTTP(rw http.ResponseWriter, r *http.Request) { principal = uprinc.(*rest_model_zrok.Principal) // this is really a rest_model_zrok.Principal, I promise } - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/metadata/overview_responses.go b/rest_server_zrok/operations/metadata/overview_responses.go index 79105e46..7ffc215e 100644 --- a/rest_server_zrok/operations/metadata/overview_responses.go +++ b/rest_server_zrok/operations/metadata/overview_responses.go @@ -16,7 +16,8 @@ import ( // OverviewOKCode is the HTTP code returned for type OverviewOK const OverviewOKCode int = 200 -/*OverviewOK overview returned +/* +OverviewOK overview returned swagger:response overviewOK */ @@ -63,7 +64,8 @@ func (o *OverviewOK) WriteResponse(rw http.ResponseWriter, producer runtime.Prod // OverviewInternalServerErrorCode is the HTTP code returned for type OverviewInternalServerError const OverviewInternalServerErrorCode int = 500 -/*OverviewInternalServerError internal server error +/* +OverviewInternalServerError internal server error swagger:response overviewInternalServerError */ diff --git a/rest_server_zrok/operations/metadata/version.go b/rest_server_zrok/operations/metadata/version.go index 9e63ee6f..63ad71db 100644 --- a/rest_server_zrok/operations/metadata/version.go +++ b/rest_server_zrok/operations/metadata/version.go @@ -29,10 +29,10 @@ func NewVersion(ctx *middleware.Context, handler VersionHandler) *Version { return &Version{Context: ctx, Handler: handler} } -/* Version swagger:route GET /version metadata version +/* + Version swagger:route GET /version metadata version Version version API - */ type Version struct { Context *middleware.Context @@ -45,7 +45,7 @@ func (o *Version) ServeHTTP(rw http.ResponseWriter, r *http.Request) { *r = *rCtx } var Params = NewVersionParams() - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/metadata/version_responses.go b/rest_server_zrok/operations/metadata/version_responses.go index c7604716..4cef5ecc 100644 --- a/rest_server_zrok/operations/metadata/version_responses.go +++ b/rest_server_zrok/operations/metadata/version_responses.go @@ -16,7 +16,8 @@ import ( // VersionOKCode is the HTTP code returned for type VersionOK const VersionOKCode int = 200 -/*VersionOK retrieve the current server version +/* +VersionOK retrieve the current server version swagger:response versionOK */ diff --git a/rest_server_zrok/operations/tunnel/tunnel.go b/rest_server_zrok/operations/tunnel/tunnel.go index 0adced24..85b54bf1 100644 --- a/rest_server_zrok/operations/tunnel/tunnel.go +++ b/rest_server_zrok/operations/tunnel/tunnel.go @@ -31,10 +31,10 @@ func NewTunnel(ctx *middleware.Context, handler TunnelHandler) *Tunnel { return &Tunnel{Context: ctx, Handler: handler} } -/* Tunnel swagger:route POST /tunnel tunnel tunnel +/* + Tunnel swagger:route POST /tunnel tunnel tunnel Tunnel tunnel API - */ type Tunnel struct { Context *middleware.Context @@ -60,7 +60,7 @@ func (o *Tunnel) ServeHTTP(rw http.ResponseWriter, r *http.Request) { principal = uprinc.(*rest_model_zrok.Principal) // this is really a rest_model_zrok.Principal, I promise } - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/tunnel/tunnel_parameters.go b/rest_server_zrok/operations/tunnel/tunnel_parameters.go index 57b454a6..a294752a 100644 --- a/rest_server_zrok/operations/tunnel/tunnel_parameters.go +++ b/rest_server_zrok/operations/tunnel/tunnel_parameters.go @@ -6,7 +6,6 @@ package tunnel // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "github.com/go-openapi/errors" @@ -60,7 +59,7 @@ func (o *TunnelParams) BindRequest(r *http.Request, route *middleware.MatchedRou res = append(res, err) } - ctx := validate.WithOperationRequest(context.Background()) + ctx := validate.WithOperationRequest(r.Context()) if err := body.ContextValidate(ctx, route.Formats); err != nil { res = append(res, err) } diff --git a/rest_server_zrok/operations/tunnel/tunnel_responses.go b/rest_server_zrok/operations/tunnel/tunnel_responses.go index f3dc3b5e..b5c9fd30 100644 --- a/rest_server_zrok/operations/tunnel/tunnel_responses.go +++ b/rest_server_zrok/operations/tunnel/tunnel_responses.go @@ -16,7 +16,8 @@ import ( // TunnelCreatedCode is the HTTP code returned for type TunnelCreated const TunnelCreatedCode int = 201 -/*TunnelCreated tunnel created +/* +TunnelCreated tunnel created swagger:response tunnelCreated */ @@ -60,7 +61,8 @@ func (o *TunnelCreated) WriteResponse(rw http.ResponseWriter, producer runtime.P // TunnelUnauthorizedCode is the HTTP code returned for type TunnelUnauthorized const TunnelUnauthorizedCode int = 401 -/*TunnelUnauthorized invalid environment identity +/* +TunnelUnauthorized invalid environment identity swagger:response tunnelUnauthorized */ @@ -102,7 +104,8 @@ func (o *TunnelUnauthorized) WriteResponse(rw http.ResponseWriter, producer runt // TunnelInternalServerErrorCode is the HTTP code returned for type TunnelInternalServerError const TunnelInternalServerErrorCode int = 500 -/*TunnelInternalServerError internal server error +/* +TunnelInternalServerError internal server error swagger:response tunnelInternalServerError */ diff --git a/rest_server_zrok/operations/tunnel/untunnel.go b/rest_server_zrok/operations/tunnel/untunnel.go index 9c2d2570..dbda2eca 100644 --- a/rest_server_zrok/operations/tunnel/untunnel.go +++ b/rest_server_zrok/operations/tunnel/untunnel.go @@ -31,10 +31,10 @@ func NewUntunnel(ctx *middleware.Context, handler UntunnelHandler) *Untunnel { return &Untunnel{Context: ctx, Handler: handler} } -/* Untunnel swagger:route DELETE /untunnel tunnel untunnel +/* + Untunnel swagger:route DELETE /untunnel tunnel untunnel Untunnel untunnel API - */ type Untunnel struct { Context *middleware.Context @@ -60,7 +60,7 @@ func (o *Untunnel) ServeHTTP(rw http.ResponseWriter, r *http.Request) { principal = uprinc.(*rest_model_zrok.Principal) // this is really a rest_model_zrok.Principal, I promise } - if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // backend params + if err := o.Context.BindValidRequest(r, route, &Params); err != nil { // bind params o.Context.Respond(rw, r, route.Produces, route, err) return } diff --git a/rest_server_zrok/operations/tunnel/untunnel_parameters.go b/rest_server_zrok/operations/tunnel/untunnel_parameters.go index db892bf8..55cd49d4 100644 --- a/rest_server_zrok/operations/tunnel/untunnel_parameters.go +++ b/rest_server_zrok/operations/tunnel/untunnel_parameters.go @@ -6,7 +6,6 @@ package tunnel // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "github.com/go-openapi/errors" @@ -60,7 +59,7 @@ func (o *UntunnelParams) BindRequest(r *http.Request, route *middleware.MatchedR res = append(res, err) } - ctx := validate.WithOperationRequest(context.Background()) + ctx := validate.WithOperationRequest(r.Context()) if err := body.ContextValidate(ctx, route.Formats); err != nil { res = append(res, err) } diff --git a/rest_server_zrok/operations/tunnel/untunnel_responses.go b/rest_server_zrok/operations/tunnel/untunnel_responses.go index 796c9178..480ee349 100644 --- a/rest_server_zrok/operations/tunnel/untunnel_responses.go +++ b/rest_server_zrok/operations/tunnel/untunnel_responses.go @@ -16,7 +16,8 @@ import ( // UntunnelOKCode is the HTTP code returned for type UntunnelOK const UntunnelOKCode int = 200 -/*UntunnelOK tunnel removed +/* +UntunnelOK tunnel removed swagger:response untunnelOK */ @@ -40,7 +41,8 @@ func (o *UntunnelOK) WriteResponse(rw http.ResponseWriter, producer runtime.Prod // UntunnelNotFoundCode is the HTTP code returned for type UntunnelNotFound const UntunnelNotFoundCode int = 404 -/*UntunnelNotFound not found +/* +UntunnelNotFound not found swagger:response untunnelNotFound */ @@ -82,7 +84,8 @@ func (o *UntunnelNotFound) WriteResponse(rw http.ResponseWriter, producer runtim // UntunnelInternalServerErrorCode is the HTTP code returned for type UntunnelInternalServerError const UntunnelInternalServerErrorCode int = 500 -/*UntunnelInternalServerError internal server error +/* +UntunnelInternalServerError internal server error swagger:response untunnelInternalServerError */ diff --git a/rest_server_zrok/operations/zrok_api.go b/rest_server_zrok/operations/zrok_api.go index 9849840c..9843ed40 100644 --- a/rest_server_zrok/operations/zrok_api.go +++ b/rest_server_zrok/operations/zrok_api.go @@ -50,6 +50,9 @@ func NewZrokAPI(spec *loads.Document) *ZrokAPI { IdentityCreateAccountHandler: identity.CreateAccountHandlerFunc(func(params identity.CreateAccountParams) middleware.Responder { return middleware.NotImplemented("operation identity.CreateAccount has not yet been implemented") }), + IdentityDisableHandler: identity.DisableHandlerFunc(func(params identity.DisableParams, principal *rest_model_zrok.Principal) middleware.Responder { + return middleware.NotImplemented("operation identity.Disable has not yet been implemented") + }), IdentityEnableHandler: identity.EnableHandlerFunc(func(params identity.EnableParams, principal *rest_model_zrok.Principal) middleware.Responder { return middleware.NotImplemented("operation identity.Enable has not yet been implemented") }), @@ -120,6 +123,8 @@ type ZrokAPI struct { // IdentityCreateAccountHandler sets the operation handler for the create account operation IdentityCreateAccountHandler identity.CreateAccountHandler + // IdentityDisableHandler sets the operation handler for the disable operation + IdentityDisableHandler identity.DisableHandler // IdentityEnableHandler sets the operation handler for the enable operation IdentityEnableHandler identity.EnableHandler // IdentityLoginHandler sets the operation handler for the login operation @@ -216,6 +221,9 @@ func (o *ZrokAPI) Validate() error { if o.IdentityCreateAccountHandler == nil { unregistered = append(unregistered, "identity.CreateAccountHandler") } + if o.IdentityDisableHandler == nil { + unregistered = append(unregistered, "identity.DisableHandler") + } if o.IdentityEnableHandler == nil { unregistered = append(unregistered, "identity.EnableHandler") } @@ -340,6 +348,10 @@ func (o *ZrokAPI) initHandlerCache() { if o.handlers["POST"] == nil { o.handlers["POST"] = make(map[string]http.Handler) } + o.handlers["POST"]["/disable"] = identity.NewDisable(o.context, o.IdentityDisableHandler) + if o.handlers["POST"] == nil { + o.handlers["POST"] = make(map[string]http.Handler) + } o.handlers["POST"]["/enable"] = identity.NewEnable(o.context, o.IdentityEnableHandler) if o.handlers["POST"] == nil { o.handlers["POST"] = make(map[string]http.Handler) diff --git a/rest_server_zrok/server.go b/rest_server_zrok/server.go index c2099497..2bc7f9c6 100644 --- a/rest_server_zrok/server.go +++ b/rest_server_zrok/server.go @@ -8,7 +8,6 @@ import ( "crypto/x509" "errors" "fmt" - "io/ioutil" "log" "net" "net/http" @@ -73,23 +72,23 @@ type Server struct { GracefulTimeout time.Duration `long:"graceful-timeout" description:"grace period for which to wait before shutting down the server" default:"15s"` MaxHeaderSize flagext.ByteSize `long:"max-header-size" description:"controls the maximum number of bytes the server will read parsing the request header's keys and values, including the request line. It does not limit the size of the request body." default:"1MiB"` - SocketPath flags.Filename `long:"socket-path" description:"the unix socket to frontend on" default:"/var/run/zrok.sock"` + SocketPath flags.Filename `long:"socket-path" description:"the unix socket to listen on" default:"/var/run/zrok.sock"` domainSocketL net.Listener - Host string `long:"host" description:"the IP to frontend on" default:"localhost" env:"HOST"` - Port int `long:"port" description:"the port to frontend on for insecure connections, defaults to a random value" env:"PORT"` - ListenLimit int `long:"frontend-limit" description:"limit the number of outstanding requests"` + Host string `long:"host" description:"the IP to listen on" default:"localhost" env:"HOST"` + Port int `long:"port" description:"the port to listen on for insecure connections, defaults to a random value" env:"PORT"` + ListenLimit int `long:"listen-limit" description:"limit the number of outstanding requests"` KeepAlive time.Duration `long:"keep-alive" description:"sets the TCP keep-alive timeouts on accepted connections. It prunes dead TCP connections ( e.g. closing laptop mid-download)" default:"3m"` ReadTimeout time.Duration `long:"read-timeout" description:"maximum duration before timing out read of the request" default:"30s"` WriteTimeout time.Duration `long:"write-timeout" description:"maximum duration before timing out write of the response" default:"60s"` httpServerL net.Listener - TLSHost string `long:"tls-host" description:"the IP to frontend on for tls, when not specified it's the same as --host" env:"TLS_HOST"` - TLSPort int `long:"tls-port" description:"the port to frontend on for secure connections, defaults to a random value" env:"TLS_PORT"` + TLSHost string `long:"tls-host" description:"the IP to listen on for tls, when not specified it's the same as --host" env:"TLS_HOST"` + TLSPort int `long:"tls-port" description:"the port to listen on for secure connections, defaults to a random value" env:"TLS_PORT"` TLSCertificate flags.Filename `long:"tls-certificate" description:"the certificate to use for secure connections" env:"TLS_CERTIFICATE"` TLSCertificateKey flags.Filename `long:"tls-key" description:"the private key to use for secure connections" env:"TLS_PRIVATE_KEY"` TLSCACertificate flags.Filename `long:"tls-ca" description:"the certificate authority file to be used with mutual tls auth" env:"TLS_CA_CERTIFICATE"` - TLSListenLimit int `long:"tls-frontend-limit" description:"limit the number of outstanding requests"` + TLSListenLimit int `long:"tls-listen-limit" description:"limit the number of outstanding requests"` TLSKeepAlive time.Duration `long:"tls-keep-alive" description:"sets the TCP keep-alive timeouts on accepted connections. It prunes dead TCP connections ( e.g. closing laptop mid-download)"` TLSReadTimeout time.Duration `long:"tls-read-timeout" description:"maximum duration before timing out read of the request"` TLSWriteTimeout time.Duration `long:"tls-write-timeout" description:"maximum duration before timing out write of the response"` @@ -274,7 +273,7 @@ func (s *Server) Serve() (err error) { if s.TLSCACertificate != "" { // include specified CA certificate - caCert, caCertErr := ioutil.ReadFile(string(s.TLSCACertificate)) + caCert, caCertErr := os.ReadFile(string(s.TLSCACertificate)) if caCertErr != nil { return caCertErr } @@ -337,7 +336,7 @@ func (s *Server) Listen() error { if s.TLSHost == "" { s.TLSHost = s.Host } - // Use http frontend limit if https frontend limit wasn't defined + // Use http listen limit if https listen limit wasn't defined if s.TLSListenLimit == 0 { s.TLSListenLimit = s.ListenLimit } diff --git a/specs/zrok.yml b/specs/zrok.yml index 09dae9ea..ecbd38b9 100644 --- a/specs/zrok.yml +++ b/specs/zrok.yml @@ -62,6 +62,28 @@ paths: schema: $ref: "#/definitions/errorMessage" + /disable: + post: + tags: + - identity + security: + - key: [] + operationId: disable + parameters: + - name: body + in: body + schema: + $ref: "#/definitions/disableRequest" + responses: + 200: + description: environment disabled + 401: + description: invalid environment + 500: + description: internal server error + schema: + $ref: "#/definitions/errorMessage" + /login: post: tags: @@ -194,6 +216,12 @@ definitions: cfg: type: string + disableRequest: + type: object + properties: + identity: + type: string + environments: type: array items: diff --git a/ui/src/api/identity.js b/ui/src/api/identity.js index b0ce9728..f78f6c3a 100644 --- a/ui/src/api/identity.js +++ b/ui/src/api/identity.js @@ -32,6 +32,21 @@ export function enable(options) { return gateway.request(enableOperation, parameters) } +/** + * @param {object} options Optional options + * @param {module:types.disableRequest} [options.body] + * @return {Promise} environment disabled + */ +export function disable(options) { + if (!options) options = {} + const parameters = { + body: { + body: options.body + } + } + return gateway.request(disableOperation, parameters) +} + /** * @param {object} options Optional options * @param {module:types.loginRequest} [options.body] @@ -64,6 +79,17 @@ const enableOperation = { ] } +const disableOperation = { + path: '/disable', + contentTypes: ['application/zrok.v1+json'], + method: 'post', + security: [ + { + id: 'key' + } + ] +} + const loginOperation = { path: '/login', contentTypes: ['application/zrok.v1+json'], diff --git a/ui/src/api/types.js b/ui/src/api/types.js index e8e1e5d8..e21449d3 100644 --- a/ui/src/api/types.js +++ b/ui/src/api/types.js @@ -40,6 +40,13 @@ * @property {string} cfg */ +/** + * @typedef disableRequest + * @memberof module:types + * + * @property {string} identity + */ + /** * @typedef environment * @memberof module:types