func logsConfigSetHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
var requestData logsSetData
err := json.NewDecoder(r.Body).Decode(&requestData)
if err != nil {
return &errors.HTTP{
Code: http.StatusBadRequest,
Message: fmt.Sprintf("unable to parse body as json: %s", err),
}
}
requestConfig := requestData.Config
if len(requestConfig.Envs) > 0 && !permission.Check(t, permission.PermPoolUpdateLogs) {
return permission.ErrUnauthorized
}
for _, poolEnv := range requestConfig.Pools {
hasPermission := permission.Check(t, permission.PermPoolUpdateLogs,
permission.Context(permission.CtxPool, poolEnv.Name))
if !hasPermission {
return permission.ErrUnauthorized
}
}
dockerLog := container.DockerLog{}
err = dockerLog.Update(&requestConfig)
if err != nil {
return err
}
if requestData.Restart {
//TODO(cezarsa): restart containers
}
w.WriteHeader(http.StatusOK)
return nil
}
func (p *dockerProvisioner) LogsEnabled(app provision.App) (bool, string, error) {
const (
logBackendsEnv = "LOG_BACKENDS"
logDocKeyFormat = "LOG_%s_DOC"
tsuruLogBackendName = "tsuru"
)
logConf := container.DockerLog{}
isBS, err := logConf.IsBS(app.GetPool())
if err != nil {
return false, "", err
}
if !isBS {
driver, _, _ := logConf.LogOpts(app.GetPool())
msg := fmt.Sprintf("Logs not available through tsuru. Enabled log driver is %q.", driver)
return false, msg, nil
}
config, err := bs.LoadConfig([]string{app.GetPool()})
if err != nil {
return false, "", err
}
enabledBackends := config.PoolEntry(app.GetPool(), logBackendsEnv)
if enabledBackends == "" {
return true, "", nil
}
backendsList := strings.Split(enabledBackends, ",")
for i := range backendsList {
backendsList[i] = strings.TrimSpace(backendsList[i])
if backendsList[i] == tsuruLogBackendName {
return true, "", nil
}
}
var docs []string
for _, backendName := range backendsList {
keyName := fmt.Sprintf(logDocKeyFormat, strings.ToUpper(backendName))
backendDoc := config.PoolEntry(app.GetPool(), keyName)
var docLine string
if backendDoc == "" {
docLine = fmt.Sprintf("* %s", backendName)
} else {
docLine = fmt.Sprintf("* %s: %s", backendName, backendDoc)
}
docs = append(docs, docLine)
}
fullDoc := fmt.Sprintf("Logs not available through tsuru. Enabled log backends are:\n%s",
strings.Join(docs, "\n"))
return false, fullDoc, nil
}
func logsConfigSetHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
var requestData logsSetData
err := json.NewDecoder(r.Body).Decode(&requestData)
if err != nil {
return &errors.HTTP{
Code: http.StatusBadRequest,
Message: fmt.Sprintf("unable to parse body as json: %s", err),
}
}
requestConfig := requestData.Config
if len(requestConfig.Envs) > 0 && !permission.Check(t, permission.PermPoolUpdateLogs) {
return permission.ErrUnauthorized
}
updateAll := len(requestConfig.Envs) > 0
var receivedPools []string
for _, poolEnv := range requestConfig.Pools {
receivedPools = append(receivedPools, poolEnv.Name)
hasPermission := permission.Check(t, permission.PermPoolUpdateLogs,
permission.Context(permission.CtxPool, poolEnv.Name))
if !hasPermission {
return permission.ErrUnauthorized
}
}
dockerLog := container.DockerLog{}
err = dockerLog.Update(&requestConfig)
if err != nil {
return err
}
keepAliveWriter := tsuruIo.NewKeepAliveWriter(w, 15*time.Second, "")
defer keepAliveWriter.Stop()
writer := &tsuruIo.SimpleJsonMessageEncoderWriter{Encoder: json.NewEncoder(keepAliveWriter)}
fmt.Fprintln(writer, "Log config successfully updated.")
if requestData.Restart {
filter := &app.Filter{}
if !updateAll {
filter.Pools = receivedPools
}
tryRestartAppsByFilter(filter, writer)
}
return nil
}