// cloudHandler returns a handler that responds with the cloud config for the
// requester.
func cloudHandler(srv server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
group, err := groupFromContext(ctx)
if err != nil || group.Profile == "" {
http.NotFound(w, req)
return
}
profile, err := srv.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil || profile.CloudId == "" {
http.NotFound(w, req)
return
}
contents, err := srv.CloudGet(ctx, profile.CloudId)
if err != nil {
http.NotFound(w, req)
return
}
// collect data for rendering
data := make(map[string]interface{})
if group.Metadata != nil {
err = json.Unmarshal(group.Metadata, &data)
if err != nil {
log.Errorf("error unmarshalling metadata: %v", err)
http.NotFound(w, req)
return
}
}
for key, value := range group.Selector {
data[strings.ToLower(key)] = value
}
// render the template of a cloud config with data
var buf bytes.Buffer
err = renderTemplate(&buf, data, contents)
if err != nil {
http.NotFound(w, req)
return
}
config := buf.String()
if !cloudinit.IsCloudConfig(config) && !cloudinit.IsScript(config) {
log.Error("error parsing user-data")
http.NotFound(w, req)
return
}
if cloudinit.IsCloudConfig(config) {
if _, err = cloudinit.NewCloudConfig(config); err != nil {
log.Errorf("error parsing cloud config: %v", err)
http.NotFound(w, req)
return
}
}
http.ServeContent(w, req, "", time.Time{}, strings.NewReader(config))
}
return ContextHandlerFunc(fn)
}
// selectProfile selects the Profile for the given query parameters, adds the
// Profile to the ctx, and calls the next handler. The next handler should
// handle a missing profile.
func (s *Server) selectProfile(core server.Server, next ContextHandler) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
attrs := labelsFromRequest(s.logger, req)
// match machine request
profile, err := core.SelectProfile(ctx, &pb.SelectProfileRequest{Labels: attrs})
if err == nil {
// add the Profile to the ctx for the next handler
ctx = withProfile(ctx, profile)
}
next.ServeHTTP(ctx, w, req)
}
return ContextHandlerFunc(fn)
}
// selectGroup selects the Group whose selectors match the query parameters,
// adds the Group to the ctx, and calls the next handler. The next handler
// should handle a missing Group.
func selectGroup(srv server.Server, next ContextHandler) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
attrs := labelsFromRequest(req)
// match machine request
group, err := srv.SelectGroup(ctx, &pb.SelectGroupRequest{Labels: attrs})
if err == nil {
// add the Group to the ctx for next handler
ctx = withGroup(ctx, group)
}
next.ServeHTTP(ctx, w, req)
}
return ContextHandlerFunc(fn)
}
// genericHandler returns a handler that responds with generic file for
// the requester.
func genericHandler(srv server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
group, err := groupFromContext(ctx)
if err != nil || group.Profile == "" {
http.NotFound(w, req)
return
}
profile, err := srv.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil || profile.GenericId == "" {
http.NotFound(w, req)
return
}
contents, err := srv.GenericGet(ctx, profile.GenericId)
if err != nil {
http.NotFound(w, req)
return
}
// collect data for rendering
data := make(map[string]interface{})
if group.Metadata != nil {
err = json.Unmarshal(group.Metadata, &data)
if err != nil {
log.Errorf("error unmarshalling metadata: %v", err)
http.NotFound(w, req)
return
}
}
data["query"] = req.URL.RawQuery
for key, value := range group.Selector {
data[strings.ToLower(key)] = value
}
// render the template of a generic config with data
var buf bytes.Buffer
err = renderTemplate(&buf, data, contents)
if err != nil {
http.NotFound(w, req)
return
}
config := buf.String()
http.ServeContent(w, req, "", time.Time{}, strings.NewReader(config))
}
return ContextHandlerFunc(fn)
}
// pixiecoreHandler returns a handler that renders the boot config JSON for
// the requester, to implement the Pixiecore API specification.
// https://github.com/danderson/pixiecore/blob/master/README.api.md
func (s *Server) pixiecoreHandler(core server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
// pixiecore only provides a MAC address label
macAddr, err := parseMAC(filepath.Base(req.URL.Path))
if err != nil {
s.logger.Errorf("unparseable MAC address: %v", err)
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
attrs := map[string]string{"mac": macAddr.String()}
group, err := core.SelectGroup(ctx, &pb.SelectGroupRequest{Labels: attrs})
if err != nil {
s.logger.WithFields(logrus.Fields{
"label": macAddr,
}).Infof("No matching group")
http.NotFound(w, req)
return
}
profile, err := core.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil {
s.logger.WithFields(logrus.Fields{
"label": macAddr,
"group": group.Id,
}).Infof("No profile named: %s", group.Profile)
http.NotFound(w, req)
return
}
// match was successful
s.logger.WithFields(logrus.Fields{
"label": macAddr,
"group": group.Id,
"profile": profile.Id,
}).Debug("Matched a Pixiecore config")
s.renderJSON(w, profile.Boot)
}
return ContextHandlerFunc(fn)
}
// pixiecoreHandler returns a handler that renders the boot config JSON for
// the requester, to implement the Pixiecore API specification.
// https://github.com/danderson/pixiecore/blob/master/README.api.md
func pixiecoreHandler(srv server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
macAddr, err := parseMAC(filepath.Base(req.URL.Path))
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// pixiecore only provides MAC addresses
attrs := map[string]string{"mac": macAddr.String()}
group, err := srv.SelectGroup(ctx, &pb.SelectGroupRequest{Labels: attrs})
if err != nil {
http.NotFound(w, req)
return
}
profile, err := srv.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil {
http.NotFound(w, req)
return
}
renderJSON(w, profile.Boot)
}
return ContextHandlerFunc(fn)
}
// ignitionHandler returns a handler that responds with the Ignition config
// for the requester. The Ignition file referenced in the Profile is parsed
// as raw Ignition (for .ign/.ignition) or rendered to a Fuze config (YAML)
// and converted to Ignition. Ignition configs are served as HTTP JSON
// responses.
func (s *Server) ignitionHandler(core server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
group, err := groupFromContext(ctx)
if err != nil {
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
}).Infof("No matching group")
http.NotFound(w, req)
return
}
profile, err := core.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil {
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
"group": group.Id,
"group_name": group.Name,
}).Infof("No profile named: %s", group.Profile)
http.NotFound(w, req)
return
}
contents, err := core.IgnitionGet(ctx, profile.IgnitionId)
if err != nil {
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
"group": group.Id,
"group_name": group.Name,
"profile": group.Profile,
}).Infof("No Ignition or Fuze template named: %s", profile.IgnitionId)
http.NotFound(w, req)
return
}
// match was successful
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
"group": group.Id,
"profile": profile.Id,
}).Debug("Matched an Ignition or Fuze template")
// Skip rendering if raw Ignition JSON is provided
if isIgnition(profile.IgnitionId) {
_, err := ignition.Parse([]byte(contents))
if err != nil {
s.logger.Warningf("warning parsing Ignition JSON: %v", err)
}
s.writeJSON(w, []byte(contents))
return
}
// Fuze Config template
// collect data for rendering
data := make(map[string]interface{})
if group.Metadata != nil {
err = json.Unmarshal(group.Metadata, &data)
if err != nil {
s.logger.Errorf("error unmarshalling metadata: %v", err)
http.NotFound(w, req)
return
}
}
data["query"] = req.URL.RawQuery
for key, value := range group.Selector {
data[strings.ToLower(key)] = value
}
// render the template for an Ignition config with data
var buf bytes.Buffer
err = s.renderTemplate(&buf, data, contents)
if err != nil {
http.NotFound(w, req)
return
}
// Parse fuze config into an Ignition config
config, err := fuze.ParseAsV2_0_0(buf.Bytes())
if err == nil {
s.renderJSON(w, config)
return
}
s.logger.Errorf("error parsing Ignition config: %v", err)
http.NotFound(w, req)
return
}
return ContextHandlerFunc(fn)
}
// ignitionHandler returns a handler that responds with the Ignition config
// for the requester. The Ignition file referenced in the Profile is rendered
// with metadata and parsed and validated as either YAML or JSON based on the
// extension. The Ignition config is served as an HTTP JSON response.
func ignitionHandler(srv server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
group, err := groupFromContext(ctx)
if err != nil || group.Profile == "" {
http.NotFound(w, req)
return
}
profile, err := srv.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil || profile.IgnitionId == "" {
http.NotFound(w, req)
return
}
contents, err := srv.IgnitionGet(ctx, profile.IgnitionId)
if err != nil {
http.NotFound(w, req)
return
}
// collect data for rendering Ignition Config
data := make(map[string]interface{})
if group.Metadata != nil {
err = json.Unmarshal(group.Metadata, &data)
if err != nil {
log.Errorf("error unmarshalling metadata: %v", err)
http.NotFound(w, req)
return
}
}
data["query"] = req.URL.RawQuery
for key, value := range group.Selector {
data[strings.ToLower(key)] = value
}
// render the template for an Ignition config with data
var buf bytes.Buffer
err = renderTemplate(&buf, data, contents)
if err != nil {
http.NotFound(w, req)
return
}
// Unmarshal YAML or JSON to Ignition V2
cfg, err := parseToV2(buf.Bytes())
if err == nil {
renderJSON(w, cfg)
return
}
// Unmarshal YAML or JSON to Ignition V1
oldCfg, err := parseToV1(buf.Bytes())
if err == nil {
renderJSON(w, oldCfg)
return
}
log.Errorf("error parsing Ignition config: %v", err)
http.NotFound(w, req)
return
}
return ContextHandlerFunc(fn)
}
// genericHandler returns a handler that responds with generic file for
// the requester.
func (s *Server) genericHandler(core server.Server) ContextHandler {
fn := func(ctx context.Context, w http.ResponseWriter, req *http.Request) {
group, err := groupFromContext(ctx)
if err != nil {
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
}).Infof("No matching group")
http.NotFound(w, req)
return
}
profile, err := core.ProfileGet(ctx, &pb.ProfileGetRequest{Id: group.Profile})
if err != nil {
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
"group": group.Id,
"group_name": group.Name,
}).Infof("No profile named: %s", group.Profile)
http.NotFound(w, req)
return
}
contents, err := core.GenericGet(ctx, profile.GenericId)
if err != nil {
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
"group": group.Id,
"group_name": group.Name,
"profile": group.Profile,
}).Infof("No generic template named: %s", profile.GenericId)
http.NotFound(w, req)
return
}
// match was successful
s.logger.WithFields(logrus.Fields{
"labels": labelsFromRequest(nil, req),
"group": group.Id,
"profile": profile.Id,
}).Debug("Matched a generic template")
// collect data for rendering
data := make(map[string]interface{})
if group.Metadata != nil {
err = json.Unmarshal(group.Metadata, &data)
if err != nil {
s.logger.Errorf("error unmarshalling metadata: %v", err)
http.NotFound(w, req)
return
}
}
data["query"] = req.URL.RawQuery
for key, value := range group.Selector {
data[strings.ToLower(key)] = value
}
// render the template of a generic config with data
var buf bytes.Buffer
err = s.renderTemplate(&buf, data, contents)
if err != nil {
http.NotFound(w, req)
return
}
config := buf.String()
http.ServeContent(w, req, "", time.Time{}, strings.NewReader(config))
}
return ContextHandlerFunc(fn)
}