func (ws *webServer) DelMachineVariable(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
macStr := vars["mac"]
name := vars["name"]
var machineInterface datasource.MachineInterface
if macStr != "" {
mac, err := net.ParseMAC(macStr)
if err != nil {
http.Error(w, `{"error": "Error while parsing the mac"}`, http.StatusInternalServerError)
return
}
machineInterface = ws.ds.MachineInterface(mac)
}
var err error
machineInterface.DeleteVariable(name)
if err != nil {
http.Error(w, `{"error": "Error while delleting value"}`, http.StatusInternalServerError)
return
}
io.WriteString(w, `"OK"`)
}
func machineToDetails(machineInterface datasource.MachineInterface) (*machineDetails, error) {
name := machineInterface.Hostname()
mac := machineInterface.Mac()
machine, err := machineInterface.Machine(false, nil)
if err != nil {
return nil, errors.New("error in retrieving machine details")
}
last, _ := machineInterface.LastSeen()
return &machineDetails{
name, mac.String(),
machine.IP, machine.Type,
machine.FirstSeen, last}, nil
}
func executeTemplate(rootTemplte *template.Template, templateName string,
ds datasource.DataSource, machineInterface datasource.MachineInterface,
webServerAddr string) (string, error) {
template := rootTemplte.Lookup(templateName)
if template == nil {
return "", fmt.Errorf("template with name=%s wasn't found for root=%v",
templateName, rootTemplte)
}
mac := machineInterface.Mac().String()
buf := new(bytes.Buffer)
template.Funcs(map[string]interface{}{
"V": func(key string) string {
value, err := machineInterface.GetVariable(key)
if err != nil {
log.WithField("where", "templating.executeTemplate").WithError(err).Warn(
"error while GetVariable")
}
return value
},
"b64": func(text string) string {
return base64.StdEncoding.EncodeToString([]byte(text))
},
"b64template": func(templateName string) string {
text, err := executeTemplate(rootTemplte, templateName, ds, machineInterface, webServerAddr)
if err != nil {
log.WithField("where", "templating.executeTemplate").WithError(err).Warnf(
"error while executeTemplate(templateName=%s machine=%s)",
templateName, mac)
return ""
}
return base64.StdEncoding.EncodeToString([]byte(text))
},
})
etcdMembers, _ := ds.EtcdMembers()
machine, err := machineInterface.Machine(false, nil)
if err != nil {
return "", err
}
data := struct {
Mac string
IP string
Hostname string
Domain string
WebServerAddr string
EtcdEndpoints string
}{
mac,
machine.IP.String(),
machineInterface.Hostname(),
ds.ClusterName(),
webServerAddr,
etcdMembers,
}
err = template.ExecuteTemplate(buf, templateName, &data)
if err != nil {
return "", err
}
str := buf.String()
str = strings.Trim(str, "\n")
return str, nil
}
