mirror of
https://github.com/minio/minio
synced 2024-09-30 13:13:56 +00:00
faf013ec84
Existing:
```go
type xlMetaV2 struct {
Versions []xlMetaV2Version `json:"Versions" msg:"Versions"`
}
```
Serialized as regular MessagePack.
```go
//msgp:tuple xlMetaV2VersionHeader
type xlMetaV2VersionHeader struct {
VersionID [16]byte
ModTime int64
Type VersionType
Flags xlFlags
}
```
Serialize as streaming MessagePack, format:
```
int(headerVersion)
int(xlmetaVersion)
int(nVersions)
for each version {
binary blob, xlMetaV2VersionHeader, serialized
binary blob, xlMetaV2Version, serialized.
}
```
xlMetaV2VersionHeader is <= 30 bytes serialized. Deserialized struct
can easily be reused and does not contain pointers, so efficient as a
slice (single allocation)
This allows quickly parsing everything as slices of bytes (no copy).
Versions are always *saved* sorted by modTime, newest *first*.
No more need to sort on load.
* Allows checking if a version exists.
* Allows reading single version without unmarshal all.
* Allows reading latest version of type without unmarshal all.
* Allows reading latest version without unmarshal of all.
* Allows checking if the latest is deleteMarker by reading first entry.
* Allows adding/updating/deleting a version with only header deserialization.
* Reduces allocations on conversion to FileInfo(s).
109 lines
3.3 KiB
Go
109 lines
3.3 KiB
Go
// Copyright (c) 2015-2021 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/minio/minio/internal/bucket/lifecycle"
|
|
)
|
|
|
|
const freeVersion = "free-version"
|
|
|
|
// InitFreeVersion creates a free-version to track the tiered-content of j. If j has
|
|
// no tiered content, it returns false.
|
|
func (j xlMetaV2Object) InitFreeVersion(fi FileInfo) (xlMetaV2Version, bool) {
|
|
if status, ok := j.MetaSys[ReservedMetadataPrefixLower+TransitionStatus]; ok && bytes.Equal(status, []byte(lifecycle.TransitionComplete)) {
|
|
vID, err := uuid.Parse(fi.TierFreeVersionID())
|
|
if err != nil {
|
|
panic(fmt.Errorf("Invalid Tier Object delete marker versionId %s %v", fi.TierFreeVersionID(), err))
|
|
}
|
|
freeEntry := xlMetaV2Version{Type: DeleteType}
|
|
freeEntry.DeleteMarker = &xlMetaV2DeleteMarker{
|
|
VersionID: vID,
|
|
ModTime: j.ModTime, // fi.ModTime may be empty
|
|
MetaSys: make(map[string][]byte),
|
|
}
|
|
|
|
freeEntry.DeleteMarker.MetaSys[ReservedMetadataPrefixLower+freeVersion] = []byte{}
|
|
tierKey := ReservedMetadataPrefixLower + TransitionTier
|
|
tierObjKey := ReservedMetadataPrefixLower + TransitionedObjectName
|
|
tierObjVIDKey := ReservedMetadataPrefixLower + TransitionedVersionID
|
|
|
|
for k, v := range j.MetaSys {
|
|
switch k {
|
|
case tierKey, tierObjKey, tierObjVIDKey:
|
|
freeEntry.DeleteMarker.MetaSys[k] = v
|
|
}
|
|
}
|
|
return freeEntry, true
|
|
}
|
|
return xlMetaV2Version{}, false
|
|
}
|
|
|
|
// FreeVersion returns true if j represents a free-version, false otherwise.
|
|
func (j xlMetaV2DeleteMarker) FreeVersion() bool {
|
|
_, ok := j.MetaSys[ReservedMetadataPrefixLower+freeVersion]
|
|
return ok
|
|
}
|
|
|
|
// FreeVersion returns true if j represents a free-version, false otherwise.
|
|
func (j xlMetaV2Version) FreeVersion() bool {
|
|
switch j.Type {
|
|
case DeleteType:
|
|
return j.DeleteMarker.FreeVersion()
|
|
}
|
|
return false
|
|
}
|
|
|
|
// AddFreeVersion adds a free-version if needed for fi.VersionID version.
|
|
// Free-version will be added if fi.VersionID has transitioned.
|
|
func (x *xlMetaV2) AddFreeVersion(fi FileInfo) error {
|
|
var uv uuid.UUID
|
|
var err error
|
|
switch fi.VersionID {
|
|
case "", nullVersionID:
|
|
default:
|
|
uv, err = uuid.Parse(fi.VersionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for i, version := range x.versions {
|
|
if version.header.VersionID != uv || version.header.Type != ObjectType {
|
|
continue
|
|
}
|
|
// if uv has tiered content we add a
|
|
// free-version to track it for asynchronous
|
|
// deletion via scanner.
|
|
ver, err := x.getIdx(i)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
|
|
return x.addVersion(freeVersion)
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
}
|