mirror of
https://github.com/ceph/ceph-csi.git
synced 2024-10-19 21:59:54 +00:00
91774fc936
Uses github.com/libopenstorage/secrets to communicate with Vault. This removes the need for maintaining our own limited Vault APIs. By adding the new dependency, several other packages got updated in the process. Unused indirect dependencies have been removed from go.mod. Signed-off-by: Niels de Vos <ndevos@redhat.com>
93 lines
3.1 KiB
Go
93 lines
3.1 KiB
Go
// Copyright 2019 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package impl
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"hash/crc32"
|
|
"math"
|
|
"reflect"
|
|
|
|
"google.golang.org/protobuf/internal/errors"
|
|
pref "google.golang.org/protobuf/reflect/protoreflect"
|
|
piface "google.golang.org/protobuf/runtime/protoiface"
|
|
)
|
|
|
|
// These functions exist to support exported APIs in generated protobufs.
|
|
// While these are deprecated, they cannot be removed for compatibility reasons.
|
|
|
|
// LegacyEnumName returns the name of enums used in legacy code.
|
|
func (Export) LegacyEnumName(ed pref.EnumDescriptor) string {
|
|
return legacyEnumName(ed)
|
|
}
|
|
|
|
// LegacyMessageTypeOf returns the protoreflect.MessageType for m,
|
|
// with name used as the message name if necessary.
|
|
func (Export) LegacyMessageTypeOf(m piface.MessageV1, name pref.FullName) pref.MessageType {
|
|
if mv := (Export{}).protoMessageV2Of(m); mv != nil {
|
|
return mv.ProtoReflect().Type()
|
|
}
|
|
return legacyLoadMessageInfo(reflect.TypeOf(m), name)
|
|
}
|
|
|
|
// UnmarshalJSONEnum unmarshals an enum from a JSON-encoded input.
|
|
// The input can either be a string representing the enum value by name,
|
|
// or a number representing the enum number itself.
|
|
func (Export) UnmarshalJSONEnum(ed pref.EnumDescriptor, b []byte) (pref.EnumNumber, error) {
|
|
if b[0] == '"' {
|
|
var name pref.Name
|
|
if err := json.Unmarshal(b, &name); err != nil {
|
|
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
|
|
}
|
|
ev := ed.Values().ByName(name)
|
|
if ev == nil {
|
|
return 0, errors.New("invalid value for enum %v: %s", ed.FullName(), name)
|
|
}
|
|
return ev.Number(), nil
|
|
} else {
|
|
var num pref.EnumNumber
|
|
if err := json.Unmarshal(b, &num); err != nil {
|
|
return 0, errors.New("invalid input for enum %v: %s", ed.FullName(), b)
|
|
}
|
|
return num, nil
|
|
}
|
|
}
|
|
|
|
// CompressGZIP compresses the input as a GZIP-encoded file.
|
|
// The current implementation does no compression.
|
|
func (Export) CompressGZIP(in []byte) (out []byte) {
|
|
// RFC 1952, section 2.3.1.
|
|
var gzipHeader = [10]byte{0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff}
|
|
|
|
// RFC 1951, section 3.2.4.
|
|
var blockHeader [5]byte
|
|
const maxBlockSize = math.MaxUint16
|
|
numBlocks := 1 + len(in)/maxBlockSize
|
|
|
|
// RFC 1952, section 2.3.1.
|
|
var gzipFooter [8]byte
|
|
binary.LittleEndian.PutUint32(gzipFooter[0:4], crc32.ChecksumIEEE(in))
|
|
binary.LittleEndian.PutUint32(gzipFooter[4:8], uint32(len(in)))
|
|
|
|
// Encode the input without compression using raw DEFLATE blocks.
|
|
out = make([]byte, 0, len(gzipHeader)+len(blockHeader)*numBlocks+len(in)+len(gzipFooter))
|
|
out = append(out, gzipHeader[:]...)
|
|
for blockHeader[0] == 0 {
|
|
blockSize := maxBlockSize
|
|
if blockSize > len(in) {
|
|
blockHeader[0] = 0x01 // final bit per RFC 1951, section 3.2.3.
|
|
blockSize = len(in)
|
|
}
|
|
binary.LittleEndian.PutUint16(blockHeader[1:3], uint16(blockSize)^0x0000)
|
|
binary.LittleEndian.PutUint16(blockHeader[3:5], uint16(blockSize)^0xffff)
|
|
out = append(out, blockHeader[:]...)
|
|
out = append(out, in[:blockSize]...)
|
|
in = in[blockSize:]
|
|
}
|
|
out = append(out, gzipFooter[:]...)
|
|
return out
|
|
}
|