Example #1
0
func (d DeployList) Humanize(body io.Reader) string {
	dec := json.NewDecoder(body)
	var deploys Deploys
	e := dec.Decode(&deploys)
	Check(e == nil, "failed to unmarshal response", e)
	title := "DEPLOYID VERSION PROGRESS APPS\n"
	var b bytes.Buffer
	for _, deploy := range deploys {
		b.WriteString(deploy.DeployID)
		b.WriteString(" ")
		b.WriteString(deploy.Version)
		b.WriteString(" ")
		b.WriteString(strconv.Itoa(deploy.CurrentStep))
		b.WriteString("/")
		b.WriteString(strconv.Itoa(deploy.TotalSteps))
		b.WriteString(" ")
		for _, app := range deploy.AffectedApps {
			b.WriteString(app)
		}
		b.UnreadRune()
		b.WriteString("\n")
	}
	text := title + b.String()
	return Columnize(text)
}
Example #2
0
func readRawMsgBytes(buf *bytes.Buffer) ([]byte, error) {
	nilChar, _, err := buf.ReadRune()
	if err == io.EOF {
		return nil, nil
	}

	// see if there is a nil char
	if nilChar == '-' {
		return nil, nil
	}

	buf.UnreadRune()

	data := buf.Next(buf.Len())

	return data, nil
}
Example #3
0
func ParseSData(buf *bytes.Buffer) (*sysmsg.StrctData, error) {
	var sData *sysmsg.StrctData
	startChar, _, err := buf.ReadRune()

	if err != nil {
		return sData, err
	}
	// [ = 91
	// ] = 93
	// \ = 92

	if startChar == '-' {
		return nil, nil
	}

	// if it doesn't start with '[' return error
	if startChar != 91 {
		return sData, BadSDErr
	}

	buf.UnreadRune()

	// now, there exists SData, parse it
	readSData := true
	endSData := false
	//[exampleSDID iut="3" eventSource="Application" eventID="1011"][examplePriority@32473 class="high"]
	var element sysmsg.SDElement
	var readParam bool

loop:
	for {
		startChar, _, err := buf.ReadRune()

		if err == io.EOF && endSData {
			return sData, nil
		} else if err != nil {
			return sData, err
		}

		switch {
		case startChar == '[' || readSData:
			//fmt.Println("begin SData")
			readSData = false
			endSData = false
			id, err := parseSDName(buf, sysmsg.SP_VAL_BYTE)
			//fmt.Println("Parsed ID ", id)
			if err != nil {
				return sData, err
			}
			element = sysmsg.SDElement{}
			element.Id = id
			element.Params = make([]sysmsg.SDParam, 0, 2)
			readParam = true
			break

		case startChar == sysmsg.SP_VAL_BYTE || readParam:
			//fmt.Println("begin SData SP")

			// step back one char
			if readParam {
				buf.UnreadRune()
			}

			readParam = false
			if endSData {
				break loop
			}

			name, err := parseSDName(buf, '=')
			if err != nil {
				return sData, err
			}

			val, err := parseSDParamVal(buf)
			if err != nil {
				return sData, err
			}

			param := sysmsg.SDParam{name, val}
			element.Params = append(element.Params, param)

			break

		case startChar == ']':
			//fmt.Println("end SData")
			endSData = true
			if sData == nil {
				sData = &sysmsg.StrctData{}
				sData.Elements = make([]sysmsg.SDElement, 0, 2)
			}

			sData.Elements = append(sData.Elements, element)
			continue loop
		}
	}

	fmt.Println("completed parsing SData", sData)

	return sData, nil
}
Example #4
0
func buffer2word(source bytes.Buffer, removeQuote bool) string {
	var buffer bytes.Buffer

	lastchar := ' '
	quoteNow := NOTQUOTED
	yenCount := 0
	for {
		ch, _, err := source.ReadRune()
		if err != nil {
			break
		}
		if ch == '~' && unicode.IsSpace(lastchar) {
			if home := dos.GetHome(); home != "" {
				buffer.WriteString(home)
			} else {
				buffer.WriteRune('~')
			}
			lastchar = '~'
			continue
		}
		if ch == '%' && quoteNow != '\'' && yenCount%2 == 0 {
			var nameBuf bytes.Buffer
			for {
				ch, _, err = source.ReadRune()
				if err != nil {
					buffer.WriteRune('%')
					nameBuf.WriteTo(&buffer)
					return buffer.String()
				}
				if ch == '%' {
					if value, ok := OurGetEnv(nameBuf.String()); ok {
						buffer.WriteString(value)
					} else {
						buffer.WriteRune('%')
						nameBuf.WriteTo(&buffer)
						buffer.WriteRune('%')
					}
					break
				}
				if ch == '=' {
					source.UnreadRune()
					buffer.WriteRune('%')
					nameBuf.WriteTo(&buffer)
					break
				}
				nameBuf.WriteRune(ch)
			}
			continue
		}

		if quoteNow != NOTQUOTED && ch == quoteNow && yenCount%2 == 0 {
			if !removeQuote {
				buffer.WriteRune(ch)
			}
			// Close Quotation.
			for ; yenCount >= 2; yenCount -= 2 {
				buffer.WriteRune('\\')
			}
			quoteNow = NOTQUOTED
		} else if (ch == '\'' || ch == '"') && quoteNow == NOTQUOTED && yenCount%2 == 0 {
			if !removeQuote {
				buffer.WriteRune(ch)
			}
			// Open Qutation.
			for ; yenCount >= 2; yenCount -= 2 {
				buffer.WriteRune('\\')
			}
			quoteNow = ch
			if ch == lastchar {
				buffer.WriteRune(ch)
			}
		} else {
			if ch == '\\' {
				yenCount++
			} else if ch == '\'' || ch == '"' {
				for ; yenCount >= 2; yenCount -= 2 {
					buffer.WriteRune('\\')
				}
				yenCount = 0
				buffer.WriteRune(ch)
			} else {
				for ; yenCount > 0; yenCount-- {
					buffer.WriteRune('\\')
				}
				buffer.WriteRune(ch)
			}
		}
		lastchar = ch
	}
	for ; yenCount > 0; yenCount-- {
		buffer.WriteRune('\\')
	}
	return buffer.String()
}
Example #5
0
// Generic Request Handling
func (n NetkiRequester) ProcessRequest(partner *NetkiPartner, uri string, method string, bodyData string) (*simplejson.Json, error) {
	var supported_methods = [...]string{"GET", "POST", "PUT", "DELETE"}
	var isSupportedMethod = false

	// make sure we have a supported HTTP method
	for _, val := range supported_methods {
		if val == method {
			isSupportedMethod = true
		}
	}

	if !isSupportedMethod {
		return &simplejson.Json{}, &NetkiError{fmt.Sprintf("Unsupported HTTP Method: %s", method), make([]string, 0)}
	}

	buf := new(bytes.Buffer)
	if bodyData != "" {
		_, err := buf.WriteString(bodyData)
		if err != nil {
			return &simplejson.Json{}, &NetkiError{"Unable to Write Request Data to Buffer", make([]string, 0)}
		}
	}

	// Create Our Request
	buffer := new(bytes.Buffer)
	buffer.WriteString(partner.ApiUrl)
	if !strings.HasSuffix(partner.ApiUrl, "/") {
		buffer.UnreadRune()
	}
	buffer.WriteString(uri)

	req, err := http.NewRequest(method, buffer.String(), buf)
	req.Header.Set("Content-Type", "application/json")
	if partner.PartnerId == "" && partner.UserKey != nil {
		sig, err := n.SignRequest(buffer.String(), bodyData, partner.UserKey)
		if err != nil {
			return &simplejson.Json{}, err
		}
		req.Header.Set("X-Identity", partner.GetUserPublicKey())
		req.Header.Set("X-Signature", sig)
		req.Header.Set("X-Partner-Key", partner.GetKeySigningKey())
		req.Header.Set("X-Partner-KeySig", hex.EncodeToString(partner.KeySignature))
	} else {
		req.Header.Set("X-Partner-ID", partner.PartnerId)
		req.Header.Set("Authorization", partner.ApiKey)
	}

	// See if we have an injected HTTPClient
	var client *http.Client
	if n.HTTPClient == nil {
		client = http.DefaultClient
	} else {
		client = n.HTTPClient
	}

	// Send Our Request
	resp, err := client.Do(req)
	if err != nil {
		return &simplejson.Json{}, &NetkiError{fmt.Sprintf("HTTP Request Failed: %s", err), make([]string, 0)}
	}

	// DELETE with 204 Response, Don't Care About Response Data
	if method == "DELETE" && resp.StatusCode == http.StatusNoContent {
		return &simplejson.Json{}, nil
	}

	// Close the body when we're done with the function
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return &simplejson.Json{}, &NetkiError{fmt.Sprintf("HTTP Body Read Failed: %s", err), make([]string, 0)}
	}

	// Get Our JSON Data
	js, err := simplejson.NewJson(body)
	if err != nil {
		return &simplejson.Json{}, &NetkiError{fmt.Sprintf("Error Retrieving JSON Data: %s", err), make([]string, 0)}
	}

	// Return message if success is false
	if !js.Get("success").MustBool(false) {
		errMsg := new(bytes.Buffer)
		errMsg.WriteString(js.Get("message").MustString())
		resp, _ := js.Get("failures").Array()
		if resp != nil {
			errMsg.WriteString(" [FAILURES: ")
			failures := make([]string, 0)
			for i := 0; i < len(js.Get("failures").MustArray()); i++ {
				failures = append(failures, js.Get("failures").GetIndex(i).Get("message").MustString())
			}
			errMsg.WriteString(strings.Join(failures, ", "))
			errMsg.WriteString("]")
		}
		return &simplejson.Json{}, &NetkiError{errMsg.String(), make([]string, 0)}
	}

	return js, nil

}
Example #6
0
func dequote(source *bytes.Buffer) string {
	var buffer bytes.Buffer

	lastchar := ' '
	quoteNow := NOTQUOTED
	yenCount := 0
	for {
		ch, _, err := source.ReadRune()
		if err != nil {
			break
		}
		if ch == '~' && unicode.IsSpace(lastchar) {
			if home := dos.GetHome(); home != "" {
				buffer.WriteString(home)
			} else {
				buffer.WriteRune('~')
			}
			lastchar = '~'
			continue
		}
		if ch == '%' && quoteNow != '\'' && yenCount%2 == 0 {
			var nameBuf bytes.Buffer
			for {
				ch, _, err = source.ReadRune()
				if err != nil {
					buffer.WriteRune('%')
					buffer.WriteString(nameBuf.String())
					return buffer.String()
				}
				if ch == '%' {
					nameStr := nameBuf.String()
					value := os.Getenv(nameStr)
					if value != "" {
						buffer.WriteString(value)
					} else if m := rxUnicode.FindStringSubmatch(nameStr); m != nil {
						ucode, _ := strconv.ParseInt(m[1], 16, 32)
						buffer.WriteRune(rune(ucode))
					} else if f, ok := PercentFunc[nameStr]; ok {
						buffer.WriteString(f())
					} else {
						buffer.WriteRune('%')
						buffer.WriteString(nameStr)
						buffer.WriteRune('%')
					}
					break
				}
				if !unicode.IsLower(ch) && !unicode.IsUpper(ch) && !unicode.IsNumber(ch) && ch != '_' && ch != '+' {
					source.UnreadRune()
					buffer.WriteRune('%')
					buffer.WriteString(nameBuf.String())
					break
				}
				nameBuf.WriteRune(ch)
			}
			continue
		}

		if quoteNow != NOTQUOTED && ch == quoteNow && yenCount%2 == 0 {
			// Close Quotation.
			for ; yenCount >= 2; yenCount -= 2 {
				buffer.WriteRune('\\')
			}
			quoteNow = NOTQUOTED
		} else if (ch == '\'' || ch == '"') && quoteNow == NOTQUOTED && yenCount%2 == 0 {
			// Open Qutation.
			for ; yenCount >= 2; yenCount -= 2 {
				buffer.WriteRune('\\')
			}
			quoteNow = ch
			if ch == lastchar {
				buffer.WriteRune(ch)
			}
		} else {
			if ch == '\\' {
				yenCount++
			} else if ch == '\'' || ch == '"' {
				for ; yenCount >= 2; yenCount -= 2 {
					buffer.WriteRune('\\')
				}
				yenCount = 0
				buffer.WriteRune(ch)
			} else {
				for ; yenCount > 0; yenCount-- {
					buffer.WriteRune('\\')
				}
				buffer.WriteRune(ch)
			}
		}
		lastchar = ch
	}
	for ; yenCount > 0; yenCount-- {
		buffer.WriteRune('\\')
	}
	return buffer.String()
}