X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/c14246b9a21d038fc6fa850f4032659a98397784..e59b78c774872e33b9c69acc196989a0f565bdf4:/services/keepstore/volume.go

diff --git a/services/keepstore/volume.go b/services/keepstore/volume.go
index 57e18aba9f..6bce05bec0 100644
--- a/services/keepstore/volume.go
+++ b/services/keepstore/volume.go
@@ -1,12 +1,33 @@
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
 package main
 
 import (
 	"context"
+	"crypto/rand"
+	"fmt"
 	"io"
+	"math/big"
 	"sync/atomic"
 	"time"
+
+	"git.curoverse.com/arvados.git/sdk/go/arvados"
 )
 
+type BlockWriter interface {
+	// WriteBlock reads all data from r, writes it to a backing
+	// store as "loc", and returns the number of bytes written.
+	WriteBlock(ctx context.Context, loc string, r io.Reader) error
+}
+
+type BlockReader interface {
+	// ReadBlock retrieves data previously stored as "loc" and
+	// writes it to w.
+	ReadBlock(ctx context.Context, loc string, w io.Writer) error
+}
+
 // A Volume is an interface representing a Keep back-end storage unit:
 // for example, a single mounted disk, a RAID array, an Amazon S3 volume,
 // etc.
@@ -217,6 +238,13 @@ type Volume interface {
 	// EmptyTrash looks for trashed blocks that exceeded TrashLifetime
 	// and deletes them from the volume.
 	EmptyTrash()
+
+	// Return a globally unique ID of the underlying storage
+	// device if possible, otherwise "".
+	DeviceID() string
+
+	// Get the storage classes associated with this volume
+	GetStorageClasses() []string
 }
 
 // A VolumeWithExamples provides example configs to display in the
@@ -229,6 +257,14 @@ type VolumeWithExamples interface {
 // A VolumeManager tells callers which volumes can read, which volumes
 // can write, and on which volume the next write should be attempted.
 type VolumeManager interface {
+	// Mounts returns all mounts (volume attachments).
+	Mounts() []*VolumeMount
+
+	// Lookup returns the volume under the given mount
+	// UUID. Returns nil if the mount does not exist. If
+	// write==true, returns nil if the volume is not writable.
+	Lookup(uuid string, write bool) Volume
+
 	// AllReadable returns all volumes.
 	AllReadable() []Volume
 
@@ -243,23 +279,71 @@ type VolumeManager interface {
 	// with more free space, etc.
 	NextWritable() Volume
 
+	// VolumeStats returns the ioStats used for tracking stats for
+	// the given Volume.
+	VolumeStats(Volume) *ioStats
+
 	// Close shuts down the volume manager cleanly.
 	Close()
 }
 
+// A VolumeMount is an attachment of a Volume to a VolumeManager.
+type VolumeMount struct {
+	arvados.KeepMount
+	volume Volume
+}
+
+// Generate a UUID the way API server would for a "KeepVolumeMount"
+// object.
+func (*VolumeMount) generateUUID() string {
+	var max big.Int
+	_, ok := max.SetString("zzzzzzzzzzzzzzz", 36)
+	if !ok {
+		panic("big.Int parse failed")
+	}
+	r, err := rand.Int(rand.Reader, &max)
+	if err != nil {
+		panic(err)
+	}
+	return fmt.Sprintf("zzzzz-ivpuk-%015s", r.Text(36))
+}
+
 // RRVolumeManager is a round-robin VolumeManager: the Nth call to
 // NextWritable returns the (N % len(writables))th writable Volume
 // (where writables are all Volumes v where v.Writable()==true).
 type RRVolumeManager struct {
+	mounts    []*VolumeMount
+	mountMap  map[string]*VolumeMount
 	readables []Volume
 	writables []Volume
 	counter   uint32
+	iostats   map[Volume]*ioStats
 }
 
 // MakeRRVolumeManager initializes RRVolumeManager
 func MakeRRVolumeManager(volumes []Volume) *RRVolumeManager {
-	vm := &RRVolumeManager{}
+	vm := &RRVolumeManager{
+		iostats: make(map[Volume]*ioStats),
+	}
+	vm.mountMap = make(map[string]*VolumeMount)
 	for _, v := range volumes {
+		sc := v.GetStorageClasses()
+		if len(sc) == 0 {
+			sc = []string{"default"}
+		}
+		mnt := &VolumeMount{
+			KeepMount: arvados.KeepMount{
+				UUID:           (*VolumeMount)(nil).generateUUID(),
+				DeviceID:       v.DeviceID(),
+				ReadOnly:       !v.Writable(),
+				Replication:    v.Replication(),
+				StorageClasses: sc,
+			},
+			volume: v,
+		}
+		vm.iostats[v] = &ioStats{}
+		vm.mounts = append(vm.mounts, mnt)
+		vm.mountMap[mnt.UUID] = mnt
 		vm.readables = append(vm.readables, v)
 		if v.Writable() {
 			vm.writables = append(vm.writables, v)
@@ -268,6 +352,18 @@ func MakeRRVolumeManager(volumes []Volume) *RRVolumeManager {
 	return vm
 }
 
+func (vm *RRVolumeManager) Mounts() []*VolumeMount {
+	return vm.mounts
+}
+
+func (vm *RRVolumeManager) Lookup(uuid string, needWrite bool) Volume {
+	if mnt, ok := vm.mountMap[uuid]; ok && (!needWrite || !mnt.ReadOnly) {
+		return mnt.volume
+	} else {
+		return nil
+	}
+}
+
 // AllReadable returns an array of all readable volumes
 func (vm *RRVolumeManager) AllReadable() []Volume {
 	return vm.readables
@@ -287,18 +383,35 @@ func (vm *RRVolumeManager) NextWritable() Volume {
 	return vm.writables[i%uint32(len(vm.writables))]
 }
 
+// VolumeStats returns an ioStats for the given volume.
+func (vm *RRVolumeManager) VolumeStats(v Volume) *ioStats {
+	return vm.iostats[v]
+}
+
 // Close the RRVolumeManager
 func (vm *RRVolumeManager) Close() {
 }
 
-// VolumeStatus provides status information of the volume consisting of:
-//   * mount_point
-//   * device_num (an integer identifying the underlying storage system)
-//   * bytes_free
-//   * bytes_used
+// VolumeStatus describes the current condition of a volume
 type VolumeStatus struct {
-	MountPoint string `json:"mount_point"`
-	DeviceNum  uint64 `json:"device_num"`
-	BytesFree  uint64 `json:"bytes_free"`
-	BytesUsed  uint64 `json:"bytes_used"`
+	MountPoint string
+	DeviceNum  uint64
+	BytesFree  uint64
+	BytesUsed  uint64
+}
+
+// ioStats tracks I/O statistics for a volume or server
+type ioStats struct {
+	Errors     uint64
+	Ops        uint64
+	CompareOps uint64
+	GetOps     uint64
+	PutOps     uint64
+	TouchOps   uint64
+	InBytes    uint64
+	OutBytes   uint64
+}
+
+type InternalStatser interface {
+	InternalStats() interface{}
 }