github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/storage/registries.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package storage
     5  
     6  import (
     7  	"sort"
     8  
     9  	"github.com/juju/errors"
    10  )
    11  
    12  // ChainedProviderRegistry is storage provider registry that combines
    13  // multiple storage provider registries, chaining their results. Registries
    14  // earlier in the chain take precedence.
    15  type ChainedProviderRegistry []ProviderRegistry
    16  
    17  // StorageProviderTypes implements ProviderRegistry.
    18  func (r ChainedProviderRegistry) StorageProviderTypes() ([]ProviderType, error) {
    19  	var result []ProviderType
    20  	for _, r := range r {
    21  		types, err := r.StorageProviderTypes()
    22  		if err != nil {
    23  			return nil, errors.Trace(err)
    24  		}
    25  		result = append(result, types...)
    26  	}
    27  	return result, nil
    28  }
    29  
    30  // StorageProvider implements ProviderRegistry.
    31  func (r ChainedProviderRegistry) StorageProvider(t ProviderType) (Provider, error) {
    32  	for _, r := range r {
    33  		p, err := r.StorageProvider(t)
    34  		if err == nil {
    35  			return p, nil
    36  		}
    37  		if errors.IsNotFound(err) {
    38  			continue
    39  		}
    40  		return nil, errors.Annotatef(err, "getting storage provider %q", t)
    41  	}
    42  	return nil, errors.NotFoundf("storage provider %q", t)
    43  }
    44  
    45  // StaticProviderRegistry is a storage provider registry with a statically
    46  // defined set of providers.
    47  type StaticProviderRegistry struct {
    48  	// Providers contains the storage providers for this registry.
    49  	Providers map[ProviderType]Provider
    50  }
    51  
    52  // StorageProviderTypes implements ProviderRegistry.
    53  func (r StaticProviderRegistry) StorageProviderTypes() ([]ProviderType, error) {
    54  	typeStrings := make([]string, 0, len(r.Providers))
    55  	for t := range r.Providers {
    56  		typeStrings = append(typeStrings, string(t))
    57  	}
    58  	sort.Strings(typeStrings)
    59  	types := make([]ProviderType, len(typeStrings))
    60  	for i, s := range typeStrings {
    61  		types[i] = ProviderType(s)
    62  	}
    63  	return types, nil
    64  }
    65  
    66  // StorageProvider implements ProviderRegistry.
    67  func (r StaticProviderRegistry) StorageProvider(t ProviderType) (Provider, error) {
    68  	p, ok := r.Providers[t]
    69  	if ok {
    70  		return p, nil
    71  	}
    72  	return nil, errors.NotFoundf("storage provider %q", t)
    73  }