mirror of
https://github.com/gofiber/fiber.git
synced 2025-05-17 13:09:46 +00:00
58677d5c86
* Add Drop method to DefaultCtx and remove redundant checks Introduced a Drop method in DefaultCtx for closing connections, enabling easier resource management. Removed unnecessary nil-checks for headers in manager_msgp to simplify code logic. Added a unit test to ensure the new Drop method behaves as expected. * Add `Drop` method to Fiber context API documentation The `Drop` method allows silently terminating client connections without sending HTTP headers or a response body. This is useful for scenarios like mitigating DDoS attacks or blocking unauthorized access to sensitive endpoints. Example usage and function signature are included in the updated documentation. * Remove extraneous blank line in documentation. Eliminated an unnecessary blank line in the API context documentation for improved readability and formatting consistency. No functional changes were made to the content. * Update API documentation example to return "Hello World!" Revised the example code in the API documentation to return a generic "Hello World!" string instead of a dynamic response. This improves consistency and simplifies the example for easier understanding. * Refactor Drop method and extend test coverage. Simplified the Drop method by inlining the connection close call. Added new test cases to ensure proper handling of no-response scenarios and improved overall test coverage. * fix golangci-lint issue * Add test for Ctx.Drop with middleware interaction This test ensures the correct behavior of the Ctx.Drop method when used with middleware, including response handling and error scenarios. It verifies that the middleware and handler properly handle the Drop call and its resulting effects. * Add Drop method to DefaultCtx for closing connections The Drop method allows closing connections without sending a response, improving control over connection handling. Also updated a test assertion to use StatusOK for improved readability and consistency. * Refine Drop method comments to clarify error handling. Explain the rationale for not wrapping errors in the Drop method. Emphasize that the returned error is solely for logging and not for further propagation or processing. * Update Drop method documentation for clarity Clarified the `Drop` method's behavior, specifying that it closes the connection without sending headers or a body. Added examples of use cases, such as DDoS mitigation and blocking sensitive endpoints. * Refactor response header setting in middleware. Replaced the direct header setting with the `Set` method for consistency and improved clarity. Removed a test case checking for a panic on closed response body as it is no longer applicable.
332 lines
7.5 KiB
Go
332 lines
7.5 KiB
Go
package cache
|
|
|
|
// Code generated by github.com/tinylib/msgp DO NOT EDIT.
|
|
|
|
import (
|
|
"github.com/tinylib/msgp/msgp"
|
|
)
|
|
|
|
// DecodeMsg implements msgp.Decodable
|
|
func (z *item) DecodeMsg(dc *msgp.Reader) (err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zb0001 uint32
|
|
zb0001, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
err = msgp.WrapError(err)
|
|
return
|
|
}
|
|
for zb0001 > 0 {
|
|
zb0001--
|
|
field, err = dc.ReadMapKeyPtr()
|
|
if err != nil {
|
|
err = msgp.WrapError(err)
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "headers":
|
|
var zb0002 uint32
|
|
zb0002, err = dc.ReadMapHeader()
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers")
|
|
return
|
|
}
|
|
if z.headers == nil {
|
|
z.headers = make(map[string][]byte, zb0002)
|
|
} else if len(z.headers) > 0 {
|
|
for key := range z.headers {
|
|
delete(z.headers, key)
|
|
}
|
|
}
|
|
for zb0002 > 0 {
|
|
zb0002--
|
|
var za0001 string
|
|
var za0002 []byte
|
|
za0001, err = dc.ReadString()
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers")
|
|
return
|
|
}
|
|
za0002, err = dc.ReadBytes(za0002)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers", za0001)
|
|
return
|
|
}
|
|
z.headers[za0001] = za0002
|
|
}
|
|
case "body":
|
|
z.body, err = dc.ReadBytes(z.body)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "body")
|
|
return
|
|
}
|
|
case "ctype":
|
|
z.ctype, err = dc.ReadBytes(z.ctype)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "ctype")
|
|
return
|
|
}
|
|
case "cencoding":
|
|
z.cencoding, err = dc.ReadBytes(z.cencoding)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "cencoding")
|
|
return
|
|
}
|
|
case "status":
|
|
z.status, err = dc.ReadInt()
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "status")
|
|
return
|
|
}
|
|
case "exp":
|
|
z.exp, err = dc.ReadUint64()
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "exp")
|
|
return
|
|
}
|
|
case "heapidx":
|
|
z.heapidx, err = dc.ReadInt()
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "heapidx")
|
|
return
|
|
}
|
|
default:
|
|
err = dc.Skip()
|
|
if err != nil {
|
|
err = msgp.WrapError(err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// EncodeMsg implements msgp.Encodable
|
|
func (z *item) EncodeMsg(en *msgp.Writer) (err error) {
|
|
// map header, size 7
|
|
// write "headers"
|
|
err = en.Append(0x87, 0xa7, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteMapHeader(uint32(len(z.headers)))
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers")
|
|
return
|
|
}
|
|
for za0001, za0002 := range z.headers {
|
|
err = en.WriteString(za0001)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers")
|
|
return
|
|
}
|
|
err = en.WriteBytes(za0002)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers", za0001)
|
|
return
|
|
}
|
|
}
|
|
// write "body"
|
|
err = en.Append(0xa4, 0x62, 0x6f, 0x64, 0x79)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteBytes(z.body)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "body")
|
|
return
|
|
}
|
|
// write "ctype"
|
|
err = en.Append(0xa5, 0x63, 0x74, 0x79, 0x70, 0x65)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteBytes(z.ctype)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "ctype")
|
|
return
|
|
}
|
|
// write "cencoding"
|
|
err = en.Append(0xa9, 0x63, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteBytes(z.cencoding)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "cencoding")
|
|
return
|
|
}
|
|
// write "status"
|
|
err = en.Append(0xa6, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteInt(z.status)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "status")
|
|
return
|
|
}
|
|
// write "exp"
|
|
err = en.Append(0xa3, 0x65, 0x78, 0x70)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteUint64(z.exp)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "exp")
|
|
return
|
|
}
|
|
// write "heapidx"
|
|
err = en.Append(0xa7, 0x68, 0x65, 0x61, 0x70, 0x69, 0x64, 0x78)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = en.WriteInt(z.heapidx)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "heapidx")
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// MarshalMsg implements msgp.Marshaler
|
|
func (z *item) MarshalMsg(b []byte) (o []byte, err error) {
|
|
o = msgp.Require(b, z.Msgsize())
|
|
// map header, size 7
|
|
// string "headers"
|
|
o = append(o, 0x87, 0xa7, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73)
|
|
o = msgp.AppendMapHeader(o, uint32(len(z.headers)))
|
|
for za0001, za0002 := range z.headers {
|
|
o = msgp.AppendString(o, za0001)
|
|
o = msgp.AppendBytes(o, za0002)
|
|
}
|
|
// string "body"
|
|
o = append(o, 0xa4, 0x62, 0x6f, 0x64, 0x79)
|
|
o = msgp.AppendBytes(o, z.body)
|
|
// string "ctype"
|
|
o = append(o, 0xa5, 0x63, 0x74, 0x79, 0x70, 0x65)
|
|
o = msgp.AppendBytes(o, z.ctype)
|
|
// string "cencoding"
|
|
o = append(o, 0xa9, 0x63, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67)
|
|
o = msgp.AppendBytes(o, z.cencoding)
|
|
// string "status"
|
|
o = append(o, 0xa6, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73)
|
|
o = msgp.AppendInt(o, z.status)
|
|
// string "exp"
|
|
o = append(o, 0xa3, 0x65, 0x78, 0x70)
|
|
o = msgp.AppendUint64(o, z.exp)
|
|
// string "heapidx"
|
|
o = append(o, 0xa7, 0x68, 0x65, 0x61, 0x70, 0x69, 0x64, 0x78)
|
|
o = msgp.AppendInt(o, z.heapidx)
|
|
return
|
|
}
|
|
|
|
// UnmarshalMsg implements msgp.Unmarshaler
|
|
func (z *item) UnmarshalMsg(bts []byte) (o []byte, err error) {
|
|
var field []byte
|
|
_ = field
|
|
var zb0001 uint32
|
|
zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err)
|
|
return
|
|
}
|
|
for zb0001 > 0 {
|
|
zb0001--
|
|
field, bts, err = msgp.ReadMapKeyZC(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err)
|
|
return
|
|
}
|
|
switch msgp.UnsafeString(field) {
|
|
case "headers":
|
|
var zb0002 uint32
|
|
zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers")
|
|
return
|
|
}
|
|
if z.headers == nil {
|
|
z.headers = make(map[string][]byte, zb0002)
|
|
} else if len(z.headers) > 0 {
|
|
for key := range z.headers {
|
|
delete(z.headers, key)
|
|
}
|
|
}
|
|
for zb0002 > 0 {
|
|
var za0001 string
|
|
var za0002 []byte
|
|
zb0002--
|
|
za0001, bts, err = msgp.ReadStringBytes(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers")
|
|
return
|
|
}
|
|
za0002, bts, err = msgp.ReadBytesBytes(bts, za0002)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "headers", za0001)
|
|
return
|
|
}
|
|
z.headers[za0001] = za0002
|
|
}
|
|
case "body":
|
|
z.body, bts, err = msgp.ReadBytesBytes(bts, z.body)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "body")
|
|
return
|
|
}
|
|
case "ctype":
|
|
z.ctype, bts, err = msgp.ReadBytesBytes(bts, z.ctype)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "ctype")
|
|
return
|
|
}
|
|
case "cencoding":
|
|
z.cencoding, bts, err = msgp.ReadBytesBytes(bts, z.cencoding)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "cencoding")
|
|
return
|
|
}
|
|
case "status":
|
|
z.status, bts, err = msgp.ReadIntBytes(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "status")
|
|
return
|
|
}
|
|
case "exp":
|
|
z.exp, bts, err = msgp.ReadUint64Bytes(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "exp")
|
|
return
|
|
}
|
|
case "heapidx":
|
|
z.heapidx, bts, err = msgp.ReadIntBytes(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err, "heapidx")
|
|
return
|
|
}
|
|
default:
|
|
bts, err = msgp.Skip(bts)
|
|
if err != nil {
|
|
err = msgp.WrapError(err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
o = bts
|
|
return
|
|
}
|
|
|
|
// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
|
|
func (z *item) Msgsize() (s int) {
|
|
s = 1 + 8 + msgp.MapHeaderSize
|
|
if z.headers != nil {
|
|
for za0001, za0002 := range z.headers {
|
|
_ = za0002
|
|
s += msgp.StringPrefixSize + len(za0001) + msgp.BytesPrefixSize + len(za0002)
|
|
}
|
|
}
|
|
s += 5 + msgp.BytesPrefixSize + len(z.body) + 6 + msgp.BytesPrefixSize + len(z.ctype) + 10 + msgp.BytesPrefixSize + len(z.cencoding) + 7 + msgp.IntSize + 4 + msgp.Uint64Size + 8 + msgp.IntSize
|
|
return
|
|
}
|