github.com/Cloud-Foundations/Dominator@v0.3.4/dom/herd/listSubs.go (about)

     1  package herd
     2  
     3  import (
     4  	"bufio"
     5  	"fmt"
     6  	"net/http"
     7  
     8  	"github.com/Cloud-Foundations/Dominator/lib/json"
     9  	"github.com/Cloud-Foundations/Dominator/lib/tags/tagmatcher"
    10  	"github.com/Cloud-Foundations/Dominator/lib/url"
    11  	proto "github.com/Cloud-Foundations/Dominator/proto/dominator"
    12  )
    13  
    14  func (herd *Herd) listSubsHandlerWithSelector(w http.ResponseWriter,
    15  	selectFunc func(*Sub) bool, parsedQuery url.ParsedQuery) {
    16  	writer := bufio.NewWriter(w)
    17  	defer writer.Flush()
    18  	subs := herd.getSelectedSubs(selectFunc)
    19  	switch parsedQuery.OutputType() {
    20  	case url.OutputTypeText:
    21  	case url.OutputTypeHtml:
    22  		for _, sub := range subs {
    23  			fmt.Fprintln(writer, sub.mdb.Hostname)
    24  		}
    25  	case url.OutputTypeJson:
    26  		subNames := make([]string, 0, len(subs))
    27  		for _, sub := range subs {
    28  			subNames = append(subNames, sub.mdb.Hostname)
    29  		}
    30  		json.WriteWithIndent(writer, "  ", subNames)
    31  		fmt.Fprintln(writer)
    32  	}
    33  }
    34  
    35  func (herd *Herd) listReachableSubsHandler(w http.ResponseWriter,
    36  	req *http.Request) {
    37  	parsedQuery := url.ParseQuery(req.URL)
    38  	selector, err := herd.getReachableSelector(parsedQuery)
    39  	if err != nil {
    40  		fmt.Fprintln(w, err)
    41  		return
    42  	}
    43  	herd.listSubsHandlerWithSelector(w, selector, parsedQuery)
    44  }
    45  
    46  func (herd *Herd) listUnreachableSubsHandler(w http.ResponseWriter,
    47  	req *http.Request) {
    48  	parsedQuery := url.ParseQuery(req.URL)
    49  	selector, err := herd.getUnreachableSelector(parsedQuery)
    50  	if err != nil {
    51  		fmt.Fprintln(w, err)
    52  		return
    53  	}
    54  	herd.listSubsHandlerWithSelector(w, selector, parsedQuery)
    55  }
    56  
    57  func (herd *Herd) listSubs(request proto.ListSubsRequest) ([]string, error) {
    58  	selectFunc := makeSelector(request.LocationsToMatch,
    59  		request.StatusesToMatch, tagmatcher.New(request.TagsToMatch, false))
    60  	if len(request.Hostnames) < 1 {
    61  		return herd.selectSubs(selectFunc), nil
    62  	}
    63  	subNames := make([]string, 0, len(request.Hostnames))
    64  	herd.RLock()
    65  	defer herd.RUnlock()
    66  	for _, hostname := range request.Hostnames {
    67  		if sub, ok := herd.subsByName[hostname]; ok {
    68  			if selectFunc(sub) {
    69  				subNames = append(subNames, hostname)
    70  			}
    71  		}
    72  	}
    73  	return subNames, nil
    74  }
    75  
    76  func (herd *Herd) listSubsHandler(w http.ResponseWriter, req *http.Request) {
    77  	writer := bufio.NewWriter(w)
    78  	defer writer.Flush()
    79  	parsedQuery := url.ParseQuery(req.URL)
    80  	subNames := herd.selectSubs(makeUrlQuerySelector(req.URL.Query()))
    81  	switch parsedQuery.OutputType() {
    82  	case url.OutputTypeText:
    83  	case url.OutputTypeHtml:
    84  		for _, name := range subNames {
    85  			fmt.Fprintln(writer, name)
    86  		}
    87  	case url.OutputTypeJson:
    88  		json.WriteWithIndent(writer, "  ", subNames)
    89  		fmt.Fprintln(writer)
    90  	}
    91  }
    92  
    93  func (herd *Herd) selectSubs(selectFunc func(sub *Sub) bool) []string {
    94  	herd.RLock()
    95  	defer herd.RUnlock()
    96  	subNames := make([]string, 0, len(herd.subsByIndex))
    97  	for _, sub := range herd.subsByIndex {
    98  		if selectFunc(sub) {
    99  			subNames = append(subNames, sub.mdb.Hostname)
   100  		}
   101  	}
   102  	return subNames
   103  }