// BaseStack builds new base stack for the given context value.
func (s *Stacker) BaseStack(ctx context.Context) (*BaseStack, error) {
bs := &BaseStack{
Planner: &Planner{
Provider: s.Provider.Name,
ResourceType: s.Provider.resourceName(),
Log: s.Log,
},
Provider: s.Provider,
KlientIDs: make(stack.KiteMap),
Klients: make(map[string]*DialState),
TunnelURL: s.TunnelURL,
Keys: s.SSHKey,
}
var ok bool
if bs.Req, ok = request.FromContext(ctx); !ok {
return nil, errors.New("request not available in context")
}
req, ok := stack.TeamRequestFromContext(ctx)
if !ok {
return nil, errors.New("team request not available in context")
}
if bs.Session, ok = session.FromContext(ctx); !ok {
return nil, errors.New("session not available in context")
}
bs.Log = s.Log.New(req.GroupName)
if traceID, ok := stack.TraceFromContext(ctx); ok {
bs.Log = logging.NewCustom("kloud-"+req.Provider, true).New(traceID)
bs.TraceID = traceID
}
if keys, ok := publickeys.FromContext(ctx); ok {
bs.Keys = keys
}
if ev, ok := eventer.FromContext(ctx); ok {
bs.Eventer = ev
}
builderOpts := &BuilderOptions{
Log: s.Log.New("stackplan"),
CredStore: s.CredStore,
}
bs.Builder = NewBuilder(builderOpts)
if err := bs.Builder.BuildTeam(req.GroupName); err != nil {
return nil, err
}
if !bs.Builder.Team.IsSubActive() {
return nil, stack.NewError(stack.ErrTeamSubIsNotActive)
}
return bs, nil
}
func (s *Stacker) BuildBaseMachine(ctx context.Context, m *models.Machine) (*BaseMachine, error) {
req, ok := request.FromContext(ctx)
if !ok {
return nil, errors.New("request context is not available")
}
bm := &BaseMachine{
Machine: m,
Session: &session.Session{
DB: s.DB,
Kite: s.Kite,
Userdata: s.Userdata,
Log: s.Log.New(m.ObjectId.Hex()),
},
Credential: s.Provider.newCredential(),
Bootstrap: s.Provider.newBootstrap(),
Metadata: s.Provider.newMetadata(nil),
Req: req,
Provider: s.Provider.Name,
Debug: s.Debug,
}
// NOTE(rjeczalik): "internal" method is used by (*Queue).CheckAWS
if req.Method != "internal" {
// get user model which contains user ssh keys or the list of users that
// are allowed to use this machine
if len(m.Users) == 0 {
return nil, errors.New("permitted users list is empty")
}
// get the user from the permitted list. If the list contains more than one
// allowed person, fetch the one that is the same as requesterName, if
// not pick up the first one.
var err error
bm.User, err = modelhelper.GetPermittedUser(req.Username, bm.Users)
if err != nil {
return nil, err
}
if err := s.ValidateUser(bm.User, bm.Users, req); err != nil {
return nil, err
}
}
if traceID, ok := stack.TraceFromContext(ctx); ok {
bm.Log = logging.NewCustom("kloud-"+s.Provider.Name, true).New(m.ObjectId.Hex()).New(traceID)
bm.Debug = true
bm.TraceID = traceID
}
ev, ok := eventer.FromContext(ctx)
if ok {
bm.Eventer = ev
}
s.Log.Debug("BaseMachine: %+v", bm)
return bm, nil
}