unkin-agent
9da206dc7c
PVCs and CloudNativePG Clusters need S3 buckets and backup schedules
provisioned consistently. This operator watches the
backups.unkin.net/{schedule,destination} annotations on those objects and
provisions everything needed to back them up, with no new CRDs.
- Add a PVC controller that provisions cephrgw ObjectStoreUser/Bucket/BucketAccess,
auto-generates a restic repo-password Secret and creates a k8up Schedule scoped
to the PVC via spec.backup.volumes[].persistentVolumeClaim.claimName.
- Add a CNPG Cluster controller that provisions the same bucket stack, idempotently
patches spec.backup.barmanObjectStore (leaving a user-set destinationPath alone
with a Warning event) and creates a ScheduledBackup.
- Resolve destinations through a ConfigMap lookup table; requeue until the
BucketAccess is Ready before creating schedule resources; own-reference created
resources and retain bucket data by default.
- Add schedule-mapping helpers (k8up 5-field/shortcut pass-through, CNPG 6-field
seconds-first) and deterministic, length-bounded name derivation.
- Add unit tests (schedule mapping, name derivation, destination resolution) and
envtest controller tests for both paths, wiring the external CRDs into envtest.
- Add kubebuilder-generated RBAC, a Dockerfile (distroless/nonroot), Woodpecker
lint/test/build pipelines and a tag-triggered image push to the artifactapi
docker-internal registry, plus a version-bump Makefile and deploy manifests.
99 lines
3.4 KiB
Go
99 lines
3.4 KiB
Go
// Copyright (c) Faye Amacker. All rights reserved.
|
|
// Licensed under the MIT License. See LICENSE in the project root for license information.
|
|
|
|
package cbor
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
)
|
|
|
|
// SimpleValue represents CBOR simple value.
|
|
// CBOR simple value is:
|
|
// - an extension point like CBOR tag.
|
|
// - a subset of CBOR major type 7 that isn't floating-point.
|
|
// - "identified by a number between 0 and 255, but distinct from that number itself".
|
|
// For example, "a simple value 2 is not equivalent to an integer 2" as a CBOR map key.
|
|
//
|
|
// CBOR simple values identified by 20..23 are: "false", "true" , "null", and "undefined".
|
|
// Other CBOR simple values are currently unassigned/reserved by IANA.
|
|
type SimpleValue uint8
|
|
|
|
var (
|
|
typeSimpleValue = reflect.TypeOf(SimpleValue(0))
|
|
)
|
|
|
|
// MarshalCBOR encodes SimpleValue as CBOR simple value (major type 7).
|
|
func (sv SimpleValue) MarshalCBOR() ([]byte, error) {
|
|
// RFC 8949 3.3. Floating-Point Numbers and Values with No Content says:
|
|
// "An encoder MUST NOT issue two-byte sequences that start with 0xf8
|
|
// (major type 7, additional information 24) and continue with a byte
|
|
// less than 0x20 (32 decimal). Such sequences are not well-formed.
|
|
// (This implies that an encoder cannot encode false, true, null, or
|
|
// undefined in two-byte sequences and that only the one-byte variants
|
|
// of these are well-formed; more generally speaking, each simple value
|
|
// only has a single representation variant)."
|
|
|
|
switch {
|
|
case sv <= maxSimpleValueInAdditionalInformation:
|
|
return []byte{byte(cborTypePrimitives) | byte(sv)}, nil
|
|
|
|
case sv >= minSimpleValueIn1ByteArgument:
|
|
return []byte{byte(cborTypePrimitives) | additionalInformationWith1ByteArgument, byte(sv)}, nil
|
|
|
|
default:
|
|
return nil, &UnsupportedValueError{msg: fmt.Sprintf("SimpleValue(%d)", sv)}
|
|
}
|
|
}
|
|
|
|
// UnmarshalCBOR decodes CBOR simple value (major type 7) to SimpleValue.
|
|
//
|
|
// Deprecated: No longer used by this codec; kept for compatibility
|
|
// with user apps that directly call this function.
|
|
func (sv *SimpleValue) UnmarshalCBOR(data []byte) error {
|
|
if sv == nil {
|
|
return errors.New("cbor.SimpleValue: UnmarshalCBOR on nil pointer")
|
|
}
|
|
|
|
d := decoder{data: data, dm: defaultDecMode}
|
|
|
|
// Check well-formedness of CBOR data item.
|
|
// SimpleValue.UnmarshalCBOR() is exported, so
|
|
// the codec needs to support same behavior for:
|
|
// - Unmarshal(data, *SimpleValue)
|
|
// - SimpleValue.UnmarshalCBOR(data)
|
|
err := d.wellformed(false, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return sv.unmarshalCBOR(data)
|
|
}
|
|
|
|
// unmarshalCBOR decodes CBOR simple value (major type 7) to SimpleValue.
|
|
// This function assumes data is well-formed, and does not perform bounds checking.
|
|
// This function is called by Unmarshal().
|
|
func (sv *SimpleValue) unmarshalCBOR(data []byte) error {
|
|
if sv == nil {
|
|
return errors.New("cbor.SimpleValue: UnmarshalCBOR on nil pointer")
|
|
}
|
|
|
|
d := decoder{data: data, dm: defaultDecMode}
|
|
|
|
typ, ai, val := d.getHead()
|
|
|
|
if typ != cborTypePrimitives {
|
|
return &UnmarshalTypeError{CBORType: typ.String(), GoType: "SimpleValue"}
|
|
}
|
|
if ai > additionalInformationWith1ByteArgument {
|
|
return &UnmarshalTypeError{CBORType: typ.String(), GoType: "SimpleValue", errorMsg: "not simple values"}
|
|
}
|
|
|
|
// It is safe to cast val to uint8 here because
|
|
// - data is already verified to be well-formed CBOR simple value and
|
|
// - val is <= math.MaxUint8.
|
|
*sv = SimpleValue(val)
|
|
return nil
|
|
}
|