github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/apiserver/common/networkingcommon/shims.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package networkingcommon
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"gopkg.in/juju/names.v2"
     9  
    10  	"github.com/juju/juju/apiserver/params"
    11  	"github.com/juju/juju/network"
    12  	providercommon "github.com/juju/juju/provider/common"
    13  	"github.com/juju/juju/state"
    14  	"github.com/juju/juju/state/stateenvirons"
    15  )
    16  
    17  // NOTE: All of the following code is only tested with a feature test.
    18  
    19  // subnetShim forwards and adapts state.Subnets methods to BackingSubnet.
    20  type subnetShim struct {
    21  	subnet *state.Subnet
    22  }
    23  
    24  func (s *subnetShim) CIDR() string {
    25  	return s.subnet.CIDR()
    26  }
    27  
    28  func (s *subnetShim) VLANTag() int {
    29  	return s.subnet.VLANTag()
    30  }
    31  
    32  func (s *subnetShim) ProviderNetworkId() network.Id {
    33  	return s.subnet.ProviderNetworkId()
    34  }
    35  
    36  func (s *subnetShim) ProviderId() network.Id {
    37  	return s.subnet.ProviderId()
    38  }
    39  
    40  func (s *subnetShim) AvailabilityZones() []string {
    41  	// TODO(dimitern): Add multiple zones to state.Subnet.
    42  	return []string{s.subnet.AvailabilityZone()}
    43  }
    44  
    45  func (s *subnetShim) Life() params.Life {
    46  	return params.Life(s.subnet.Life().String())
    47  }
    48  
    49  func (s *subnetShim) Status() string {
    50  	// TODO(dimitern): This should happen in a cleaner way.
    51  	if s.Life() != params.Alive {
    52  		return "terminating"
    53  	}
    54  	return "in-use"
    55  }
    56  
    57  func (s *subnetShim) SpaceName() string {
    58  	return s.subnet.SpaceName()
    59  }
    60  
    61  // spaceShim forwards and adapts state.Space methods to BackingSpace.
    62  type spaceShim struct {
    63  	space *state.Space
    64  }
    65  
    66  func (s *spaceShim) Name() string {
    67  	return s.space.Name()
    68  }
    69  
    70  func (s *spaceShim) ProviderId() network.Id {
    71  	return s.space.ProviderId()
    72  }
    73  
    74  func (s *spaceShim) Subnets() ([]BackingSubnet, error) {
    75  	results, err := s.space.Subnets()
    76  	if err != nil {
    77  		return nil, errors.Trace(err)
    78  	}
    79  	subnets := make([]BackingSubnet, len(results))
    80  	for i, result := range results {
    81  		subnets[i] = &subnetShim{subnet: result}
    82  	}
    83  	return subnets, nil
    84  }
    85  
    86  func NewStateShim(st *state.State) (*stateShim, error) {
    87  	m, err := st.Model()
    88  	if err != nil {
    89  		return nil, errors.Trace(err)
    90  	}
    91  	return &stateShim{stateenvirons.EnvironConfigGetter{st, m}, st, m}, nil
    92  }
    93  
    94  // stateShim forwards and adapts state.State methods to Backing
    95  // method.
    96  // TODO - CAAS(ericclaudejones): This should contain state and stateenvirons alone, model will be
    97  // removed once all relevant methods are moved from state to model.
    98  type stateShim struct {
    99  	stateenvirons.EnvironConfigGetter
   100  	st *state.State
   101  	m  *state.Model
   102  }
   103  
   104  func (s *stateShim) AddSpace(name string, providerId network.Id, subnetIds []string, public bool) error {
   105  	_, err := s.st.AddSpace(name, providerId, subnetIds, public)
   106  	return err
   107  }
   108  
   109  func (s *stateShim) AllSpaces() ([]BackingSpace, error) {
   110  	// TODO(dimitern): Make this ListSpaces() instead.
   111  	results, err := s.st.AllSpaces()
   112  	if err != nil {
   113  		return nil, errors.Trace(err)
   114  	}
   115  	spaces := make([]BackingSpace, len(results))
   116  	for i, result := range results {
   117  		spaces[i] = &spaceShim{space: result}
   118  	}
   119  	return spaces, nil
   120  }
   121  
   122  func (s *stateShim) AddSubnet(info BackingSubnetInfo) (BackingSubnet, error) {
   123  	// TODO(babbageclunk): we only take the first zone because
   124  	// state.Subnet currently only stores one.
   125  	var firstZone string
   126  	if len(info.AvailabilityZones) > 0 {
   127  		firstZone = info.AvailabilityZones[0]
   128  	}
   129  	_, err := s.st.AddSubnet(state.SubnetInfo{
   130  		CIDR:              info.CIDR,
   131  		VLANTag:           info.VLANTag,
   132  		ProviderId:        info.ProviderId,
   133  		ProviderNetworkId: info.ProviderNetworkId,
   134  		AvailabilityZone:  firstZone,
   135  		SpaceName:         info.SpaceName,
   136  	})
   137  	return nil, err // Drop the first result, as it's unused.
   138  }
   139  
   140  func (s *stateShim) AllSubnets() ([]BackingSubnet, error) {
   141  	results, err := s.st.AllSubnets()
   142  	if err != nil {
   143  		return nil, errors.Trace(err)
   144  	}
   145  	subnets := make([]BackingSubnet, len(results))
   146  	for i, result := range results {
   147  		subnets[i] = &subnetShim{subnet: result}
   148  	}
   149  	return subnets, nil
   150  }
   151  
   152  func (s *stateShim) AvailabilityZones() ([]providercommon.AvailabilityZone, error) {
   153  	// TODO(dimitern): Fix this to get them from state when available!
   154  	return nil, nil
   155  }
   156  
   157  func (s *stateShim) SetAvailabilityZones(zones []providercommon.AvailabilityZone) error {
   158  	return nil
   159  }
   160  
   161  func (s *stateShim) ModelTag() names.ModelTag {
   162  	return s.m.ModelTag()
   163  }