Пример #1
0
func (c *client) purge(host string, f gfind.File, k int, id int) {
	var Url *url.URL
	Url, err := url.Parse(host)
	chkErr(err)
	Url.Path += "/purge"
	Url.Path += f.Relpath
	var u string
	u = Url.String()
	if security != "" {
		u += "?" + ParseNgxSecurityLink(security, host, f)
	}
	req, err := http.NewRequest("HEAD", u, nil)
	req.Close = true
	if vhost != "client.com" {
		req.Host = vhost
	}
	resp, err := c.c.Do(req)
	chkErr(err)
	if resp.StatusCode == 200 {
		color.Printf("%6v-%-2d @{g}%-17v@{|} %v %v\n", k, id, "PURGE:SUCCESS", Url.String(), f.Size())
	} else if resp.StatusCode == 404 {
		color.Printf("%6v-%-2d @{y}%-17v@{|} %v %v\n", k, id, "PURGE:NOFILE", Url.String(), f.Size())
	}

}
Пример #2
0
func output(hostname, servicename, v interface{}) {
	// define quick color/graphic view of output
	var s, m, a string
	if state(v) == 0 {
		s = color.Sprintf("@{g}%-10s", "[OK]")
	} else if state(v) == 1 {
		s = color.Sprintf("@{y}%-10s", "[WARNING]")
	} else if state(v) == 2 {
		s = color.Sprintf("@{r}%-10s", "[CRITICAL]")
	}
	if notifications(v) {
		m = color.Sprintf("@{g}  %v  ", ` `)
	} else {
		m = color.Sprintf("@{r}  %v  ", `Ø`)
	}
	if acknowledged(v) {
		a = color.Sprintf("@{g}  %v  ", `√`)
	} else {
		a = color.Sprintf("@{g}  %v  ", ` `)
	}

	// this just incase if change mind use different syntax
	switch v := v.(type) {
	default:
	case *nagiosToJson.Hoststatus:
		// 		color.Printf("%-10s: %v %v %v %v %v\n", hostname, m, s, a, v.Plugin_output, time.Since(str2time(v.Last_check)))
		color.Printf("%-10s: %-10v %v %v %v %v %v\n", hostname, servicename, m, s, a, v.Plugin_output, time.Since(str2time(v.Last_check)))
	case *nagiosToJson.Servicestatus:
		color.Printf("%-10s: %-10v %v %v %v %v %v\n", hostname, servicename, m, s, a, v.Plugin_output, time.Since(str2time(v.Last_check)))
	}
}
func readWholeNumber(prompt string, bits int, unsigned bool, allowBlank bool, defaultValue int64) (out int64, err error) {
	var iu uint64
	var i int64

loop:
	for {
		fmt.Print(prompt)

		line, err := readLine()

		if strings.TrimSpace(line) == "" && allowBlank {
			if unsigned {
				iu = uint64(defaultValue)
			} else {
				i = defaultValue
			}

			break loop
		}

		if unsigned {
			iu, err = strconv.ParseUint(string(line), 10, bits)
		} else {
			i, err = strconv.ParseInt(string(line), 10, bits)
		}

		if err != nil {
			numError := err.(*strconv.NumError)

			switch numError.Err {
			case strconv.ErrSyntax:
				if unsigned {
					color.Printf("@{r}%s is not a non-negative integer\n", numError.Num)
				} else {
					color.Printf("@{r}%s is not a integer\n", numError.Num)
				}
				continue loop
			case strconv.ErrRange:
				color.Printf("@{r}%s does not fit in %d bits\n", numError.Num, bits)
				continue loop
			default:
				color.Printf("@{r}Unknown error %s\n", numError)
				continue loop
			}
		}

		break loop
	}

	if unsigned {
		out = int64(iu)
	} else {
		out = i
	}

	return
}
Пример #4
0
Файл: main.go Проект: kiyor/stf
// dump request , body true/false, print true/false
func dumpResponse(r *http.Response, b, p bool, host string) []byte {
	dump, err := httputil.DumpResponse(r, b)
	if err != nil {
		log.Println(err.Error())
	}
	// 	isGzip := false
	// 	if v, ok := r.Header["Accept-Encoding"]; ok {
	// 		if strings.Contains(v[0], "gzip") {
	// 			isGzip = true
	// 			log.Println("is gzip")
	// 		}
	// 	}
	if p {
		index := bytes.Index(dump, []byte("\r\n\r\n"))
		headers := dump[:index]
		body := bytes.TrimLeft(dump[index:], "\r\n\r\n")
		// 		body = bytes.TrimLeft(body, string([]byte{13, 10, 13, 10}))

		// 		if isGzip {
		// 			reader := bytes.NewReader(body)
		// 			g, err := gzip.NewReader(reader)
		// 			if err != nil {
		// 				log.Println(err.Error())
		// 			}
		// 			body, err = ioutil.ReadAll(g)
		// 			if err != nil {
		// 				log.Println(err.Error())
		// 			}
		// 		}
		if *veryverbose {
			now := time.Now()
			dirname := "/tmp/stfdump/" + host
			if _, err := os.Stat(dirname); err != nil {
				if err := os.MkdirAll(dirname, 0755); err != nil {
					log.Fatalln(err.Error())
				}
			}
			filename := fmt.Sprintf("%s/%d<", dirname, now.UnixNano())
			ioutil.WriteFile(filename, body, 0644)
		}
		if *colors {
			// 			color.Printf("@{b}%s@{|}", string(dump))
			color.Printf("@{c}%v@{|}\n", string(headers))
			if *showBody {
				color.Printf("@{g}%v@{|}\n", string(body))
			}
			// 			color.Printf("@{g}%v@{|}\n", ehex.EncodeToString(body))
			// 			color.Printf("@{g}%v@{|}\n", body)
		} else {
			// 			fmt.Print(string(dump))
			fmt.Println(string(headers))
			fmt.Println(string(body))
		}
	}
	return dump
}
Пример #5
0
func (self *Case) reportFailWithDiff(lhs, rhs interface{}) {
	if lhs != nil && rhs != nil {
		if s1, ok := lhs.(string); ok {
			s2 := rhs.(string)
			self.printDiff(s1, s2)
			return
		}
	}

	color.Printf("@r...@| expected @g%s = %v@|\n", mustTypeName(lhs), lhs)
	color.Printf("@r...@|   actual @r%s = %v@|\n", mustTypeName(rhs), rhs)
}
Пример #6
0
func query(name, qtype string) {
	start := time.Now()
	qname, err := idna.ToASCII(name)
	if err != nil {
		color.Fprintf(os.Stderr, "Invalid IDN domain name: %s\n", name)
		os.Exit(1)
	}

	rrs, err := resolver.ResolveErr(qname, qtype)

	color.Printf("\n")
	if len(rrs) > 0 {
		color.Printf("@{g};; RESULTS:\n")
	}
	for _, rr := range rrs {
		color.Printf("@{g}%s\n", rr.String())
	}

	if err != nil {
		color.Printf("@{r};; %s\t%s\t%s\n", err, name, qtype)
	} else if rrs == nil {
		color.Printf("@{y};; NIL\t%s\t%s\n", name, qtype)
	} else if len(rrs) > 0 {
		color.Printf("@{g};; TRUE\t%s\t%s\n", name, qtype)
	} else {
		color.Printf("@{r};; FALSE\t%s\t%s\n", name, qtype)
	}

	color.Printf("@{.w};; Elapsed: %s\n", time.Since(start).String())
}
Пример #7
0
func (self *Case) reportFail(depth int, lhs, rhs interface{}, msg string, op int) {
	self.location(depth + 1)
	color.Printf("@r---@| FAIL %s\n", msg)

	switch op {
	case eq:
		fallthrough
	case throw:
		self.reportFailWithDiff(lhs, rhs)
	case ne:
		color.Printf("@r...@| expected @g%s = %v@|\n", mustTypeName(lhs), lhs)
		color.Printf("@r...@|   but is @requals@|\n")
	}
	self.numFail++
}
Пример #8
0
func observeChannel(resultRepository <-chan *github.Repository, networkErr <-chan error) (*github.Repository, error) {
	var repository *github.Repository
	var err error
getLoop:
	for {
		select {
		case repository = <-resultRepository:
			break getLoop
		case getErr := <-networkErr:
			fmt.Printf("\n\n")
			color.Printf("@{r} !!! Error Occuered !!! ")
			fmt.Printf("\n\n")
			fmt.Println(getErr)
			fmt.Printf("\n\n")
			break getLoop
		case <-time.After(time.Minute):
			fmt.Println(" @{r} !!! Timeout !!! ")
			break getLoop
		default:
			time.Sleep(time.Second / 2)
			fmt.Printf(".")
		}
	}
	return repository, err
}
Пример #9
0
func main() {
	flag.Usage = func() {
		color.Fprintf(os.Stderr, "Usage: %s [arguments] <name> [type]\n\nAvailable arguments:\n", os.Args[0])
		flag.PrintDefaults()
		os.Exit(1)
	}
	flag.Parse()
	qtype := ""
	args := flag.Args()
	if len(args) == 0 {
		flag.Usage()
	} else if _, isType := dns.StringToType[args[len(args)-1]]; len(args) > 1 && isType {
		qtype, args = args[len(args)-1], args[:len(args)-1]
	}
	if verbose {
		dnsr.DebugLogger = os.Stderr
	}
	var wg sync.WaitGroup
	start := time.Now()
	for _, name := range args {
		wg.Add(1)
		go func(name string, qtype string) {
			query(name, qtype)
			wg.Done()
		}(name, qtype)
	}
	wg.Wait()
	if len(args) > 1 {
		color.Printf("\n@{.w};; Total elapsed: %s\n", time.Since(start).String())
	}
}
Пример #10
0
// Update project details
// http://docs.gemnasium.apiary.io/#patch-%2Fprojects%2F%7Bslug%7D
func (p *Project) Update(name, desc *string, monitored *bool) error {
	if name == nil && desc == nil && monitored == nil {
		return errors.New("Please specify at least one thing to update (name, desc, or monitored")
	}

	update := make(map[string]interface{})
	if name != nil {
		update["name"] = *name
	}
	if desc != nil {
		update["desc"] = *desc
	}
	if monitored != nil {
		update["monitored"] = *monitored
	}
	opts := &gemnasium.APIRequestOptions{
		Method: "PATCH",
		URI:    fmt.Sprintf("/projects/%s", p.Slug),
		Body:   update,
	}
	err := gemnasium.APIRequest(opts)
	if err != nil {
		return err
	}

	color.Printf("@gProject %s updated succesfully\n", p.Slug)
	return nil
}
Пример #11
0
func (self *Case) Fail() {
	self.location(2)
	color.Printf("@r---@| FAIL %s\n", self.what)
	self.what = ""
	self.numFail++
	panic(self)
}
Пример #12
0
func (p *Printer) Printf(fmtstr string, args ...interface{}) {
	if p.NoColors {
		fmtstr = removeMeta.ReplaceAllLiteralString(fmtstr, "")
		fmt.Printf(fmtstr, args...)
	} else {
		color.Printf(fmtstr, args...)
	}
}
Пример #13
0
func (v *GRVisitor) SearchFile(fn string, content []byte) {
	lines := IntList([]int{})
	binary := false

	if bytes.IndexByte(content, 0) != -1 {
		binary = true
	}

	for _, info := range v.FindAllIndex(content) {
		if lines.Contains(info.num) {
			continue
		}

		if v.prependNewLine {
			fmt.Println("")
			v.prependNewLine = false
		}

		first := len(lines) == 0
		lines = append(lines, info.num)

		if first {
			if binary && !*onlyName {
				fmt.Printf("Binary file %s matches\n", fn)
				break
			} else {
				color.Printf("@g%s\n", fn)
			}
		}

		if *onlyName {
			return
		}

		color.Printf("@!@y%d:", info.num)
		coloredLine := v.pattern.ReplaceAllStringFunc(string(info.line),
			func(wrap string) string {
				return color.Sprintf("@Y%s", wrap)
			})
		fmt.Printf("%s\n", coloredLine)
	}

	if len(lines) > 0 {
		v.prependNewLine = true
	}
}
Пример #14
0
func doCreate(c *cli.Context) {
	name := c.Args().First()
	if len(name) == 0 {
		return
	}

	// check configuration
	configuration, err := OpenConfiguration()
	if err != nil {
		fmt.Println(err)
		return
	}
	if configuration.GithubToken == "" {
		configuration.GithubToken = PromptPersonalGithubToken()
		configuration.Persist()
	}

	// set repository attributes
	newRepository := github.Repository{Name: &name}
	prompt := c.Bool(flagDetail)
	if description := GetRepositryField(flagDesc, c.String(flagDesc), prompt).(string); description != "" {
		newRepository.Description = &description
	}
	if homepage := GetRepositryField(flagHP, c.String(flagHP), prompt).(string); homepage != "" {
		newRepository.Homepage = &homepage
	}
	if teamid := GetRepositryField(flagTeamID, c.Int(flagTeamID), prompt).(int); teamid != 0 {
		newRepository.TeamID = &teamid
	}
	private := GetRepositryField(flagPrivate, c.Bool(flagPrivate), prompt).(bool)
	newRepository.Private = &private
	issue := GetRepositryField(flagIssue, c.Bool(flagIssue), prompt).(bool)
	newRepository.HasIssues = &issue
	wiki := GetRepositryField(flagWiki, c.Bool(flagWiki), prompt).(bool)
	newRepository.HasWiki = &wiki
	download := GetRepositryField(flagDownload, c.Bool(flagDownload), prompt).(bool)
	newRepository.HasDownloads = &download

	// create repository
	org := c.String(flagOrg)
	client := NewClient(configuration)
	repository, _ := observeChannel(client.CreateRepository(org, &newRepository))
	if repository == nil {
		return
	}

	output := "\n\n" +
		"=========================\n" +
		"                         \n" +
		"@{g}* We are sccessful in Creating a repository! Push an existing repository from the command line@{|}\n" +
		"                         \n" +
		"git remote add origin %s \n" +
		"git push -u origin master\n" +
		"                         \n" +
		"=========================\n" +
		"\n\n"
	color.Printf(output, *repository.GitURL)
}
Пример #15
0
func (p *Printer) Printf(colorfmt, plainfmt string,
	args ...interface{}) {

	if p.NoColors {
		fmt.Printf(plainfmt, args...)
	} else {
		color.Printf(colorfmt, args...)
	}
}
Пример #16
0
// define output in one place, make it clean
func title() {
	// use HOST as host check servicename
	// 	if *mutehost != "" {
	// 		color.Printf("%-10s: %v %-10v %v %v\n", "hostname", "alert", "state", "acked", "output")
	// 	}
	// 	if *muteservice != "" {
	color.Printf("%-10s: %-10v %v %-10v %v %v\n", "hostname", "srvname", "alert", "state", "acked", "output")
	// 	}
}
Пример #17
0
func (self *Batch) val() interface{} {
	if self.index >= len(self.returnVals) {
		self.c.location(1)
		color.Printf("@r---@| FAIL: too many check values, max: %v\n", len(self.returnVals))
		self.c.numFail++
		panic(self.c)
	}
	return self.returnVals[self.index]
}
Пример #18
0
func (c *BalanceCommand) Run() error {
	user := &models.User{}
	user.Id = db.USERID
	amount, err := user.GetBalance()
	if err != nil {
		return err
	}
	color.Printf("@gBalance: %f\n", amount)
	return nil
}
Пример #19
0
func (v *GRVisitor) ReplaceInFile(fn string, content []byte) (changed bool, result []byte) {
	changed = false
	binary := false
	changenum := 0

	if *singleline {
		errhandle(
			fmt.Errorf("Can't handle singleline replacements yet"),
			true, "")
	}

	if *plaintext {
		errhandle(
			fmt.Errorf("Can't handle plain text replacements yet"),
			true, "")
	}

	if bytes.IndexByte(content, 0) != -1 {
		binary = true
	}

	result = v.pattern.ReplaceAllFunc(content, func(s []byte) []byte {
		if binary && !*force {
			errhandle(
				fmt.Errorf("supply --force to force change of binary file"),
				false, "")
		}
		if !changed {
			changed = true
			color.Printf("@g%s", fn)
		}

		changenum += 1
		return []byte(*replace)
	})

	if changenum > 0 {
		color.Printf("@!@y - %d change%s made\n",
			changenum, getSuffix(changenum))
	}

	return changed, result
}
Пример #20
0
// uses color if availible
func smartPrintf(format string, a ...interface{}) (cnt int, err error) {
	pattern := regexp.MustCompile(`@.`)
	if useColor {
		cnt, err = color.Printf(format, a...)
	} else {
		rawFormat := pattern.ReplaceAll([]byte(format), []byte(""))
		cnt, err = fmt.Printf(string(rawFormat), a...)
	}
	return
}
Пример #21
0
func (s *LoggingServer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	s.mu.RLock()
	defer s.mu.RUnlock()

	if i := sort.SearchStrings(s.ExcludePaths, req.URL.Path); i < len(s.ExcludePaths) && req.URL.Path == s.ExcludePaths[i] {
		return
	}

	req.ParseForm()

	// Log request
	var data string
	for key, _ := range req.Form {
		data += "\n    "
		if value := req.Form.Get(key); value != "" {
			data += color.Sprintf("@.%s@|@w = @|%s", key, value)
		} else {
			data += color.Sprintf("%s", key)
		}
	}

	log.Print(color.Sprintf("@c%s @{!y}%s", req.Method, req.RequestURI))
	if data != "" {
		color.Printf("  @bRequest@|%s\n", data)
	}

	// Find matcher
	matcher := s.findMatcher(req)
	if matcher != nil {
		matcher.Write(w, req)
		// TODO Better response logging
		response := matcher.Response

		color.Printf("  @gResponse@|\n    %+v\n", response)
	} else {
		color.Print("  @rUnmatched@|\n")

		w.WriteHeader(http.StatusNotFound)
		w.Header().Set("Content-Type", "text/html")
		io.WriteString(w, "<html><body>Unmatched request, please configure a mock request for path "+req.URL.Path+" and method "+req.Method+"</body></html>\n")
	}
}
Пример #22
0
func (self *Case) location(depth int) {
	if _, file, line, ok := runtime.Caller(depth); ok {
		lines, err := self.cache.Put(file)
		if err != io.EOF {
			panic(err)
		}

		file = self.fileName(file)
		color.Printf("@r---@| %s.%s %s:%d:\n%s\n", self.suiteName, self.name, file, line, lines[line-1])
	}
}
Пример #23
0
func printDCR(dcr *epp.DomainCheckResponse) {
	if dcr == nil {
		return
	}
	av := make(map[string]bool)
	for _, c := range dcr.Checks {
		av[c.Domain] = c.Available
		if c.Available {
			color.Printf("@{g}%s\tavail=%t\treason=%q\n", c.Domain, c.Available, c.Reason)
		} else {
			color.Printf("@{y}%s\tavail=%t\treason=%q\n", c.Domain, c.Available, c.Reason)
		}
	}
	for _, c := range dcr.Charges {
		if av[c.Domain] {
			color.Printf("@{g}%s\tcategory=%s\tname=%q\n", c.Domain, c.Category, c.CategoryName)
		} else {
			color.Printf("@{y}%s\tcategory=%s\tname=%q\n", c.Domain, c.Category, c.CategoryName)
		}
	}
}
Пример #24
0
func largestWithNodes(c *cli.Context) {
	debug := true
	command := "find / ! -readable -prune -type f -printf '%s %p\n' 2> /dev/null | sort -nr | head -n 15"

	if c.Bool("sudo") == true {
		command = fmt.Sprintf("/usr/bin/sudo -n bash <<CMD\nexport PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin\n%s\nCMD", command)
	} else {
		command = fmt.Sprintf("/bin/bash <<CMD\nexport PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/root/bin\n%s\nCMD", command)
	}

	if debug {
		color.Printf("@{b}%s\n", command)
	}

	var conns []string
	if c.IsSet("nodes") {
		conns = filterHosts(strings.Split(c.String("nodes"), ","))
	} else if c.IsSet("node") {
		conns = filterHosts(c.StringSlice("node"))
	} else {
		fmt.Errorf("Node or Nodes must be specified")
	}

	pathToSizeAndNodes := make(map[string]sizeByNodes)

	results := runSsh(conns, command, debug)
	for _, r := range results {
		lines := strings.Split(r.Res, "\n")
		for _, line := range lines {
			items := strings.Fields(line)
			fmt.Println(items[0])
			fmt.Println(items[1])

			path := items[1]

			if _, ok := pathToSizeAndNodes[path]; ok == false {
				size, err := strconv.ParseUint(items[0], 0, 0)
				if err != nil {
					panic(err)
				}
				pathToSizeAndNodes[path] = sizeByNodes{Size: size, Nodes: []string{r.Host}}
			} else {
				nodes := append(pathToSizeAndNodes[path].Nodes, r.Host)
				pathToSizeAndNodes[path] = sizeByNodes{Size: pathToSizeAndNodes[path].Size, Nodes: nodes}
			}
		}
	}

	for _, res := range sortedKeys(pathToSizeAndNodes) {
		fmt.Printf("%s\t%s\t%v\n", humanize.Bytes(pathToSizeAndNodes[res].Size), res, pathToSizeAndNodes[res].Nodes)
	}
}
Пример #25
0
func (self *Case) printDiff(s1, s2 string) {
	s1, s2 = formatize("    ", s1), formatize("    ", s2)
	color.Printf("@r...@| expected @gstring =@|\n%v\n", s1)
	color.Printf("@r...@|   actual @rstring =@|\n%v\n", s2)
	color.Printf("@r...@|  diff is\n")

	state := dmp.New()
	diffs := state.DiffMain(s1, s2, false)
	for _, diff := range diffs {
		switch diff.Type {
		case dmp.DiffEqual:
			fmt.Print(diff.Text)

		case dmp.DiffDelete:
			color.Printf("@r[-%s]@|", diff.Text)

		case dmp.DiffInsert:
			color.Printf("@g[+%s]@|", diff.Text)
		}
	}
	fmt.Println()
}
Пример #26
0
// Start project synchronization
// http://docs.gemnasium.apiary.io/#post-%2Fprojects%2F%7Bslug%7D%2Fsync
func (p *Project) Sync() error {
	opts := &gemnasium.APIRequestOptions{
		Method: "POST",
		URI:    fmt.Sprintf("/projects/%s/sync", p.Slug),
	}
	err := gemnasium.APIRequest(opts)
	if err != nil {
		return err
	}

	color.Printf("@gSynchronization started for project %s\n", p.Slug)
	return nil
}
Пример #27
0
func showHelp() {
	fmt.Println()
	color.Printf(
		`  * HELP *
 @{Kg}/chat [ID]@{|}	Start a chat with [ID]
 @{Kg}/end      @{|}	End current chat
 @{Kg}/add  [ID]@{|}	Add [ID] to roster
 @{Kg}/mkg      @{|}	Generate new group id
 @{Kg}/help     @{|}	Show this message
 @{Kg}/stat     @{|}	Show node status
 @{Kg}/exit     @{|}	Exit this program`)
	fmt.Println()
}
Пример #28
0
/**
* Central function for printing
 */
func print(level int, message string) {

	if !beenhere {
		startTime = time.Now()
		beenhere = true
	}

	if _level >= level {

		//
		// Escape newlines and carriage returns
		//
		message = strings.Replace(message, "\n", "\\n", -1)
		message = strings.Replace(message, "\r", "\\r", -1)

		//
		// Escape anything else that is below ASCII 32 (space)
		// This is done because backspace (ASCII 8) is especially evil,
		// as an attrack could inject backspaces to hide their tracks
		//
		re, _ := regexp.Compile("([\x00-\x1f])")
		message = re.ReplaceAllStringFunc(message, func(in string) string {
			return (fmt.Sprintf("[0x%x]", in))
		})

		//
		// If displayTime is uninitialized, default to true
		//
		if displayTime == 0 || displayTime == 2 {
			now := time.Now()
			elapsed := now.Sub(startTime)
			if UseColor() {
				color_string := getColor(level)
				color.Printf(color_string+"[%s] %s\n", elapsed, message)
			} else {
				fmt.Printf("[%s] %s\n", elapsed, message)
			}

		} else {
			if UseColor() {
				color_string := getColor(level)
				color.Println(color_string + message)
			} else {
				fmt.Println(message)
			}

		}

	}

} // End of print()
Пример #29
0
func printGitlabProjectIssues(gitlab *gogitlab.Gitlab, projectId int) {

	page := 1
	for {
		issues, err := gitlab.ProjectIssues(projectId, page)
		if err != nil {
			log.Fatal(err.Error())
			return
		}
		if len(issues) == 0 {
			break
		}

		for _, issue := range issues {
			if issue.State == "closed" {
				color.Printf("@r[%4d(%d)] [%s] %s state=%s\n", issue.Id, issue.LocalId, issue.Title, issue.Description, issue.State)
			} else {
				color.Printf("@g[%4d(%d)] [%s] %s state=%s\n", issue.Id, issue.LocalId, issue.Title, issue.Description, issue.State)
			}
		}

		page++
	}
}
Пример #30
0
func AddLocations(zones map[string]*Zone, locations []string) {
	var added, modified int
	for _, z := range zones {
		s := NewSet(z.Locations...)
		n := len(s)
		s.Add(locations...)
		m := len(s) - n
		if m != 0 {
			z.Locations = s.Values()
			added += m
			modified++
		}
	}
	color.Printf("@{.}Added %d locations(s) to %d zone(s)\n", added, modified)
}