1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
24 "git.curoverse.com/arvados.git/sdk/go/arvados"
25 "github.com/Azure/azure-sdk-for-go/storage"
26 "github.com/prometheus/client_golang/prometheus"
29 const azureDefaultRequestTimeout = arvados.Duration(10 * time.Minute)
33 azureStorageAccountName string
34 azureStorageAccountKeyFile string
35 azureStorageReplication int
36 azureWriteRaceInterval = 15 * time.Second
37 azureWriteRacePollTime = time.Second
40 func readKeyFromFile(file string) (string, error) {
41 buf, err := ioutil.ReadFile(file)
43 return "", errors.New("reading key from " + file + ": " + err.Error())
45 accountKey := strings.TrimSpace(string(buf))
47 return "", errors.New("empty account key in " + file)
49 return accountKey, nil
52 type azureVolumeAdder struct {
56 // String implements flag.Value
57 func (s *azureVolumeAdder) String() string {
61 func (s *azureVolumeAdder) Set(containerName string) error {
62 s.Config.Volumes = append(s.Config.Volumes, &AzureBlobVolume{
63 ContainerName: containerName,
64 StorageAccountName: azureStorageAccountName,
65 StorageAccountKeyFile: azureStorageAccountKeyFile,
66 AzureReplication: azureStorageReplication,
67 ReadOnly: deprecated.flagReadonly,
73 VolumeTypes = append(VolumeTypes, func() VolumeWithExamples { return &AzureBlobVolume{} })
75 flag.Var(&azureVolumeAdder{theConfig},
76 "azure-storage-container-volume",
77 "Use the given container as a storage volume. Can be given multiple times.")
79 &azureStorageAccountName,
80 "azure-storage-account-name",
82 "Azure storage account name used for subsequent --azure-storage-container-volume arguments.")
84 &azureStorageAccountKeyFile,
85 "azure-storage-account-key-file",
87 "`File` containing the account key used for subsequent --azure-storage-container-volume arguments.")
89 &azureStorageReplication,
90 "azure-storage-replication",
92 "Replication level to report to clients when data is stored in an Azure container.")
95 "azure-max-get-bytes",
97 fmt.Sprintf("Maximum bytes to request in a single GET request. If smaller than %d, use multiple concurrent range requests to retrieve a block.", BlockSize))
100 // An AzureBlobVolume stores and retrieves blocks in an Azure Blob
102 type AzureBlobVolume struct {
103 StorageAccountName string
104 StorageAccountKeyFile string
105 StorageBaseURL string // "" means default, "core.windows.net"
109 RequestTimeout arvados.Duration
110 StorageClasses []string
112 azClient storage.Client
113 container *azureContainer
116 // singleSender is a single-attempt storage.Sender.
117 type singleSender struct{}
119 // Send performs req exactly once.
120 func (*singleSender) Send(c *storage.Client, req *http.Request) (resp *http.Response, err error) {
121 return c.HTTPClient.Do(req)
124 // Examples implements VolumeWithExamples.
125 func (*AzureBlobVolume) Examples() []Volume {
128 StorageAccountName: "example-account-name",
129 StorageAccountKeyFile: "/etc/azure_storage_account_key.txt",
130 ContainerName: "example-container-name",
132 RequestTimeout: azureDefaultRequestTimeout,
135 StorageAccountName: "cn-account-name",
136 StorageAccountKeyFile: "/etc/azure_cn_storage_account_key.txt",
137 StorageBaseURL: "core.chinacloudapi.cn",
138 ContainerName: "cn-container-name",
140 RequestTimeout: azureDefaultRequestTimeout,
145 // Type implements Volume.
146 func (v *AzureBlobVolume) Type() string {
150 // Start implements Volume.
151 func (v *AzureBlobVolume) Start(vm *volumeMetricsVecs) error {
152 if v.ContainerName == "" {
153 return errors.New("no container name given")
155 if v.StorageAccountName == "" || v.StorageAccountKeyFile == "" {
156 return errors.New("StorageAccountName and StorageAccountKeyFile must be given")
158 accountKey, err := readKeyFromFile(v.StorageAccountKeyFile)
162 if v.StorageBaseURL == "" {
163 v.StorageBaseURL = storage.DefaultBaseURL
165 v.azClient, err = storage.NewClient(v.StorageAccountName, accountKey, v.StorageBaseURL, storage.DefaultAPIVersion, true)
167 return fmt.Errorf("creating Azure storage client: %s", err)
169 v.azClient.Sender = &singleSender{}
171 if v.RequestTimeout == 0 {
172 v.RequestTimeout = azureDefaultRequestTimeout
174 v.azClient.HTTPClient = &http.Client{
175 Timeout: time.Duration(v.RequestTimeout),
177 bs := v.azClient.GetBlobService()
178 v.container = &azureContainer{
179 ctr: bs.GetContainerReference(v.ContainerName),
182 if ok, err := v.container.Exists(); err != nil {
185 return fmt.Errorf("Azure container %q does not exist", v.ContainerName)
187 // Set up prometheus metrics
188 lbls := prometheus.Labels{"device_id": v.DeviceID()}
189 v.container.stats.opsCounters = vm.opsCounters.MustCurryWith(lbls)
190 v.container.stats.errCounters = vm.errCounters.MustCurryWith(lbls)
191 v.container.stats.ioBytes = vm.ioBytes.MustCurryWith(lbls)
196 // DeviceID returns a globally unique ID for the storage container.
197 func (v *AzureBlobVolume) DeviceID() string {
198 return "azure://" + v.StorageBaseURL + "/" + v.StorageAccountName + "/" + v.ContainerName
201 // Return true if expires_at metadata attribute is found on the block
202 func (v *AzureBlobVolume) checkTrashed(loc string) (bool, map[string]string, error) {
203 metadata, err := v.container.GetBlobMetadata(loc)
205 return false, metadata, v.translateError(err)
207 if metadata["expires_at"] != "" {
208 return true, metadata, nil
210 return false, metadata, nil
213 // Get reads a Keep block that has been stored as a block blob in the
216 // If the block is younger than azureWriteRaceInterval and is
217 // unexpectedly empty, assume a PutBlob operation is in progress, and
218 // wait for it to finish writing.
219 func (v *AzureBlobVolume) Get(ctx context.Context, loc string, buf []byte) (int, error) {
220 trashed, _, err := v.checkTrashed(loc)
225 return 0, os.ErrNotExist
227 var deadline time.Time
228 haveDeadline := false
229 size, err := v.get(ctx, loc, buf)
230 for err == nil && size == 0 && loc != "d41d8cd98f00b204e9800998ecf8427e" {
231 // Seeing a brand new empty block probably means we're
232 // in a race with CreateBlob, which under the hood
233 // (apparently) does "CreateEmpty" and "CommitData"
234 // with no additional transaction locking.
236 t, err := v.Mtime(loc)
238 log.Print("Got empty block (possible race) but Mtime failed: ", err)
241 deadline = t.Add(azureWriteRaceInterval)
242 if time.Now().After(deadline) {
245 log.Printf("Race? Block %s is 0 bytes, %s old. Polling until %s", loc, time.Since(t), deadline)
247 } else if time.Now().After(deadline) {
253 case <-time.After(azureWriteRacePollTime):
255 size, err = v.get(ctx, loc, buf)
258 log.Printf("Race ended with size==%d", size)
263 func (v *AzureBlobVolume) get(ctx context.Context, loc string, buf []byte) (int, error) {
264 ctx, cancel := context.WithCancel(ctx)
266 expectSize := len(buf)
267 if azureMaxGetBytes < BlockSize {
268 // Unfortunately the handler doesn't tell us how long the blob
269 // is expected to be, so we have to ask Azure.
270 props, err := v.container.GetBlobProperties(loc)
272 return 0, v.translateError(err)
274 if props.ContentLength > int64(BlockSize) || props.ContentLength < 0 {
275 return 0, fmt.Errorf("block %s invalid size %d (max %d)", loc, props.ContentLength, BlockSize)
277 expectSize = int(props.ContentLength)
284 // We'll update this actualSize if/when we get the last piece.
286 pieces := (expectSize + azureMaxGetBytes - 1) / azureMaxGetBytes
287 errors := make(chan error, pieces)
288 var wg sync.WaitGroup
290 for p := 0; p < pieces; p++ {
291 // Each goroutine retrieves one piece. If we hit an
292 // error, it is sent to the errors chan so get() can
293 // return it -- but only if the error happens before
294 // ctx is done. This way, if ctx is done before we hit
295 // any other error (e.g., requesting client has hung
296 // up), we return the original ctx.Err() instead of
297 // the secondary errors from the transfers that got
298 // interrupted as a result.
301 startPos := p * azureMaxGetBytes
302 endPos := startPos + azureMaxGetBytes
303 if endPos > expectSize {
306 var rdr io.ReadCloser
308 gotRdr := make(chan struct{})
311 if startPos == 0 && endPos == expectSize {
312 rdr, err = v.container.GetBlob(loc)
314 rdr, err = v.container.GetBlobRange(loc, startPos, endPos-1, nil)
334 // Close the reader when the client
335 // hangs up or another piece fails
336 // (possibly interrupting ReadFull())
337 // or when all pieces succeed and
342 n, err := io.ReadFull(rdr, buf[startPos:endPos])
343 if pieces == 1 && (err == io.ErrUnexpectedEOF || err == io.EOF) {
344 // If we don't know the actual size,
345 // and just tried reading 64 MiB, it's
346 // normal to encounter EOF.
347 } else if err != nil {
348 if ctx.Err() == nil {
355 actualSize = startPos + n
362 return 0, v.translateError(<-errors)
364 if ctx.Err() != nil {
367 return actualSize, nil
370 // Compare the given data with existing stored data.
371 func (v *AzureBlobVolume) Compare(ctx context.Context, loc string, expect []byte) error {
372 trashed, _, err := v.checkTrashed(loc)
377 return os.ErrNotExist
379 var rdr io.ReadCloser
380 gotRdr := make(chan struct{})
383 rdr, err = v.container.GetBlob(loc)
397 return v.translateError(err)
400 return compareReaderWithBuf(ctx, rdr, expect, loc[:32])
403 // Put stores a Keep block as a block blob in the container.
404 func (v *AzureBlobVolume) Put(ctx context.Context, loc string, block []byte) error {
406 return MethodDisabledError
408 // Send the block data through a pipe, so that (if we need to)
409 // we can close the pipe early and abandon our
410 // CreateBlockBlobFromReader() goroutine, without worrying
411 // about CreateBlockBlobFromReader() accessing our block
412 // buffer after we release it.
413 bufr, bufw := io.Pipe()
415 io.Copy(bufw, bytes.NewReader(block))
418 errChan := make(chan error)
420 var body io.Reader = bufr
422 // We must send a "Content-Length: 0" header,
423 // but the http client interprets
424 // ContentLength==0 as "unknown" unless it can
425 // confirm by introspection that Body will
430 errChan <- v.container.CreateBlockBlobFromReader(loc, len(block), body, nil)
434 theConfig.debugLogf("%s: taking CreateBlockBlobFromReader's input away: %s", v, ctx.Err())
435 // Our pipe might be stuck in Write(), waiting for
436 // io.Copy() to read. If so, un-stick it. This means
437 // CreateBlockBlobFromReader will get corrupt data,
438 // but that's OK: the size won't match, so the write
440 go io.Copy(ioutil.Discard, bufr)
441 // CloseWithError() will return once pending I/O is done.
442 bufw.CloseWithError(ctx.Err())
443 theConfig.debugLogf("%s: abandoning CreateBlockBlobFromReader goroutine", v)
445 case err := <-errChan:
450 // Touch updates the last-modified property of a block blob.
451 func (v *AzureBlobVolume) Touch(loc string) error {
453 return MethodDisabledError
455 trashed, metadata, err := v.checkTrashed(loc)
460 return os.ErrNotExist
463 metadata["touch"] = fmt.Sprintf("%d", time.Now().Unix())
464 return v.container.SetBlobMetadata(loc, metadata, nil)
467 // Mtime returns the last-modified property of a block blob.
468 func (v *AzureBlobVolume) Mtime(loc string) (time.Time, error) {
469 trashed, _, err := v.checkTrashed(loc)
471 return time.Time{}, err
474 return time.Time{}, os.ErrNotExist
477 props, err := v.container.GetBlobProperties(loc)
479 return time.Time{}, err
481 return time.Time(props.LastModified), nil
484 // IndexTo writes a list of Keep blocks that are stored in the
486 func (v *AzureBlobVolume) IndexTo(prefix string, writer io.Writer) error {
487 params := storage.ListBlobsParameters{
489 Include: &storage.IncludeBlobDataset{Metadata: true},
492 resp, err := v.container.ListBlobs(params)
496 for _, b := range resp.Blobs {
497 if !v.isKeepBlock(b.Name) {
500 modtime := time.Time(b.Properties.LastModified)
501 if b.Properties.ContentLength == 0 && modtime.Add(azureWriteRaceInterval).After(time.Now()) {
502 // A new zero-length blob is probably
503 // just a new non-empty blob that
504 // hasn't committed its data yet (see
505 // Get()), and in any case has no
509 if b.Metadata["expires_at"] != "" {
510 // Trashed blob; exclude it from response
513 fmt.Fprintf(writer, "%s+%d %d\n", b.Name, b.Properties.ContentLength, modtime.UnixNano())
515 if resp.NextMarker == "" {
518 params.Marker = resp.NextMarker
522 // Trash a Keep block.
523 func (v *AzureBlobVolume) Trash(loc string) error {
525 return MethodDisabledError
528 // Ideally we would use If-Unmodified-Since, but that
529 // particular condition seems to be ignored by Azure. Instead,
530 // we get the Etag before checking Mtime, and use If-Match to
531 // ensure we don't delete data if Put() or Touch() happens
532 // between our calls to Mtime() and DeleteBlob().
533 props, err := v.container.GetBlobProperties(loc)
537 if t, err := v.Mtime(loc); err != nil {
539 } else if time.Since(t) < theConfig.BlobSignatureTTL.Duration() {
543 // If TrashLifetime == 0, just delete it
544 if theConfig.TrashLifetime == 0 {
545 return v.container.DeleteBlob(loc, &storage.DeleteBlobOptions{
550 // Otherwise, mark as trash
551 return v.container.SetBlobMetadata(loc, storage.BlobMetadata{
552 "expires_at": fmt.Sprintf("%d", time.Now().Add(theConfig.TrashLifetime.Duration()).Unix()),
553 }, &storage.SetBlobMetadataOptions{
558 // Untrash a Keep block.
559 // Delete the expires_at metadata attribute
560 func (v *AzureBlobVolume) Untrash(loc string) error {
561 // if expires_at does not exist, return NotFoundError
562 metadata, err := v.container.GetBlobMetadata(loc)
564 return v.translateError(err)
566 if metadata["expires_at"] == "" {
567 return os.ErrNotExist
570 // reset expires_at metadata attribute
571 metadata["expires_at"] = ""
572 err = v.container.SetBlobMetadata(loc, metadata, nil)
573 return v.translateError(err)
576 // Status returns a VolumeStatus struct with placeholder data.
577 func (v *AzureBlobVolume) Status() *VolumeStatus {
578 return &VolumeStatus{
580 BytesFree: BlockSize * 1000,
585 // String returns a volume label, including the container name.
586 func (v *AzureBlobVolume) String() string {
587 return fmt.Sprintf("azure-storage-container:%+q", v.ContainerName)
590 // Writable returns true, unless the -readonly flag was on when the
592 func (v *AzureBlobVolume) Writable() bool {
596 // Replication returns the replication level of the container, as
597 // specified by the -azure-storage-replication argument.
598 func (v *AzureBlobVolume) Replication() int {
599 return v.AzureReplication
602 // GetStorageClasses implements Volume
603 func (v *AzureBlobVolume) GetStorageClasses() []string {
604 return v.StorageClasses
607 // If possible, translate an Azure SDK error to a recognizable error
608 // like os.ErrNotExist.
609 func (v *AzureBlobVolume) translateError(err error) error {
613 case strings.Contains(err.Error(), "StatusCode=503"):
614 // "storage: service returned error: StatusCode=503, ErrorCode=ServerBusy, ErrorMessage=The server is busy" (See #14804)
615 return VolumeBusyError
616 case strings.Contains(err.Error(), "Not Found"):
617 // "storage: service returned without a response body (404 Not Found)"
618 return os.ErrNotExist
624 var keepBlockRegexp = regexp.MustCompile(`^[0-9a-f]{32}$`)
626 func (v *AzureBlobVolume) isKeepBlock(s string) bool {
627 return keepBlockRegexp.MatchString(s)
630 // EmptyTrash looks for trashed blocks that exceeded TrashLifetime
631 // and deletes them from the volume.
632 func (v *AzureBlobVolume) EmptyTrash() {
633 var bytesDeleted, bytesInTrash int64
634 var blocksDeleted, blocksInTrash int64
636 doBlob := func(b storage.Blob) {
637 // Check whether the block is flagged as trash
638 if b.Metadata["expires_at"] == "" {
642 atomic.AddInt64(&blocksInTrash, 1)
643 atomic.AddInt64(&bytesInTrash, b.Properties.ContentLength)
645 expiresAt, err := strconv.ParseInt(b.Metadata["expires_at"], 10, 64)
647 log.Printf("EmptyTrash: ParseInt(%v): %v", b.Metadata["expires_at"], err)
651 if expiresAt > time.Now().Unix() {
655 err = v.container.DeleteBlob(b.Name, &storage.DeleteBlobOptions{
656 IfMatch: b.Properties.Etag,
659 log.Printf("EmptyTrash: DeleteBlob(%v): %v", b.Name, err)
662 atomic.AddInt64(&blocksDeleted, 1)
663 atomic.AddInt64(&bytesDeleted, b.Properties.ContentLength)
666 var wg sync.WaitGroup
667 todo := make(chan storage.Blob, theConfig.EmptyTrashWorkers)
668 for i := 0; i < 1 || i < theConfig.EmptyTrashWorkers; i++ {
672 for b := range todo {
678 params := storage.ListBlobsParameters{Include: &storage.IncludeBlobDataset{Metadata: true}}
680 resp, err := v.container.ListBlobs(params)
682 log.Printf("EmptyTrash: ListBlobs: %v", err)
685 for _, b := range resp.Blobs {
688 if resp.NextMarker == "" {
691 params.Marker = resp.NextMarker
696 log.Printf("EmptyTrash stats for %v: Deleted %v bytes in %v blocks. Remaining in trash: %v bytes in %v blocks.", v.String(), bytesDeleted, blocksDeleted, bytesInTrash-bytesDeleted, blocksInTrash-blocksDeleted)
699 // InternalStats returns bucket I/O and API call counters.
700 func (v *AzureBlobVolume) InternalStats() interface{} {
701 return &v.container.stats
704 type azureBlobStats struct {
709 GetMetadataOps uint64
710 GetPropertiesOps uint64
712 SetMetadataOps uint64
717 func (s *azureBlobStats) TickErr(err error) {
721 errType := fmt.Sprintf("%T", err)
722 if err, ok := err.(storage.AzureStorageServiceError); ok {
723 errType = errType + fmt.Sprintf(" %d (%s)", err.StatusCode, err.Code)
725 log.Printf("errType %T, err %s", err, err)
726 s.statsTicker.TickErr(err, errType)
729 // azureContainer wraps storage.Container in order to count I/O and
731 type azureContainer struct {
732 ctr *storage.Container
736 func (c *azureContainer) Exists() (bool, error) {
737 c.stats.TickOps("exists")
738 c.stats.Tick(&c.stats.Ops)
739 ok, err := c.ctr.Exists()
744 func (c *azureContainer) GetBlobMetadata(bname string) (storage.BlobMetadata, error) {
745 c.stats.TickOps("get_metadata")
746 c.stats.Tick(&c.stats.Ops, &c.stats.GetMetadataOps)
747 b := c.ctr.GetBlobReference(bname)
748 err := b.GetMetadata(nil)
750 return b.Metadata, err
753 func (c *azureContainer) GetBlobProperties(bname string) (*storage.BlobProperties, error) {
754 c.stats.TickOps("get_properties")
755 c.stats.Tick(&c.stats.Ops, &c.stats.GetPropertiesOps)
756 b := c.ctr.GetBlobReference(bname)
757 err := b.GetProperties(nil)
759 return &b.Properties, err
762 func (c *azureContainer) GetBlob(bname string) (io.ReadCloser, error) {
763 c.stats.TickOps("get")
764 c.stats.Tick(&c.stats.Ops, &c.stats.GetOps)
765 b := c.ctr.GetBlobReference(bname)
766 rdr, err := b.Get(nil)
768 return NewCountingReader(rdr, c.stats.TickInBytes), err
771 func (c *azureContainer) GetBlobRange(bname string, start, end int, opts *storage.GetBlobOptions) (io.ReadCloser, error) {
772 c.stats.TickOps("get_range")
773 c.stats.Tick(&c.stats.Ops, &c.stats.GetRangeOps)
774 b := c.ctr.GetBlobReference(bname)
775 rdr, err := b.GetRange(&storage.GetBlobRangeOptions{
776 Range: &storage.BlobRange{
777 Start: uint64(start),
780 GetBlobOptions: opts,
783 return NewCountingReader(rdr, c.stats.TickInBytes), err
786 // If we give it an io.Reader that doesn't also have a Len() int
787 // method, the Azure SDK determines data size by copying the data into
788 // a new buffer, which is not a good use of memory.
789 type readerWithAzureLen struct {
794 // Len satisfies the private lener interface in azure-sdk-for-go.
795 func (r *readerWithAzureLen) Len() int {
799 func (c *azureContainer) CreateBlockBlobFromReader(bname string, size int, rdr io.Reader, opts *storage.PutBlobOptions) error {
800 c.stats.TickOps("create")
801 c.stats.Tick(&c.stats.Ops, &c.stats.CreateOps)
803 rdr = &readerWithAzureLen{
804 Reader: NewCountingReader(rdr, c.stats.TickOutBytes),
808 b := c.ctr.GetBlobReference(bname)
809 err := b.CreateBlockBlobFromReader(rdr, opts)
814 func (c *azureContainer) SetBlobMetadata(bname string, m storage.BlobMetadata, opts *storage.SetBlobMetadataOptions) error {
815 c.stats.TickOps("set_metadata")
816 c.stats.Tick(&c.stats.Ops, &c.stats.SetMetadataOps)
817 b := c.ctr.GetBlobReference(bname)
819 err := b.SetMetadata(opts)
824 func (c *azureContainer) ListBlobs(params storage.ListBlobsParameters) (storage.BlobListResponse, error) {
825 c.stats.TickOps("list")
826 c.stats.Tick(&c.stats.Ops, &c.stats.ListOps)
827 resp, err := c.ctr.ListBlobs(params)
832 func (c *azureContainer) DeleteBlob(bname string, opts *storage.DeleteBlobOptions) error {
833 c.stats.TickOps("delete")
834 c.stats.Tick(&c.stats.Ops, &c.stats.DelOps)
835 b := c.ctr.GetBlobReference(bname)
836 err := b.Delete(opts)