Golang os.Error函数代码示例

// Expand expands a shortened url to long url.
// It returns the orgin url and nil if success, or empty string
// and an os.Error when failed.
func (req *Googl) Expand(url string) (string, os.Error) {
	res, err := req.get(url)
	if err != nil {
		return "", err
	}

	var temp map[string]string
	if err = json.Unmarshal([]byte(res), &temp); err != nil {
		return "", os.Error(err)
	}

	if _, ok := temp["code"]; ok {
		return "", os.NewError(temp["message"])
	}

	if status, _ := temp["status"]; "OK" != status {
		return "", os.NewError(status)
	}

	url, ok := temp["longUrl"]
	if !ok {
		return "", os.NewError("Invalid response")
	}

	return url, nil
}

// Project like Expand above.
// But this will return with short URL's analytics as a
// map[string]interface{} type.
func (req *Googl) Project(url, proj string) (map[string]interface{}, os.Error) {
	proj = strings.ToUpper(proj)
	if "FULL" != proj && "ANALYTICS_CLICKS" != proj && "ANALYTICS_TOP_STRINGS" != proj {
		return nil, os.EINVAL
	}

	res, err := req.get(url, map[string]string{"projection": proj})
	if err != nil {
		return nil, err
	}

	var temp map[string]interface{}
	if err = json.Unmarshal([]byte(res), &temp); err != nil {
		return nil, os.Error(err)
	}

	if _, ok := temp["code"]; ok {
		msg, _ := temp["message"].(string)

		return nil, os.NewError(msg)
	}

	if status, _ := temp["status"]; "OK" != status {
		msg, _ := status.(string)

		return nil, os.NewError(msg)
	}

	return temp, nil
}

func TestDecode(t *testing.T) {
	for _, p := range pairs {
		dbuf := make([]byte, StdEncoding.DecodedLen(len(p.encoded)))
		count, end, err := StdEncoding.decode(dbuf, []byte(p.encoded))
		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
		testEqual(t, "Decode(%q) = length %v, want %v", p.encoded, count, len(p.decoded))
		if len(p.encoded) > 0 {
			testEqual(t, "Decode(%q) = end %v, want %v", p.encoded, end, (p.encoded[len(p.encoded)-1] == '='))
		}
		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:count]), p.decoded)

		dbuf, err = StdEncoding.DecodeString(p.encoded)
		testEqual(t, "DecodeString(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
		testEqual(t, "DecodeString(%q) = %q, want %q", string(dbuf), p.decoded)
	}
}

func (req *Googl) get(url string, params ...map[string]string) (string, os.Error) {
	if !strings.Contains(url, "://goo.gl/") {
		return "", os.EINVAL
	}

	req_url := GOOGL_V1 + "?shortUrl=" + url
	if 0 < len(params) {
		for i := 0; i < len(params); i++ {
			req_url += "&" + toQuery(params[i])
		}
	}

	if "" != req.Key {
		req_url += "&key=" + req.Key
	}

	res, _, err := http.Get(req_url)
	defer res.Body.Close()
	if err != nil {
		return "", os.Error(err)
	}

	body, _ := ioutil.ReadAll(res.Body)

	return string(body), nil
}

// Elect chooses a seed node, and returns a connection to a cal.
// If this process is the seed, returns nil.
func elect(name, id, laddr string, b *doozer.Conn) *doozer.Conn {
	// advertise our presence, since we might become a cal
	nspath := "/ctl/ns/" + name + "/" + id
	r, err := b.Set(nspath, 0, []byte(laddr))
	if err != nil {
		panic(err)
	}

	// fight to be the seed
	_, err = b.Set("/ctl/boot/"+name, 0, []byte(id))
	switch err {
	case os.Error(doozer.ErrOldRev):
		// we lost, lookup addresses again
		cl := lookupAndAttach(b, name)
		if cl == nil {
			panic("failed to attach after losing election")
		}

		// also delete our entry, since we're not officially a cal yet.
		// it gets set again in peer.Main when we become a cal.
		err := b.Del(nspath, r)
		if err != nil {
			panic(err)
		}

		return cl
	case nil:
		return nil // we are the seed node -- don't attach
	}
	panic(err)
}

func TestDecode(t *testing.T) {
	for _, p := range gitPairs {
		dbuf := make([]byte, 4*len(p.encoded))
		ndst, err := Decode(dbuf, strings.Bytes(p.encoded))
		testEqual(t, "Decode(%q) = error %v, want %v", p.encoded, err, os.Error(nil))
		testEqual(t, "Decode(%q) = ndst %v, want %v", p.encoded, ndst, len(p.decoded))
		testEqual(t, "Decode(%q) = %q, want %q", p.encoded, string(dbuf[0:ndst]), p.decoded)
	}
}

func TestEncoderBuffering(t *testing.T) {
	input := []byte(bigtest.decoded)
	for bs := 1; bs <= 12; bs++ {
		bb := &bytes.Buffer{}
		encoder := NewEncoder(StdEncoding, bb)
		for pos := 0; pos < len(input); pos += bs {
			end := pos + bs
			if end > len(input) {
				end = len(input)
			}
			n, err := encoder.Write(input[pos:end])
			testEqual(t, "Write(%q) gave error %v, want %v", input[pos:end], err, os.Error(nil))
			testEqual(t, "Write(%q) gave length %v, want %v", input[pos:end], n, end-pos)
		}
		err := encoder.Close()
		testEqual(t, "Close gave error %v, want %v", err, os.Error(nil))
		testEqual(t, "Encoding/%d of %q = %q, want %q", bs, bigtest.decoded, bb.String(), bigtest.encoded)
	}
}

func TestAlertForwarding(t *testing.T) {
	c, s := net.Pipe()
	go func() {
		Client(c, testConfig).sendAlert(alertUnknownCA)
		c.Close()
	}()

	err := Server(s, testConfig).Handshake()
	s.Close()
	if e, ok := err.(*net.OpError); !ok || e.Error != os.Error(alertUnknownCA) {
		t.Errorf("Got error: %s; expected: %s", err, alertUnknownCA)
	}
}

func readFunc(size int) appendFunc {
	return func(f Form, out []byte, s string) []byte {
		out = append(out, s...)
		r := f.Reader(bytes.NewBuffer(out))
		buf := make([]byte, size)
		result := []byte{}
		for n, err := 0, os.Error(nil); err == nil; {
			n, err = r.Read(buf)
			result = append(result, buf[:n]...)
		}
		return result
	}
}

//first function to get called
func init() {
	http.HandleFunc("/", hello)                            //main page to display
	http.HandleFunc("/recalculate", recalculate)           //page with results
	http.HandleFunc("/keepDataUpToDate", keepDataUpToDate) //function for keeping data up to date

	//initialize variables with dummy values
	LastCheckTime = 0

	CurrentDifficulty = 1.0
	CurrentExchangeRate = 1.0

	//initialize the default values
	DefaultCalc.Difficulty = CurrentDifficulty
	DefaultCalc.HashRate = 100.0
	DefaultCalc.ExchangeRate = CurrentExchangeRate
	DefaultCalc.BitcoinsPerBlock = 50.0
	DefaultCalc.DisplayResults = false

	DefaultCalc.RigCost = 0.0
	DefaultCalc.PowerConsumption = 200.0
	DefaultCalc.PowerCost = 0.1

	DefaultCalc.DifficultyStr = fmt.Sprintf("%.2f", DefaultCalc.Difficulty)
	DefaultCalc.HashRateStr = fmt.Sprintf("%.2f", DefaultCalc.HashRate)
	DefaultCalc.ExchangeRateStr = fmt.Sprintf("%.2f", DefaultCalc.ExchangeRate)
	DefaultCalc.BitcoinsPerBlockStr = fmt.Sprintf("%.2f", DefaultCalc.BitcoinsPerBlock)

	DefaultCalc.RigCostStr = fmt.Sprintf("%.2f", DefaultCalc.RigCost)
	DefaultCalc.PowerConsumptionStr = fmt.Sprintf("%.2f", DefaultCalc.PowerConsumption)
	DefaultCalc.PowerCostStr = fmt.Sprintf("%.2f", DefaultCalc.PowerCost)

	err := os.Error(nil)
	CalcTemplate = template.New(nil)
	CalcTemplate.SetDelims("{{", "}}")                  //changing Delims from {} to {{}} to be able to run the Flattr script
	err = CalcTemplate.ParseFile("tpbitcalc/calc.html") //parses the HTML file. Produces errors if default delims are used because of Flattr code

	//logs an error
	if err != nil {
		log.Print("init err ", err)
		//http.Error(w, err.String(), http.StatusInternalServerError)
		return

	}
}

// Shorten shortens long url to short url.
// It returns the shortened url and nil if success, or empty
// string and an os.Error when failed.
func (req *Googl) Shorten(url string) (string, os.Error) {
	res, err := req.post(url)
	if err != nil {
		return "", err
	}

	var temp map[string]string
	if err = json.Unmarshal([]byte(res), &temp); err != nil {
		return "", os.Error(err)
	}

	if _, ok := temp["code"]; ok {
		return "", os.NewError(temp["message"])
	}

	id, ok := temp["id"]
	if !ok {
		return "", os.NewError("Invalid response!")
	}

	return id, nil
}

func (req *Googl) post(url string) (string, os.Error) {
	if strings.Contains(url, "://goo.gl/") {
		return fmt.Sprintf("{\n \"kind\": \"urlshortener#url\",\n \"id\": \"%s\",\n \"longUrl\": \"%s\"\n}", url, url), nil
	}

	req_url := GOOGL_V1
	if "" != req.Key {
		req_url += "?key=" + req.Key
	}

	buf := bytes.NewBuffer(nil)
	buf.WriteString(fmt.Sprintf(`{"longUrl": "%s"}`, url))

	res, err := http.Post(req_url, "application/json", buf)
	if err != nil {
		return "", os.Error(err)
	}

	body, _ := ioutil.ReadAll(res.Body)

	return string(body), nil
}

type DeepEqualTest struct {
	a, b interface{}
	eq   bool
}

var deepEqualTests = []DeepEqualTest{
	// Equalities
	{1, 1, true},
	{int32(1), int32(1), true},
	{0.5, 0.5, true},
	{float32(0.5), float32(0.5), true},
	{"hello", "hello", true},
	{make([]int, 10), make([]int, 10), true},
	{&[3]int{1, 2, 3}, &[3]int{1, 2, 3}, true},
	{Basic{1, 0.5}, Basic{1, 0.5}, true},
	{os.Error(nil), os.Error(nil), true},
	{map[int]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, true},

	// Inequalities
	{1, 2, false},
	{int32(1), int32(2), false},
	{0.5, 0.6, false},
	{float32(0.5), float32(0.6), false},
	{"hello", "hey", false},
	{make([]int, 10), make([]int, 11), false},
	{&[3]int{1, 2, 3}, &[3]int{1, 2, 4}, false},
	{Basic{1, 0.5}, Basic{1, 0.6}, false},
	{Basic{1, 0}, Basic{2, 0}, false},
	{map[int]string{1: "one", 3: "two"}, map[int]string{2: "two", 1: "one"}, false},
	{map[int]string{1: "one", 2: "txo"}, map[int]string{2: "two", 1: "one"}, false},
	{map[int]string{1: "one"}, map[int]string{2: "two", 1: "one"}, false},

func TestDecoderBuffering(t *testing.T) {
	for bs := 1; bs <= 12; bs++ {
		decoder := NewDecoder(StdEncoding, bytes.NewBufferString(bigtest.encoded))
		buf := make([]byte, len(bigtest.decoded)+12)
		var total int
		for total = 0; total < len(bigtest.decoded); {
			n, err := decoder.Read(buf[total : total+bs])
			testEqual(t, "Read from %q at pos %d = %d, %v, want _, %v", bigtest.encoded, total, n, err, os.Error(nil))
			total += n
		}
		testEqual(t, "Decoding/%d of %q = %q, want %q", bs, bigtest.encoded, string(buf[0:total]), bigtest.decoded)
	}
}

func (n *Network) Whois(target []string, server string) (map[string][]string, os.Error) { //TODO: return a map[string][][]string? map[string][]IrcMessage?
	t := strconv.Itoa64(time.Nanoseconds())
	ret := make(map[string][]string)
	ticker := time.NewTicker(timeout(n.lag))
	myreplies := []string{"ERR_NOSUCHSERVER", "ERR_NONICKNAMEGIVEN",
		"RPL_WHOISUSER", "RPL_WHOISCHANNELS",
		"RPL_WHOISSERVER", "RPL_AWAY",
		"RPL_WHOISOPERATOR", "RPL_WHOISIDLE",
		"ERR_NOSUCHNICK", "RPL_ENDOFWHOIS"}
	repch := make(chan *IrcMessage, 10)
	defer func(myreplies []string, t string) {
		for _, rep := range myreplies {
			n.Listen.DelListener(replies[rep], t)
		}
		return
	}(myreplies, t)
	for _, rep := range myreplies {
		if err := n.Listen.RegListener(replies[rep], t, repch); err != nil {
			ticker.Stop()
			return ret, os.NewError(fmt.Sprintf("Couldn't whois %s=%s: %s", replies[rep], rep, err.String()))
		}
	}

	if server == "" {
		n.queueOut <- &IrcMessage{"", "WHOIS", []string{strings.Join(target, ",")}}
	} else {
		n.queueOut <- &IrcMessage{"", "WHOIS", []string{server, strings.Join(target, ",")}}
	}
	for _, rep := range myreplies {
		ret[replies[rep]] = make([]string, 0)
	}
	done := 0
	err := os.Error(nil)
	for {
		select {
		case m := <-repch:
			ret[m.Cmd] = append(ret[m.Cmd], strings.Join((*m).Params, " "))
			if m.Cmd == replies["RPL_ENDOFWHOIS"] {
				ticker.Stop()
				return ret, err
			} else if m.Cmd == replies["ERR_NOSUCHNICK"] {
				for _, targ := range target {
					if m.Params[1] == targ {
						if err == nil {
							err = os.NewError(fmt.Sprintf("No such nick: %s", targ))
						} else {
							err = os.NewError(fmt.Sprintf("%s, No such nick: %s", err.String(), targ))
						}
						done++
					}
				}
				if done == len(target) {
					return ret, err
				}
			}
			ticker.Stop()
			ticker = time.NewTicker(timeout(n.lag)) //restart the ticker to timeout correctly
		case <-ticker.C:
			ticker.Stop()
			return ret, err
		}
	}
	ticker.Stop()
	return ret, err //BUG: why do we need this?
}