github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/apiserver/subnets/shims.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package subnets
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/juju/environs/config"
     9  
    10  	"github.com/juju/juju/apiserver/common"
    11  	"github.com/juju/juju/apiserver/params"
    12  	providercommon "github.com/juju/juju/provider/common"
    13  	"github.com/juju/juju/state"
    14  )
    15  
    16  // NOTE: All of the following code is only tested with a feature test.
    17  
    18  // subnetShim forwards and adapts state.Subnets methods to
    19  // common.BackingSubnet.
    20  type subnetShim struct {
    21  	common.BackingSubnet
    22  	subnet *state.Subnet
    23  }
    24  
    25  func (s *subnetShim) CIDR() string {
    26  	return s.subnet.CIDR()
    27  }
    28  
    29  func (s *subnetShim) VLANTag() int {
    30  	return s.subnet.VLANTag()
    31  }
    32  
    33  func (s *subnetShim) ProviderId() string {
    34  	return s.subnet.ProviderId()
    35  }
    36  
    37  func (s *subnetShim) AvailabilityZones() []string {
    38  	// TODO(dimitern): Add multiple zones to state.Subnet.
    39  	return []string{s.subnet.AvailabilityZone()}
    40  }
    41  
    42  func (s *subnetShim) Life() params.Life {
    43  	return params.Life(s.subnet.Life().String())
    44  }
    45  
    46  func (s *subnetShim) Status() string {
    47  	// TODO(dimitern): This should happen in a cleaner way.
    48  	if s.Life() != params.Alive {
    49  		return "terminating"
    50  	}
    51  	return "in-use"
    52  }
    53  
    54  func (s *subnetShim) SpaceName() string {
    55  	return s.subnet.SpaceName()
    56  }
    57  
    58  // spaceShim forwards and adapts state.Space methods to BackingSpace.
    59  type spaceShim struct {
    60  	common.BackingSpace
    61  	space *state.Space
    62  }
    63  
    64  func (s *spaceShim) Name() string {
    65  	return s.space.Name()
    66  }
    67  
    68  func (s *spaceShim) Subnets() ([]common.BackingSubnet, error) {
    69  	results, err := s.space.Subnets()
    70  	if err != nil {
    71  		return nil, errors.Trace(err)
    72  	}
    73  	subnets := make([]common.BackingSubnet, len(results))
    74  	for i, result := range results {
    75  		subnets[i] = &subnetShim{subnet: result}
    76  	}
    77  	return subnets, nil
    78  }
    79  
    80  // stateShim forwards and adapts state.State methods to Backing
    81  // method.
    82  type stateShim struct {
    83  	common.NetworkBacking
    84  	st *state.State
    85  }
    86  
    87  func (s *stateShim) EnvironConfig() (*config.Config, error) {
    88  	return s.st.EnvironConfig()
    89  }
    90  
    91  func (s *stateShim) AllSpaces() ([]common.BackingSpace, error) {
    92  	results, err := s.st.AllSpaces()
    93  	if err != nil {
    94  		return nil, errors.Trace(err)
    95  	}
    96  	spaces := make([]common.BackingSpace, len(results))
    97  	for i, result := range results {
    98  		spaces[i] = &spaceShim{space: result}
    99  	}
   100  	return spaces, nil
   101  }
   102  
   103  func (s *stateShim) AddSubnet(info common.BackingSubnetInfo) (common.BackingSubnet, error) {
   104  	// TODO(dimitern): Add multiple AZs per subnet in state.
   105  	var firstZone string
   106  	if len(info.AvailabilityZones) > 0 {
   107  		firstZone = info.AvailabilityZones[0]
   108  	}
   109  	_, err := s.st.AddSubnet(state.SubnetInfo{
   110  		CIDR:             info.CIDR,
   111  		VLANTag:          info.VLANTag,
   112  		ProviderId:       info.ProviderId,
   113  		AvailabilityZone: firstZone,
   114  		SpaceName:        info.SpaceName,
   115  	})
   116  	return nil, err // Drop the first result, as it's unused.
   117  }
   118  
   119  func (s *stateShim) AllSubnets() ([]common.BackingSubnet, error) {
   120  	results, err := s.st.AllSubnets()
   121  	if err != nil {
   122  		return nil, errors.Trace(err)
   123  	}
   124  	subnets := make([]common.BackingSubnet, len(results))
   125  	for i, result := range results {
   126  		subnets[i] = &subnetShim{subnet: result}
   127  	}
   128  	return subnets, nil
   129  }
   130  
   131  type availZoneShim struct{}
   132  
   133  func (availZoneShim) Name() string    { return "not-set" }
   134  func (availZoneShim) Available() bool { return true }
   135  
   136  func (s *stateShim) AvailabilityZones() ([]providercommon.AvailabilityZone, error) {
   137  	// TODO(dimitern): Fix this to get them from state when available!
   138  	logger.Debugf("not getting availability zones from state yet")
   139  	return nil, nil
   140  }
   141  
   142  func (s *stateShim) SetAvailabilityZones(zones []providercommon.AvailabilityZone) error {
   143  	logger.Debugf("not setting availability zones in state yet: %+v", zones)
   144  	return nil
   145  }