128 lines
3.3 KiB
Go
128 lines
3.3 KiB
Go
/*
|
|
* Minio Cloud Storage, (C) 2016 Minio, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
// error type when key is not found.
|
|
var errMetadataKeyNotExist = errors.New("Key not found in fileMetadata.")
|
|
|
|
// This code is built on similar ideas of http.Header.
|
|
// Ref - https://golang.org/pkg/net/http/#Header
|
|
|
|
// A fileMetadata represents a metadata header mapping
|
|
// keys to sets of values.
|
|
type fileMetadata map[string][]string
|
|
|
|
// Add adds the key, value pair to the header.
|
|
// It appends to any existing values associated with key.
|
|
func (f fileMetadata) Add(key, value string) {
|
|
f[key] = append(f[key], value)
|
|
}
|
|
|
|
// Set sets the header entries associated with key to
|
|
// the single element value. It replaces any existing
|
|
// values associated with key.
|
|
func (f fileMetadata) Set(key, value string) {
|
|
f[key] = []string{value}
|
|
}
|
|
|
|
// Get gets the first value associated with the given key.
|
|
// If there are no values associated with the key, Get returns "".
|
|
// Get is a convenience method. For more complex queries,
|
|
// access the map directly.
|
|
func (f fileMetadata) Get(key string) []string {
|
|
if f == nil {
|
|
return nil
|
|
}
|
|
v, ok := f[key]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
return v
|
|
}
|
|
|
|
// Write writes a metadata in wire format.
|
|
func (f fileMetadata) Write(writer io.Writer) error {
|
|
metadataBytes, err := json.Marshal(f)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = writer.Write(metadataBytes)
|
|
return err
|
|
}
|
|
|
|
// Get file size.
|
|
func (f fileMetadata) GetSize() (int64, error) {
|
|
sizes := f.Get("file.size")
|
|
if sizes == nil {
|
|
return 0, errMetadataKeyNotExist
|
|
}
|
|
sizeStr := sizes[0]
|
|
return strconv.ParseInt(sizeStr, 10, 64)
|
|
}
|
|
|
|
// Set file size.
|
|
func (f fileMetadata) SetSize(size int64) {
|
|
f.Set("file.size", strconv.FormatInt(size, 10))
|
|
}
|
|
|
|
// Get file Modification time.
|
|
func (f fileMetadata) GetModTime() (time.Time, error) {
|
|
timeStrs := f.Get("file.modTime")
|
|
if timeStrs == nil {
|
|
return time.Time{}, errMetadataKeyNotExist
|
|
}
|
|
return time.Parse(timeFormatAMZ, timeStrs[0])
|
|
}
|
|
|
|
// Set file Modification time.
|
|
func (f fileMetadata) SetModTime(modTime time.Time) {
|
|
f.Set("file.modTime", modTime.Format(timeFormatAMZ))
|
|
}
|
|
|
|
// Get file version.
|
|
func (f fileMetadata) GetFileVersion() (int64, error) {
|
|
version := f.Get("file.version")
|
|
if version == nil {
|
|
return 0, errMetadataKeyNotExist
|
|
}
|
|
return strconv.ParseInt(version[0], 10, 64)
|
|
}
|
|
|
|
// Set file version.
|
|
func (f fileMetadata) SetFileVersion(fileVersion int64) {
|
|
f.Set("file.version", strconv.FormatInt(fileVersion, 10))
|
|
}
|
|
|
|
// fileMetadataDecode - file metadata decode.
|
|
func fileMetadataDecode(reader io.Reader) (fileMetadata, error) {
|
|
metadata := make(fileMetadata)
|
|
decoder := json.NewDecoder(reader)
|
|
// Unmarshalling failed, file possibly corrupted.
|
|
if err := decoder.Decode(&metadata); err != nil {
|
|
return nil, err
|
|
}
|
|
return metadata, nil
|
|
}
|