Integrate BACKBEAT SDK and resolve KACHING license validation

Major integrations and fixes: - Added BACKBEAT SDK integration for P2P operation timing - Implemented beat-aware status tracking for distributed operations - Added Docker secrets support for secure license management - Resolved KACHING license validation via HTTPS/TLS - Updated docker-compose configuration for clean stack deployment - Disabled rollback policies to prevent deployment failures - Added license credential storage (CHORUS-DEV-MULTI-001) Technical improvements: - BACKBEAT P2P operation tracking with phase management - Enhanced configuration system with file-based secrets - Improved error handling for license validation - Clean separation of KACHING and CHORUS deployment stacks 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
2025-09-06 07:56:26 +10:00
parent 543ab216f9
commit 9bdcbe0447
4730 changed files with 1480093 additions and 1916 deletions
--- a/vendor/github.com/polydawn/refmt/cbor/cborEncoder.go
+++ b/vendor/github.com/polydawn/refmt/cbor/cborEncoder.go
@@ -0,0 +1,276 @@
+package cbor
+
+import (
+	"io"
+
+	. "github.com/polydawn/refmt/tok"
+)
+
+type Encoder struct {
+	w quickWriter
+
+	stack   []encoderPhase // When empty, and step returns done, all done.
+	current encoderPhase   // Shortcut to end of stack.
+	// Note unlike decoder, we need no statekeeping space for definite-len map and array.
+
+	spareBytes []byte
+}
+
+func NewEncoder(w io.Writer) (d *Encoder) {
+	d = &Encoder{
+		w:          newQuickWriterStream(w),
+		stack:      make([]encoderPhase, 0, 10),
+		current:    phase_anyExpectValue,
+		spareBytes: make([]byte, 8),
+	}
+	return
+}
+
+func (d *Encoder) Reset() {
+	d.stack = d.stack[0:0]
+	d.current = phase_anyExpectValue
+}
+
+type encoderPhase byte
+
+// There's about twice as many phases that the cbor encoder can be in compared to the json encoder
+// because the presense of indefinite vs definite length maps and arrays effectively adds a dimension to those.
+const (
+	phase_anyExpectValue           encoderPhase = iota
+	phase_mapDefExpectKeyOrEnd                  // must not yield break at end
+	phase_mapDefExpectValue                     // only necessary to flip back to DefExpectKey
+	phase_mapIndefExpectKeyOrEnd                // must yield break at end
+	phase_mapIndefExpectValue                   // only necessary to flip back to IndefExpectKey
+	phase_arrDefExpectValueOrEnd                // must not yield break at end
+	phase_arrIndefExpectValueOrEnd              // must yield break at end
+)
+
+func (d *Encoder) pushPhase(p encoderPhase) {
+	d.current = p
+	d.stack = append(d.stack, d.current)
+}
+
+// Pop a phase from the stack; return 'true' if stack now empty.
+func (d *Encoder) popPhase() bool {
+	n := len(d.stack) - 1
+	if n == 0 {
+		return true
+	}
+	if n < 0 { // the state machines are supposed to have already errored better
+		panic("cborEncoder stack overpopped")
+	}
+	d.current = d.stack[n-1]
+	d.stack = d.stack[0:n]
+	return false
+}
+
+func (d *Encoder) Step(tokenSlot *Token) (done bool, err error) {
+	/*
+		Though it reads somewhat backwards from how a human would probably intuit
+		cause and effect, switching on the token type we got first,
+		*then* switching for whether it is acceptable for our current phase... is by
+		far the shorter volume of code to write.
+	*/
+	phase := d.current
+	switch tokenSlot.Type {
+	case TMapOpen:
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			if tokenSlot.Length >= 0 {
+				d.pushPhase(phase_mapDefExpectKeyOrEnd)
+				d.emitMajorPlusLen(cborMajorMap, uint64(tokenSlot.Length))
+			} else {
+				d.pushPhase(phase_mapIndefExpectKeyOrEnd)
+				d.w.writen1(cborSigilIndefiniteMap)
+			}
+			return false, d.w.checkErr()
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	case TMapClose:
+		switch phase {
+		case phase_mapDefExpectKeyOrEnd:
+			return d.popPhase(), nil
+		case phase_mapIndefExpectKeyOrEnd:
+			d.w.writen1(cborSigilBreak)
+			return d.popPhase(), d.w.checkErr()
+		case phase_anyExpectValue, phase_mapDefExpectValue, phase_mapIndefExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForValue}
+		default:
+			panic("unreachable phase")
+		}
+	case TArrOpen:
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			if tokenSlot.Length >= 0 {
+				d.pushPhase(phase_arrDefExpectValueOrEnd)
+				d.emitMajorPlusLen(cborMajorArray, uint64(tokenSlot.Length))
+			} else {
+				d.pushPhase(phase_arrIndefExpectValueOrEnd)
+				d.w.writen1(cborSigilIndefiniteArray)
+			}
+			return false, d.w.checkErr()
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	case TArrClose:
+		switch phase {
+		case phase_arrDefExpectValueOrEnd:
+			return d.popPhase(), nil
+		case phase_arrIndefExpectValueOrEnd:
+			d.w.writen1(cborSigilBreak)
+			return d.popPhase(), d.w.checkErr()
+		case phase_anyExpectValue, phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForValue}
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	case TNull: // terminal value; not accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.w.writen1(cborSigilNil)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	case TString: // terminal value; YES, accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			goto emitStr
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			d.current += 1
+			goto emitStr
+		default:
+			panic("unreachable phase")
+		}
+	emitStr:
+		{
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.encodeString(tokenSlot.Str)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		}
+	case TBytes: // terminal value; not accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.encodeBytes(tokenSlot.Bytes)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	case TBool: // terminal value; not accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.encodeBool(tokenSlot.Bool)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	case TInt: // terminal value; YES, accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			goto emitInt
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			d.current += 1
+			goto emitInt
+		default:
+			panic("unreachable phase")
+		}
+	emitInt:
+		{
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.encodeInt64(tokenSlot.Int)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		}
+	case TUint: // terminal value; YES, accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			goto emitUint
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			d.current += 1
+			goto emitUint
+		default:
+			panic("unreachable phase")
+		}
+	emitUint:
+		{
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.encodeUint64(tokenSlot.Uint)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		}
+	case TFloat64: // terminal value; not accepted as map key.
+		switch phase {
+		case phase_mapDefExpectValue, phase_mapIndefExpectValue:
+			d.current -= 1
+			fallthrough
+		case phase_anyExpectValue, phase_arrDefExpectValueOrEnd, phase_arrIndefExpectValueOrEnd:
+			if tokenSlot.Tagged {
+				d.emitMajorPlusLen(cborMajorTag, uint64(tokenSlot.Tag))
+			}
+			d.encodeFloat64(tokenSlot.Float64)
+			return phase == phase_anyExpectValue, d.w.checkErr()
+		case phase_mapDefExpectKeyOrEnd, phase_mapIndefExpectKeyOrEnd:
+			return true, &ErrInvalidTokenStream{Got: *tokenSlot, Acceptable: tokenTypesForKey}
+		default:
+			panic("unreachable phase")
+		}
+	default:
+		panic("unhandled token type")
+	}
+}