File size: 4,609 Bytes
e89cd08 | 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 | // _ _
// __ _____ __ ___ ___ __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
// \ V V / __/ (_| |\ V /| | (_| | || __/
// \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
// Copyright © 2016 - 2025 Weaviate B.V. All rights reserved.
//
// CONTACT: hello@weaviate.io
//
package objects
import (
"fmt"
)
// objects status code
const (
StatusForbidden = 403
StatusBadRequest = 400
StatusNotFound = 404
StatusUnprocessableEntity = 422
StatusInternalServerError = 500
)
type Error struct {
Msg string
Code int
Err error
}
// Error implements error interface
func (e *Error) Error() string {
return fmt.Sprintf("msg:%s code:%v err:%v", e.Msg, e.Code, e.Err)
}
// Unwrap underlying error
func (e *Error) Unwrap() error {
return e.Err
}
func (e *Error) NotFound() bool {
return e.Code == StatusNotFound
}
func (e *Error) Forbidden() bool {
return e.Code == StatusForbidden
}
func (e *Error) BadRequest() bool {
return e.Code == StatusBadRequest
}
func (e *Error) UnprocessableEntity() bool {
return e.Code == StatusUnprocessableEntity
}
// ErrInvalidUserInput indicates a client-side error
type ErrInvalidUserInput struct {
msg string
}
func (e ErrInvalidUserInput) Error() string {
return e.msg
}
// NewErrInvalidUserInput with Errorf signature
func NewErrInvalidUserInput(format string, args ...interface{}) ErrInvalidUserInput {
return ErrInvalidUserInput{msg: fmt.Sprintf(format, args...)}
}
// ErrInternal indicates something went wrong during processing
type ErrInternal struct {
msg string
}
func (e ErrInternal) Error() string {
return e.msg
}
// NewErrInternal with Errorf signature
func NewErrInternal(format string, args ...interface{}) ErrInternal {
return ErrInternal{msg: fmt.Sprintf(format, args...)}
}
// ErrNotFound indicates the desired resource doesn't exist
type ErrNotFound struct {
msg string
}
func (e ErrNotFound) Error() string {
return e.msg
}
// NewErrNotFound with Errorf signature
func NewErrNotFound(format string, args ...interface{}) ErrNotFound {
return ErrNotFound{msg: fmt.Sprintf(format, args...)}
}
type ErrMultiTenancy struct {
err error
}
func (e ErrMultiTenancy) Error() string {
return e.err.Error()
}
func (e ErrMultiTenancy) Unwrap() error {
return e.err
}
// NewErrMultiTenancy with error signature
func NewErrMultiTenancy(err error) ErrMultiTenancy {
return ErrMultiTenancy{err}
}
// This error is thrown by the replication logic when an object has either:
//
// 1. been deleted locally but exists remotely
//
// 2. been deleted remotely but exists locally
//
// signifying that the current operation is happening simultaneously to another operation
// on the same replicated resource.
//
// This error is used to bubble up the error from the replication logic so that it can be handled
// depending on the context of the higher level operation.
//
// This was introduced originally to handle
// cases where concurrent delete_many and single_patch operations were happening on the same object
// across multiple replicas. The read repair of the patch method would fail with a 500 conflict error
// if the delete operation was not propagated to all replicas before the patch operation was attempted.
// By using this error and handling it in func (m *Manager) MergeObject, any patch updates will assume that
// the object has been deleted everywhere, despite it only being deleted in one place, and will therefore
// return a 404 not found error.
type ErrDirtyReadOfDeletedObject struct {
err error
}
func (e ErrDirtyReadOfDeletedObject) Error() string {
return e.err.Error()
}
func (e ErrDirtyReadOfDeletedObject) Unwrap() error {
return e.err
}
// It depends on the order of operations
//
// Created -> Deleted => It is safe in this case to propagate deletion to all replicas
// Created -> Deleted -> Created => propagating deletion will result in data lost
//
// Updated -> Deleted => It is safe in this case to propagate deletion to all replicas
// Updated -> Deleted -> Updated => It is also safe in this case since updating a deleted object makes no logical sense
func NewErrDirtyReadOfDeletedObject(err error) ErrDirtyReadOfDeletedObject {
return ErrDirtyReadOfDeletedObject{err}
}
type ErrDirtyWriteOfDeletedObject struct {
err error
}
func (e ErrDirtyWriteOfDeletedObject) Error() string {
return e.err.Error()
}
func (e ErrDirtyWriteOfDeletedObject) Unwrap() error {
return e.err
}
func NewErrDirtyWriteOfDeletedObject(err error) ErrDirtyWriteOfDeletedObject {
return ErrDirtyWriteOfDeletedObject{err}
}
|