github.com/webonyx/up@v0.7.4-0.20180808230834-91b94e551323/config/stages.go (about)

     1  package config
     2  
     3  import (
     4  	"sort"
     5  
     6  	"github.com/apex/up/internal/validate"
     7  	"github.com/pkg/errors"
     8  )
     9  
    10  // defaultStages is a list of default stage names.
    11  var defaultStages = []string{
    12  	"development",
    13  	"staging",
    14  	"production",
    15  }
    16  
    17  // Stage config.
    18  type Stage struct {
    19  	Domain string      `json:"domain"`
    20  	Zone   interface{} `json:"zone"`
    21  	Path   string      `json:"path"`
    22  	Cert   string      `json:"cert"`
    23  	Name   string      `json:"-"`
    24  	StageOverrides
    25  }
    26  
    27  // IsLocal returns true if the stage represents a local environment.
    28  func (s *Stage) IsLocal() bool {
    29  	return s.Name == "development"
    30  }
    31  
    32  // IsRemote returns true if the stage represents a remote environment.
    33  func (s *Stage) IsRemote() bool {
    34  	return !s.IsLocal()
    35  }
    36  
    37  // Validate implementation.
    38  func (s *Stage) Validate() error {
    39  	if err := validate.Stage(s.Name); err != nil {
    40  		return errors.Wrap(err, ".name")
    41  	}
    42  
    43  	switch s.Zone.(type) {
    44  	case bool, string:
    45  		return nil
    46  	default:
    47  		return errors.Errorf(".zone is an invalid type, must be string or boolean")
    48  	}
    49  }
    50  
    51  // Default implementation.
    52  func (s *Stage) Default() error {
    53  	if s.Zone == nil {
    54  		s.Zone = true
    55  	}
    56  
    57  	return nil
    58  }
    59  
    60  // StageOverrides config.
    61  type StageOverrides struct {
    62  	Hooks  Hooks  `json:"hooks"`
    63  	Lambda Lambda `json:"lambda"`
    64  	Proxy  Relay  `json:"proxy"`
    65  }
    66  
    67  // Override config.
    68  func (s *StageOverrides) Override(c *Config) {
    69  	s.Hooks.Override(c)
    70  	s.Lambda.Override(c)
    71  	s.Proxy.Override(c)
    72  }
    73  
    74  // Stages config.
    75  type Stages map[string]*Stage
    76  
    77  // Default implementation.
    78  func (s Stages) Default() error {
    79  	// defaults
    80  	for _, name := range defaultStages {
    81  		if _, ok := s[name]; !ok {
    82  			s[name] = &Stage{}
    83  		}
    84  	}
    85  
    86  	// assign names
    87  	for name, s := range s {
    88  		s.Name = name
    89  	}
    90  
    91  	// defaults
    92  	for _, s := range s {
    93  		if err := s.Default(); err != nil {
    94  			return errors.Wrapf(err, "stage %q", s.Name)
    95  		}
    96  	}
    97  
    98  	return nil
    99  }
   100  
   101  // Validate implementation.
   102  func (s Stages) Validate() error {
   103  	for _, s := range s {
   104  		if err := s.Validate(); err != nil {
   105  			return errors.Wrapf(err, "stage %q", s.Name)
   106  		}
   107  	}
   108  	return nil
   109  }
   110  
   111  // List returns configured stages.
   112  func (s Stages) List() (v []*Stage) {
   113  	for _, s := range s {
   114  		v = append(v, s)
   115  	}
   116  
   117  	return
   118  }
   119  
   120  // Domains returns configured domains.
   121  func (s Stages) Domains() (v []string) {
   122  	for _, s := range s.List() {
   123  		if s.Domain != "" {
   124  			v = append(v, s.Domain)
   125  		}
   126  	}
   127  
   128  	return
   129  }
   130  
   131  // Names returns configured stage names.
   132  func (s Stages) Names() (v []string) {
   133  	for _, s := range s.List() {
   134  		v = append(v, s.Name)
   135  	}
   136  
   137  	sort.Strings(v)
   138  	return
   139  }
   140  
   141  // RemoteNames returns configured remote stage names.
   142  func (s Stages) RemoteNames() (v []string) {
   143  	for _, s := range s.List() {
   144  		if s.IsRemote() {
   145  			v = append(v, s.Name)
   146  		}
   147  	}
   148  
   149  	sort.Strings(v)
   150  	return
   151  }
   152  
   153  // GetByDomain returns the stage by domain or nil.
   154  func (s Stages) GetByDomain(domain string) *Stage {
   155  	for _, s := range s.List() {
   156  		if s.Domain == domain {
   157  			return s
   158  		}
   159  	}
   160  
   161  	return nil
   162  }
   163  
   164  // GetByName returns the stage by name or nil.
   165  func (s Stages) GetByName(name string) *Stage {
   166  	for _, s := range s.List() {
   167  		if s.Name == name {
   168  			return s
   169  		}
   170  	}
   171  
   172  	return nil
   173  }