// title: remove node container list
// path: /docker/nodecontainers
// method: GET
// produce: application/json
// responses:
// 200: Ok
// 401: Unauthorized
func nodeContainerList(w http.ResponseWriter, r *http.Request, t auth.Token) error {
pools, err := permission.ListContextValues(t, permission.PermNodecontainerRead, true)
if err != nil {
return err
}
lst, err := nodecontainer.AllNodeContainers()
if err != nil {
return err
}
if pools != nil {
poolMap := map[string]struct{}{}
for _, p := range pools {
poolMap[p] = struct{}{}
}
for i, entry := range lst {
for poolName := range entry.ConfigPools {
if poolName == "" {
continue
}
if _, ok := poolMap[poolName]; !ok {
delete(entry.ConfigPools, poolName)
}
}
lst[i] = entry
}
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(lst)
}
// title: node healing info
// path: /healing/node
// method: GET
// produce: application/json
// responses:
// 200: Ok
// 401: Unauthorized
func nodeHealingRead(w http.ResponseWriter, r *http.Request, t auth.Token) error {
pools, err := permission.ListContextValues(t, permission.PermHealingRead, true)
if err != nil {
return err
}
configMap, err := healer.GetConfig()
if err != nil {
return err
}
if len(pools) > 0 {
allowedPoolSet := map[string]struct{}{}
for _, p := range pools {
allowedPoolSet[p] = struct{}{}
}
for k := range configMap {
if k == "" {
continue
}
if _, ok := allowedPoolSet[k]; !ok {
delete(configMap, k)
}
}
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(configMap)
}
// title: node container info
// path: /docker/nodecontainers/{name}
// method: GET
// produce: application/json
// responses:
// 200: Ok
// 401: Unauthorized
// 404: Not found
func nodeContainerInfo(w http.ResponseWriter, r *http.Request, t auth.Token) error {
pools, err := permission.ListContextValues(t, permission.PermNodecontainerRead, true)
if err != nil {
return err
}
name := r.URL.Query().Get(":name")
configMap, err := nodecontainer.LoadNodeContainersForPools(name)
if err != nil {
if err == nodecontainer.ErrNodeContainerNotFound {
return &tsuruErrors.HTTP{
Code: http.StatusNotFound,
Message: err.Error(),
}
}
return err
}
if pools != nil {
poolMap := map[string]struct{}{}
for _, p := range pools {
poolMap[p] = struct{}{}
}
for poolName := range configMap {
if poolName == "" {
continue
}
if _, ok := poolMap[poolName]; !ok {
delete(configMap, poolName)
}
}
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(configMap)
}
// title: logs config
// path: /docker/logs
// method: GET
// produce: application/json
// responses:
// 200: Ok
// 401: Unauthorized
func logsConfigGetHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
pools, err := permission.ListContextValues(t, permission.PermPoolUpdateLogs, true)
if err != nil {
return err
}
configEntries, err := container.LogLoadAll()
if err != nil {
return err
}
w.Header().Set("Content-Type", "application/json")
if len(pools) == 0 {
return json.NewEncoder(w).Encode(configEntries)
}
newMap := map[string]container.DockerLogConfig{}
for _, p := range pools {
if entry, ok := configEntries[p]; ok {
newMap[p] = entry
}
}
return json.NewEncoder(w).Encode(newMap)
}
// title: list nodes
// path: /{provisioner}/node
// method: GET
// produce: application/json
// responses:
// 200: Ok
// 204: No content
func listNodesHandler(w http.ResponseWriter, r *http.Request, t auth.Token) error {
pools, err := permission.ListContextValues(t, permission.PermNodeRead, false)
if err != nil {
return err
}
provs, err := provision.Registry()
if err != nil {
return err
}
provNameMap := map[string]string{}
var allNodes []provision.Node
for _, prov := range provs {
nodeProv, ok := prov.(provision.NodeProvisioner)
if !ok {
continue
}
var nodes []provision.Node
nodes, err = nodeProv.ListNodes(nil)
if err != nil {
return err
}
for _, n := range nodes {
provNameMap[n.Address()] = prov.GetName()
}
allNodes = append(allNodes, nodes...)
}
if pools != nil {
filteredNodes := make([]provision.Node, 0, len(allNodes))
for _, node := range allNodes {
for _, pool := range pools {
if node.Pool() == pool {
filteredNodes = append(filteredNodes, node)
break
}
}
}
allNodes = filteredNodes
}
iaases, err := permission.ListContextValues(t, permission.PermMachineRead, false)
if err != nil {
return err
}
machines, err := iaas.ListMachines()
if err != nil {
return err
}
if iaases != nil {
filteredMachines := make([]iaas.Machine, 0, len(machines))
for _, machine := range machines {
for _, iaas := range iaases {
if machine.Iaas == iaas {
filteredMachines = append(filteredMachines, machine)
break
}
}
}
machines = filteredMachines
}
if len(allNodes) == 0 && len(machines) == 0 {
w.WriteHeader(http.StatusNoContent)
return nil
}
nodesJson := make([]json.RawMessage, len(allNodes))
for i, n := range allNodes {
nodesJson[i], err = provision.NodeToJSON(n)
if err != nil {
return err
}
}
result := listNodeResponse{
Nodes: nodesJson,
Machines: machines,
}
w.Header().Set("Content-Type", "application/json")
return json.NewEncoder(w).Encode(result)
}