// Code generated by ogen, DO NOT EDIT. package api import ( "context" "net/http" "time" "github.com/go-faster/errors" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/metric" semconv "go.opentelemetry.io/otel/semconv/v1.26.0" "go.opentelemetry.io/otel/trace" ht "github.com/ogen-go/ogen/http" "github.com/ogen-go/ogen/middleware" "github.com/ogen-go/ogen/ogenerrors" "github.com/ogen-go/ogen/otelogen" ) type codeRecorder struct { http.ResponseWriter status int } func (c *codeRecorder) WriteHeader(status int) { c.status = status c.ResponseWriter.WriteHeader(status) } // handleActionSubmissionPublishRequest handles actionSubmissionPublish operation. // // (Internal endpoint) Role Validator changes status from Publishing -> Published. // // POST /submissions/{SubmissionID}/status/validator-published func (s *Server) handleActionSubmissionPublishRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionPublish"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/validator-published"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionPublishOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionPublishOperation, ID: "actionSubmissionPublish", } ) params, err := decodeActionSubmissionPublishParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionPublishNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionPublishOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Publishing -> Published", OperationID: "actionSubmissionPublish", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionPublishParams Response = *ActionSubmissionPublishNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionPublishParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionPublish(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionPublish(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionPublishResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionRejectRequest handles actionSubmissionReject operation. // // Role Reviewer changes status from Submitted -> Rejected. // // POST /submissions/{SubmissionID}/status/reject func (s *Server) handleActionSubmissionRejectRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionReject"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/reject"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionRejectOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionRejectOperation, ID: "actionSubmissionReject", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionRejectOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeActionSubmissionRejectParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionRejectNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionRejectOperation, OperationSummary: "Role Reviewer changes status from Submitted -> Rejected", OperationID: "actionSubmissionReject", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionRejectParams Response = *ActionSubmissionRejectNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionRejectParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionReject(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionReject(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionRejectResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionRequestChangesRequest handles actionSubmissionRequestChanges operation. // // Role Reviewer changes status from Validated|Accepted|Submitted -> ChangesRequested. // // POST /submissions/{SubmissionID}/status/request-changes func (s *Server) handleActionSubmissionRequestChangesRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionRequestChanges"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/request-changes"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionRequestChangesOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionRequestChangesOperation, ID: "actionSubmissionRequestChanges", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionRequestChangesOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeActionSubmissionRequestChangesParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionRequestChangesNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionRequestChangesOperation, OperationSummary: "Role Reviewer changes status from Validated|Accepted|Submitted -> ChangesRequested", OperationID: "actionSubmissionRequestChanges", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionRequestChangesParams Response = *ActionSubmissionRequestChangesNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionRequestChangesParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionRequestChanges(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionRequestChanges(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionRequestChangesResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionRevokeRequest handles actionSubmissionRevoke operation. // // Role Submitter changes status from Submitted|ChangesRequested -> UnderConstruction. // // POST /submissions/{SubmissionID}/status/revoke func (s *Server) handleActionSubmissionRevokeRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionRevoke"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/revoke"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionRevokeOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionRevokeOperation, ID: "actionSubmissionRevoke", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionRevokeOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeActionSubmissionRevokeParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionRevokeNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionRevokeOperation, OperationSummary: "Role Submitter changes status from Submitted|ChangesRequested -> UnderConstruction", OperationID: "actionSubmissionRevoke", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionRevokeParams Response = *ActionSubmissionRevokeNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionRevokeParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionRevoke(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionRevoke(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionRevokeResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionSubmitRequest handles actionSubmissionSubmit operation. // // Role Submitter changes status from UnderConstruction|ChangesRequested -> Submitted. // // POST /submissions/{SubmissionID}/status/submit func (s *Server) handleActionSubmissionSubmitRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionSubmit"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/submit"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionSubmitOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionSubmitOperation, ID: "actionSubmissionSubmit", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionSubmitOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeActionSubmissionSubmitParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionSubmitNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionSubmitOperation, OperationSummary: "Role Submitter changes status from UnderConstruction|ChangesRequested -> Submitted", OperationID: "actionSubmissionSubmit", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionSubmitParams Response = *ActionSubmissionSubmitNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionSubmitParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionSubmit(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionSubmit(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionSubmitResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionTriggerPublishRequest handles actionSubmissionTriggerPublish operation. // // Role Admin changes status from Validated -> Publishing. // // POST /submissions/{SubmissionID}/status/trigger-publish func (s *Server) handleActionSubmissionTriggerPublishRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionTriggerPublish"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/trigger-publish"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionTriggerPublishOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionTriggerPublishOperation, ID: "actionSubmissionTriggerPublish", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionTriggerPublishOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeActionSubmissionTriggerPublishParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionTriggerPublishNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionTriggerPublishOperation, OperationSummary: "Role Admin changes status from Validated -> Publishing", OperationID: "actionSubmissionTriggerPublish", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionTriggerPublishParams Response = *ActionSubmissionTriggerPublishNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionTriggerPublishParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionTriggerPublish(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionTriggerPublish(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionTriggerPublishResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionTriggerValidateRequest handles actionSubmissionTriggerValidate operation. // // Role Reviewer triggers validation and changes status from Submitted|Accepted -> Validating. // // POST /submissions/{SubmissionID}/status/trigger-validate func (s *Server) handleActionSubmissionTriggerValidateRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionTriggerValidate"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/trigger-validate"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionTriggerValidateOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionTriggerValidateOperation, ID: "actionSubmissionTriggerValidate", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionTriggerValidateOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeActionSubmissionTriggerValidateParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionTriggerValidateNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionTriggerValidateOperation, OperationSummary: "Role Reviewer triggers validation and changes status from Submitted|Accepted -> Validating", OperationID: "actionSubmissionTriggerValidate", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionTriggerValidateParams Response = *ActionSubmissionTriggerValidateNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionTriggerValidateParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionTriggerValidate(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionTriggerValidate(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionTriggerValidateResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleActionSubmissionValidateRequest handles actionSubmissionValidate operation. // // (Internal endpoint) Role Validator changes status from Validating -> Validated. // // POST /submissions/{SubmissionID}/status/validator-validated func (s *Server) handleActionSubmissionValidateRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("actionSubmissionValidate"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/validator-validated"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionValidateOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ActionSubmissionValidateOperation, ID: "actionSubmissionValidate", } ) params, err := decodeActionSubmissionValidateParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ActionSubmissionValidateNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ActionSubmissionValidateOperation, OperationSummary: "(Internal endpoint) Role Validator changes status from Validating -> Validated", OperationID: "actionSubmissionValidate", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = ActionSubmissionValidateParams Response = *ActionSubmissionValidateNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackActionSubmissionValidateParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.ActionSubmissionValidate(ctx, params) return response, err }, ) } else { err = s.h.ActionSubmissionValidate(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeActionSubmissionValidateResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleCreateScriptRequest handles createScript operation. // // Create a new script. // // POST /scripts func (s *Server) handleCreateScriptRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("createScript"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/scripts"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), CreateScriptOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: CreateScriptOperation, ID: "createScript", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, CreateScriptOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } request, close, err := s.decodeCreateScriptRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *ID if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: CreateScriptOperation, OperationSummary: "Create a new script", OperationID: "createScript", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *ScriptCreate Params = struct{} Response = *ID ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.CreateScript(ctx, request) return response, err }, ) } else { response, err = s.h.CreateScript(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeCreateScriptResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleCreateScriptPolicyRequest handles createScriptPolicy operation. // // Create a new script policy. // // POST /script-policy func (s *Server) handleCreateScriptPolicyRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("createScriptPolicy"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/script-policy"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), CreateScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: CreateScriptPolicyOperation, ID: "createScriptPolicy", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, CreateScriptPolicyOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } request, close, err := s.decodeCreateScriptPolicyRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *ID if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: CreateScriptPolicyOperation, OperationSummary: "Create a new script policy", OperationID: "createScriptPolicy", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *ScriptPolicyCreate Params = struct{} Response = *ID ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.CreateScriptPolicy(ctx, request) return response, err }, ) } else { response, err = s.h.CreateScriptPolicy(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeCreateScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleCreateSubmissionRequest handles createSubmission operation. // // Create new submission. // // POST /submissions func (s *Server) handleCreateSubmissionRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("createSubmission"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), CreateSubmissionOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: CreateSubmissionOperation, ID: "createSubmission", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, CreateSubmissionOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } request, close, err := s.decodeCreateSubmissionRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *ID if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: CreateSubmissionOperation, OperationSummary: "Create new submission", OperationID: "createSubmission", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *SubmissionCreate Params = struct{} Response = *ID ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.CreateSubmission(ctx, request) return response, err }, ) } else { response, err = s.h.CreateSubmission(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeCreateSubmissionResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleDeleteScriptRequest handles deleteScript operation. // // Delete the specified script by ID. // // DELETE /scripts/{ScriptID} func (s *Server) handleDeleteScriptRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("deleteScript"), semconv.HTTPRequestMethodKey.String("DELETE"), semconv.HTTPRouteKey.String("/scripts/{ScriptID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), DeleteScriptOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: DeleteScriptOperation, ID: "deleteScript", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, DeleteScriptOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeDeleteScriptParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *DeleteScriptNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: DeleteScriptOperation, OperationSummary: "Delete the specified script by ID", OperationID: "deleteScript", Body: nil, Params: middleware.Parameters{ { Name: "ScriptID", In: "path", }: params.ScriptID, }, Raw: r, } type ( Request = struct{} Params = DeleteScriptParams Response = *DeleteScriptNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackDeleteScriptParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.DeleteScript(ctx, params) return response, err }, ) } else { err = s.h.DeleteScript(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeDeleteScriptResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleDeleteScriptPolicyRequest handles deleteScriptPolicy operation. // // Delete the specified script policy by ID. // // DELETE /script-policy/id/{ScriptPolicyID} func (s *Server) handleDeleteScriptPolicyRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("deleteScriptPolicy"), semconv.HTTPRequestMethodKey.String("DELETE"), semconv.HTTPRouteKey.String("/script-policy/id/{ScriptPolicyID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), DeleteScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: DeleteScriptPolicyOperation, ID: "deleteScriptPolicy", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, DeleteScriptPolicyOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeDeleteScriptPolicyParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *DeleteScriptPolicyNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: DeleteScriptPolicyOperation, OperationSummary: "Delete the specified script policy by ID", OperationID: "deleteScriptPolicy", Body: nil, Params: middleware.Parameters{ { Name: "ScriptPolicyID", In: "path", }: params.ScriptPolicyID, }, Raw: r, } type ( Request = struct{} Params = DeleteScriptPolicyParams Response = *DeleteScriptPolicyNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackDeleteScriptPolicyParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.DeleteScriptPolicy(ctx, params) return response, err }, ) } else { err = s.h.DeleteScriptPolicy(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeDeleteScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleGetScriptRequest handles getScript operation. // // Get the specified script by ID. // // GET /scripts/{ScriptID} func (s *Server) handleGetScriptRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getScript"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/scripts/{ScriptID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), GetScriptOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: GetScriptOperation, ID: "getScript", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, GetScriptOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeGetScriptParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *Script if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: GetScriptOperation, OperationSummary: "Get the specified script by ID", OperationID: "getScript", Body: nil, Params: middleware.Parameters{ { Name: "ScriptID", In: "path", }: params.ScriptID, }, Raw: r, } type ( Request = struct{} Params = GetScriptParams Response = *Script ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackGetScriptParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.GetScript(ctx, params) return response, err }, ) } else { response, err = s.h.GetScript(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeGetScriptResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleGetScriptPolicyRequest handles getScriptPolicy operation. // // Get the specified script policy by ID. // // GET /script-policy/id/{ScriptPolicyID} func (s *Server) handleGetScriptPolicyRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getScriptPolicy"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/script-policy/id/{ScriptPolicyID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), GetScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: GetScriptPolicyOperation, ID: "getScriptPolicy", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, GetScriptPolicyOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeGetScriptPolicyParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ScriptPolicy if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: GetScriptPolicyOperation, OperationSummary: "Get the specified script policy by ID", OperationID: "getScriptPolicy", Body: nil, Params: middleware.Parameters{ { Name: "ScriptPolicyID", In: "path", }: params.ScriptPolicyID, }, Raw: r, } type ( Request = struct{} Params = GetScriptPolicyParams Response = *ScriptPolicy ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackGetScriptPolicyParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.GetScriptPolicy(ctx, params) return response, err }, ) } else { response, err = s.h.GetScriptPolicy(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeGetScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleGetScriptPolicyFromHashRequest handles getScriptPolicyFromHash operation. // // Get the policy for the given hash of script source code. // // GET /script-policy/hash/{FromScriptHash} func (s *Server) handleGetScriptPolicyFromHashRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getScriptPolicyFromHash"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/script-policy/hash/{FromScriptHash}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), GetScriptPolicyFromHashOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: GetScriptPolicyFromHashOperation, ID: "getScriptPolicyFromHash", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, GetScriptPolicyFromHashOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeGetScriptPolicyFromHashParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *ScriptPolicy if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: GetScriptPolicyFromHashOperation, OperationSummary: "Get the policy for the given hash of script source code", OperationID: "getScriptPolicyFromHash", Body: nil, Params: middleware.Parameters{ { Name: "FromScriptHash", In: "path", }: params.FromScriptHash, }, Raw: r, } type ( Request = struct{} Params = GetScriptPolicyFromHashParams Response = *ScriptPolicy ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackGetScriptPolicyFromHashParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.GetScriptPolicyFromHash(ctx, params) return response, err }, ) } else { response, err = s.h.GetScriptPolicyFromHash(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeGetScriptPolicyFromHashResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleGetSubmissionRequest handles getSubmission operation. // // Retrieve map with ID. // // GET /submissions/{SubmissionID} func (s *Server) handleGetSubmissionRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getSubmission"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), GetSubmissionOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: GetSubmissionOperation, ID: "getSubmission", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, GetSubmissionOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeGetSubmissionParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *Submission if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: GetSubmissionOperation, OperationSummary: "Retrieve map with ID", OperationID: "getSubmission", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = GetSubmissionParams Response = *Submission ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackGetSubmissionParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.GetSubmission(ctx, params) return response, err }, ) } else { response, err = s.h.GetSubmission(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeGetSubmissionResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleListScriptPolicyRequest handles listScriptPolicy operation. // // Get list of script policies. // // GET /script-policy func (s *Server) handleListScriptPolicyRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("listScriptPolicy"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/script-policy"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ListScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ListScriptPolicyOperation, ID: "listScriptPolicy", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ListScriptPolicyOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } request, close, err := s.decodeListScriptPolicyRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response []ScriptPolicy if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ListScriptPolicyOperation, OperationSummary: "Get list of script policies", OperationID: "listScriptPolicy", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *ListScriptPolicyReq Params = struct{} Response = []ScriptPolicy ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.ListScriptPolicy(ctx, request) return response, err }, ) } else { response, err = s.h.ListScriptPolicy(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeListScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleListSubmissionsRequest handles listSubmissions operation. // // Get list of submissions. // // GET /submissions func (s *Server) handleListSubmissionsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("listSubmissions"), semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/submissions"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), ListSubmissionsOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: ListSubmissionsOperation, ID: "listSubmissions", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, ListSubmissionsOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } request, close, err := s.decodeListSubmissionsRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response []Submission if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: ListSubmissionsOperation, OperationSummary: "Get list of submissions", OperationID: "listSubmissions", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( Request = *ListSubmissionsReq Params = struct{} Response = []Submission ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { response, err = s.h.ListSubmissions(ctx, request) return response, err }, ) } else { response, err = s.h.ListSubmissions(ctx, request) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeListSubmissionsResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleSetSubmissionCompletedRequest handles setSubmissionCompleted operation. // // Retrieve map with ID. // // POST /submissions/{SubmissionID}/completed func (s *Server) handleSetSubmissionCompletedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("setSubmissionCompleted"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/completed"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), SetSubmissionCompletedOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: SetSubmissionCompletedOperation, ID: "setSubmissionCompleted", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, SetSubmissionCompletedOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeSetSubmissionCompletedParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *SetSubmissionCompletedNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: SetSubmissionCompletedOperation, OperationSummary: "Retrieve map with ID", OperationID: "setSubmissionCompleted", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, }, Raw: r, } type ( Request = struct{} Params = SetSubmissionCompletedParams Response = *SetSubmissionCompletedNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackSetSubmissionCompletedParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.SetSubmissionCompleted(ctx, params) return response, err }, ) } else { err = s.h.SetSubmissionCompleted(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeSetSubmissionCompletedResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleUpdateScriptRequest handles updateScript operation. // // Update the specified script by ID. // // POST /scripts/{ScriptID} func (s *Server) handleUpdateScriptRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("updateScript"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/scripts/{ScriptID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), UpdateScriptOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: UpdateScriptOperation, ID: "updateScript", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, UpdateScriptOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeUpdateScriptParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } request, close, err := s.decodeUpdateScriptRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *UpdateScriptNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: UpdateScriptOperation, OperationSummary: "Update the specified script by ID", OperationID: "updateScript", Body: request, Params: middleware.Parameters{ { Name: "ScriptID", In: "path", }: params.ScriptID, }, Raw: r, } type ( Request = *ScriptUpdate Params = UpdateScriptParams Response = *UpdateScriptNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackUpdateScriptParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.UpdateScript(ctx, request, params) return response, err }, ) } else { err = s.h.UpdateScript(ctx, request, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeUpdateScriptResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleUpdateScriptPolicyRequest handles updateScriptPolicy operation. // // Update the specified script policy by ID. // // POST /script-policy/id/{ScriptPolicyID} func (s *Server) handleUpdateScriptPolicyRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("updateScriptPolicy"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/script-policy/id/{ScriptPolicyID}"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), UpdateScriptPolicyOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: UpdateScriptPolicyOperation, ID: "updateScriptPolicy", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, UpdateScriptPolicyOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeUpdateScriptPolicyParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } request, close, err := s.decodeUpdateScriptPolicyRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeRequest", err) s.cfg.ErrorHandler(ctx, w, r, err) return } defer func() { if err := close(); err != nil { recordError("CloseRequest", err) } }() var response *UpdateScriptPolicyNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: UpdateScriptPolicyOperation, OperationSummary: "Update the specified script policy by ID", OperationID: "updateScriptPolicy", Body: request, Params: middleware.Parameters{ { Name: "ScriptPolicyID", In: "path", }: params.ScriptPolicyID, }, Raw: r, } type ( Request = *ScriptPolicyUpdate Params = UpdateScriptPolicyParams Response = *UpdateScriptPolicyNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackUpdateScriptPolicyParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.UpdateScriptPolicy(ctx, request, params) return response, err }, ) } else { err = s.h.UpdateScriptPolicy(ctx, request, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeUpdateScriptPolicyResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } } // handleUpdateSubmissionModelRequest handles updateSubmissionModel operation. // // Update model following role restrictions. // // POST /submissions/{SubmissionID}/model func (s *Server) handleUpdateSubmissionModelRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("updateSubmissionModel"), semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/model"), } // Start a span for this request. ctx, span := s.cfg.Tracer.Start(r.Context(), UpdateSubmissionModelOperation, trace.WithAttributes(otelAttrs...), serverSpanKind, ) defer span.End() // Add Labeler to context. labeler := &Labeler{attrs: otelAttrs} ctx = contextWithLabeler(ctx, labeler) // Run stopwatch. startTime := time.Now() defer func() { elapsedDuration := time.Since(startTime) attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() code := statusWriter.status if code != 0 { codeAttr := semconv.HTTPResponseStatusCode(code) attrs = append(attrs, codeAttr) span.SetAttributes(codeAttr) } attrOpt := metric.WithAttributes(attrs...) // Increment request counter. s.requests.Add(ctx, 1, attrOpt) // Use floating point division here for higher precision (instead of Millisecond method). s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) }() var ( recordError = func(stage string, err error) { span.RecordError(err) // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, // unless there was another error (e.g., network error receiving the response body; or 3xx codes with // max redirects exceeded), in which case status MUST be set to Error. code := statusWriter.status if code >= 100 && code < 500 { span.SetStatus(codes.Error, stage) } attrSet := labeler.AttributeSet() attrs := attrSet.ToSlice() if code != 0 { attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) } s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) } err error opErrContext = ogenerrors.OperationContext{ Name: UpdateSubmissionModelOperation, ID: "updateSubmissionModel", } ) { type bitset = [1]uint8 var satisfied bitset { sctx, ok, err := s.securityCookieAuth(ctx, UpdateSubmissionModelOperation, r) if err != nil { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Security: "CookieAuth", Err: err, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security:CookieAuth", err) } return } if ok { satisfied[0] |= 1 << 0 ctx = sctx } } if ok := func() bool { nextRequirement: for _, requirement := range []bitset{ {0b00000001}, } { for i, mask := range requirement { if satisfied[i]&mask != mask { continue nextRequirement } } return true } return false }(); !ok { err = &ogenerrors.SecurityError{ OperationContext: opErrContext, Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, } if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { defer recordError("Security", err) } return } } params, err := decodeUpdateSubmissionModelParams(args, argsEscaped, r) if err != nil { err = &ogenerrors.DecodeParamsError{ OperationContext: opErrContext, Err: err, } defer recordError("DecodeParams", err) s.cfg.ErrorHandler(ctx, w, r, err) return } var response *UpdateSubmissionModelNoContent if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: UpdateSubmissionModelOperation, OperationSummary: "Update model following role restrictions", OperationID: "updateSubmissionModel", Body: nil, Params: middleware.Parameters{ { Name: "SubmissionID", In: "path", }: params.SubmissionID, { Name: "ModelID", In: "query", }: params.ModelID, { Name: "VersionID", In: "query", }: params.VersionID, }, Raw: r, } type ( Request = struct{} Params = UpdateSubmissionModelParams Response = *UpdateSubmissionModelNoContent ) response, err = middleware.HookMiddleware[ Request, Params, Response, ]( m, mreq, unpackUpdateSubmissionModelParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { err = s.h.UpdateSubmissionModel(ctx, params) return response, err }, ) } else { err = s.h.UpdateSubmissionModel(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { if err := encodeErrorResponse(errRes, w, span); err != nil { defer recordError("Internal", err) } return } if errors.Is(err, ht.ErrNotImplemented) { s.cfg.ErrorHandler(ctx, w, r, err) return } if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { defer recordError("Internal", err) } return } if err := encodeUpdateSubmissionModelResponse(response, w, span); err != nil { defer recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) } return } }