Spaces:
Running
Running
File size: 4,912 Bytes
b110593 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 |
// _ _
// __ _____ __ ___ ___ __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
// \ V V / __/ (_| |\ V /| | (_| | || __/
// \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
// Copyright © 2016 - 2024 Weaviate B.V. All rights reserved.
//
// CONTACT: [email protected]
//
package objects
import (
"encoding/json"
"fmt"
"github.com/go-openapi/strfmt"
"github.com/weaviate/weaviate/entities/models"
"github.com/weaviate/weaviate/entities/storobj"
)
// VObject is a versioned object for detecting replication inconsistencies
type VObject struct {
// LatestObject is to most up-to-date version of an object
LatestObject *models.Object `json:"object,omitempty"`
Vector []float32 `json:"vector"`
// StaleUpdateTime is the LastUpdateTimeUnix of the stale object sent to the coordinator
StaleUpdateTime int64 `json:"updateTime,omitempty"`
// Version is the most recent incremental version number of the object
Version uint64 `json:"version"`
}
// vobjectMarshaler is a helper for the methods implementing encoding.BinaryMarshaler
//
// Because models.Object has an optimized custom MarshalBinary method, that is what
// we want to use when serializing, rather than json.Marshal. This is just a thin
// wrapper around the model bytes resulting from the underlying call to MarshalBinary
type vobjectMarshaler struct {
StaleUpdateTime int64
Version uint64
Vector []float32
LatestObject []byte
}
func (vo *VObject) MarshalBinary() ([]byte, error) {
b := vobjectMarshaler{
StaleUpdateTime: vo.StaleUpdateTime,
Vector: vo.Vector,
Version: vo.Version,
}
if vo.LatestObject != nil {
obj, err := vo.LatestObject.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("marshal object: %w", err)
}
b.LatestObject = obj
}
return json.Marshal(b)
}
func (vo *VObject) UnmarshalBinary(data []byte) error {
var b vobjectMarshaler
err := json.Unmarshal(data, &b)
if err != nil {
return err
}
vo.StaleUpdateTime = b.StaleUpdateTime
vo.Vector = b.Vector
vo.Version = b.Version
if b.LatestObject != nil {
var obj models.Object
err = obj.UnmarshalBinary(b.LatestObject)
if err != nil {
return fmt.Errorf("unmarshal object: %w", err)
}
vo.LatestObject = &obj
}
return nil
}
// Replica represents a replicated data item
type Replica struct {
ID strfmt.UUID `json:"id,omitempty"`
Deleted bool `json:"deleted"`
Object *storobj.Object `json:"object,omitempty"`
}
// robjectMarshaler is a helper for the methods implementing encoding.BinaryMarshaler
//
// Because *storobj.Object has an optimized custom MarshalBinary method, that is what
// we want to use when serializing, rather than json.Marshal. This is just a thin
// wrapper around the storobj bytes resulting from the underlying call to MarshalBinary
type robjectMarshaler struct {
ID strfmt.UUID
Deleted bool
Object []byte
}
func (r *Replica) MarshalBinary() ([]byte, error) {
b := robjectMarshaler{ID: r.ID, Deleted: r.Deleted}
if r.Object != nil {
obj, err := r.Object.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("marshal object: %w", err)
}
b.Object = obj
}
return json.Marshal(b)
}
func (r *Replica) UnmarshalBinary(data []byte) error {
var b robjectMarshaler
err := json.Unmarshal(data, &b)
if err != nil {
return err
}
r.ID = b.ID
r.Deleted = b.Deleted
if b.Object != nil {
var obj storobj.Object
err = obj.UnmarshalBinary(b.Object)
if err != nil {
return fmt.Errorf("unmarshal object: %w", err)
}
r.Object = &obj
}
return nil
}
type Replicas []Replica
func (ro Replicas) MarshalBinary() ([]byte, error) {
ms := make([]robjectMarshaler, len(ro))
for i, obj := range ro {
m := robjectMarshaler{ID: obj.ID, Deleted: obj.Deleted}
if obj.Object != nil {
b, err := obj.Object.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("marshal object %q: %w", obj.ID, err)
}
m.Object = b
}
ms[i] = m
}
return json.Marshal(ms)
}
func (ro *Replicas) UnmarshalBinary(data []byte) error {
var ms []robjectMarshaler
err := json.Unmarshal(data, &ms)
if err != nil {
return err
}
reps := make(Replicas, len(ms))
for i, m := range ms {
rep := Replica{ID: m.ID, Deleted: m.Deleted}
if m.Object != nil {
var obj storobj.Object
err = obj.UnmarshalBinary(m.Object)
if err != nil {
return fmt.Errorf("unmarshal object %q: %w", m.ID, err)
}
rep.Object = &obj
}
reps[i] = rep
}
*ro = reps
return nil
}
// UpdateTime return update time if it exists and 0 otherwise
func (r Replica) UpdateTime() int64 {
if r.Object != nil {
return r.Object.LastUpdateTimeUnix()
}
return 0
}
|