Golang napping.Session类代码示例

func main() {

	// Start Session
	s := napping.Session{}
	url := BASE_URL + "get/sample"
	fmt.Println("URL:>", url)

	fmt.Println("--------------------------------------------------------------------------------")
	println("")

	fooParams := napping.Params{"md5": SAMPLE, "apikey": API_KEY}
	p := fooParams

	res := ResponseUserAgent{}
	resp, err := s.Post(url, &p, &res, nil)
	if err != nil {
		fmt.Println("Error in request")
	}
	//
	// Process response
	//
	println("")
	fmt.Println("response Status:", resp.Status())
	fmt.Println("--------------------------------------------------------------------------------")
	fmt.Println("Header")
	fmt.Println(resp.HttpResponse().Header)
	fmt.Println("--------------------------------------------------------------------------------")
	fmt.Println("RawText")
	fmt.Println(resp.RawText())
	println("")
}

func instruct(a *Coaction) *NodeResp {
	fmt.Println("Instructed " + a.Instruction + " for id " + strconv.Itoa(a.Id))
	v, _ := streamlut[a.Id]
	url := "http://127.0.0.1:" + strconv.Itoa(v.Rconf.Lport) + "/player/" + a.Instruction
	fmt.Println("Instructed as " + url)
	var answer NodeResp
	e := struct {
		Message string
		Errors  []struct {
			Resource string
			Field    string
			Code     string
		}
	}{}
	s := napping.Session{}

	var forwarder *Forwarder = nil

	if (a.Instruction == "alterviewpoint") || (a.Instruction == "mouseclick") {
		forwarder = &Forwarder{a.Cmdargs}
	}
	resp, err := s.Post(url, forwarder, &answer, &e)

	if err != nil {
		return &NodeResp{false, err.Error()}
	}

	if resp.Status() != 200 {
		return &NodeResp{false, strconv.Itoa(resp.Status()) + "..." + e.Message}
	}

	return &answer
}

func main() {
	//
	// Struct to hold error response
	//
	e := struct {
		Message string
	}{}

	// Start Session
	s := napping.Session{}
	url := "http://httpbin.org/user-agent"
	fmt.Println("URL:>", url)

	res := ResponseUserAgent{}
	resp, err := s.Get(url, nil, &res, nil)
	if err != nil {
		log.Fatal(err)
	}
	//
	// Process response
	//
	println("")
	fmt.Println("response Status:", resp.Status())

	if resp.Status() == 200 {
		// fmt.Printf("Result: %s\n\n", resp.response)
		// resp.Unmarshal(&e)
		fmt.Println("res:", res.Useragent)
	} else {
		fmt.Println("Bad response status from Github server")
		fmt.Printf("\t Status:  %v\n", resp.Status())
		fmt.Printf("\t Message: %v\n", e.Message)
	}
	fmt.Println("--------------------------------------------------------------------------------")
	println("")

	url = "http://httpbin.org/get"
	fmt.Println("URL:>", url)
	fooParams := napping.Params{"foo": "bar"}
	p := fooParams

	res = ResponseUserAgent{}
	resp, err = s.Get(url, &p, &res, nil)
	if err != nil {
		log.Fatal(err)
	}
	//
	// Process response
	//
	println("")
	fmt.Println("response Status:", resp.Status())
	fmt.Println("--------------------------------------------------------------------------------")
	fmt.Println("Header")
	fmt.Println(resp.HttpResponse().Header)
	fmt.Println("--------------------------------------------------------------------------------")
	fmt.Println("RawText")
	fmt.Println(resp.RawText())
	println("")
}

func (u *UserInfo) Get(token oauth2.Token) {
	ns := napping.Session{}
	ns.Header = &http.Header{}
	ns.Header.Add("Authorization", "Bearer "+token.AccessToken)
	url := settings.UnifiedApiEndpointUrl + "/me"
	resp, err := ns.Get(url, nil, &u, nil)
	if err != nil {
		log.Fatal(err)
	}
	if resp.Status() == 200 {
		fmt.Println("Loaded profile for :", u.Displayname)
	} else {
		fmt.Println("Bad response status from office365 unified api")
		fmt.Println("Raw Response Text : %s", resp.RawText())
	}
}

func callPeer(watchmetadata *Watchmedata, destination *utilities.OPData, queue *lane.Queue, verb string, wg *sync.WaitGroup) {
	defer wg.Done()

	target := "http://" + destination.Ovip + ":" + strconv.Itoa(destination.Announceport) + "/ovp"
	url := target + "/" + verb
	fmt.Println("Instructed as " + url)
	e := struct {
		Message string
		Errors  []struct {
			Resource string
			Field    string
			Code     string
		}
	}{}

	var j map[string]interface{}

	s := napping.Session{}

	resp, err := s.Post(url, watchmetadata, &j, &e)

	if err != nil {
		log.Printf("failed to " + verb + " on " + target + " because " + err.Error())
		return
	}

	if resp.Status() != 200 {
		log.Printf("failed to " + verb + " on " + target + " because " + strconv.Itoa(resp.Status()) + "..." + e.Message)
		return
	}

	if verb == "withdraw" || verb == "update" {
		source := watchmetadata.OPConfig
		if j["Status"].(bool) {
			queue.Enqueue(destination)
		} else {
			mesg := fmt.Sprintf("Not "+verb+" %+v from %+v", source, destination)
			panic(mesg)
		}
	}
	queue.Enqueue(*destination)
}

func getRESTResponse(url string, p *url.Values, result interface{}) {
	//
	// Struct to hold error response
	//
	e := struct {
		Message string
	}{}

	s := napping.Session{}
	resp, err := s.Get(url, p, result, e)
	if err != nil {
		log.Fatal(err)
	}
	Trace.Printf("%s Return Status [%v]", url, resp.Status())
	if resp.Status() == 200 {
		return
	} else {
		log.Fatal("Resource could not be fetched")
		log.Fatal("\t Status:  %v\n", resp.Status())
		log.Fatal("\t Message: %v\n", e.Message)
	}
}

func (s *TestSuite) TestAllRight(c *C) {
	BASE_URL := "http://127.0.0.1:9999"
	cur_dir, err := os.Getwd()
	if err != nil {
		c.Error(err)
	}
	test_file := path.Join(cur_dir, "temp/a.png")
	finite_url := BASE_URL + test_file
	log.Println(finite_url)

	// ============ authenticate ==================
	session := napping.Session{
		Userinfo: url.UserPassword("admin", "admin"),
	}
	//  ==========================================
	for i := 1; i <= 10; i++ {
		log.Println("Working ", i)
		result := IdioticJSON{}
		payload := StandartJSON{}
		payload["Artist"] = uuid.NewV4().String()
		payload["Author"] = uuid.NewV4().String()
		payload["Comment"] = uuid.NewV4().String()
		payload["Copyright"] = uuid.NewV4().String()
		// wait for server to be up ..
		_, err = session.Post(finite_url, &payload, &result, nil)
		for err != nil {
			_, err := session.Post(finite_url, &payload, &result, nil)
			if err == nil {
				break
			}
		}
		c.Assert(result.Items[0]["Artist"], Equals, payload["Artist"])
		c.Assert(result.Items[0]["Author"], Equals, payload["Author"])
		c.Assert(result.Items[0]["Comment"], Equals, payload["Comment"])
		c.Assert(result.Items[0]["Copyright"], Equals, payload["Copyright"])
	}
}

func goCrestEMDRBridge() {

	var err error

	type regionKey struct {
		RegionID int64
		TypeID   int64
	}

	type marketRegions struct {
		RegionID   int64  `db:"regionID"`
		RegionName string `db:"regionName"`
	}

	type marketTypes struct {
		TypeID   int64  `db:"typeID"`
		TypeName string `db:"typeName"`
	}

	// Pool of CREST sessions
	crestSession := napping.Session{}
	regions := []marketRegions{}
	types := []marketTypes{}
	stations = make(map[int64]int64)

	// Scope to allow garbage colect to reclaim startup data.
	{
		type crestRegions_s struct {
			TotalCount_Str string
			Items          []struct {
				HRef string
				Name string
			}
			PageCount  int64
			TotalCount int64
		}

		type crestTypes_s struct {
			TotalCount_Str string
			Items          []struct {
				Type struct {
					ID   int64
					Name string
				}
			}
			PageCount  int64
			TotalCount int64
			Next       struct {
				HRef string `json:"href,omitempty"`
			}
		}

		// Collect Regions from CREST servers.
		crestRegions := crestRegions_s{}
		_, err = crestSession.Get(crestUrl+"regions/", nil, &crestRegions, nil)
		fatalCheck(err)

		// Extract the ID out of the URI.
		for _, r := range crestRegions.Items {
			re := regexp.MustCompile("([0-9]+)")
			regionID, _ := strconv.ParseInt(re.FindString(r.HRef), 10, 64)
			regions = append(regions, marketRegions{regionID, r.Name})
		}
		log.Printf("Loaded %d Regions", len(regions))

		// Collect Types from CREST servers.
		crestTypes := crestTypes_s{}
		_, err = crestSession.Get(crestUrl+"market/types/", nil, &crestTypes, nil)
		fatalCheck(err)

		// Translate the first page.
		for _, t := range crestTypes.Items {
			types = append(types, marketTypes{t.Type.ID, t.Type.Name})
		}

		// Loop the next pages.
		for {
			last := crestTypes.Next.HRef

			_, err = crestSession.Get(crestTypes.Next.HRef, nil, &crestTypes, nil)
			fatalCheck(err)
			for _, t := range crestTypes.Items {
				types = append(types, marketTypes{t.Type.ID, t.Type.Name})
			}

			if crestTypes.Next.HRef == last {
				break
			}
		}

		log.Printf("Loaded %d Types", len(types))

		// Load NPC stations from file.
		file, err := os.Open("stations")
		fatalCheck(err)
		defer file.Close()
		reader := csv.NewReader(file)
		reader.Comma = '\t' // Tab delimited.

		for {
//.........这里部分代码省略.........

func main() {
	//
	// Prompt user for Github username/password
	//
	var username string
	fmt.Printf("Github username: ")
	_, err := fmt.Scanf("%s", &username)
	if err != nil {
		log.Fatal(err)
	}
	passwd, err := gopass.GetPass("Github password: ")
	if err != nil {
		log.Fatal(err)
	}
	//
	// Compose request
	//
	// http://developer.github.com/v3/oauth/#create-a-new-authorization
	//
	payload := struct {
		Scopes []string `json:"scopes"`
		Note   string   `json:"note"`
	}{
		Scopes: []string{"public_repo"},
		Note:   "testing Go napping" + time.Now().String(),
	}
	//
	// Struct to hold response data
	//
	res := struct {
		Id        int
		Url       string
		Scopes    []string
		Token     string
		App       map[string]string
		Note      string
		NoteUrl   string `json:"note_url"`
		UpdatedAt string `json:"updated_at"`
		CreatedAt string `json:"created_at"`
	}{}
	//
	// Struct to hold error response
	//
	e := struct {
		Message string
		Errors  []struct {
			Resource string
			Field    string
			Code     string
		}
	}{}
	//
	// Setup HTTP Basic auth for this session (ONLY use this with SSL).  Auth
	// can also be configured on a per-request basis when using Send().
	//
	s := napping.Session{
		Userinfo: url.UserPassword(username, passwd),
	}
	url := "https://api.github.com/authorizations"
	//
	// Send request to server
	//
	resp, err := s.Post(url, &payload, &res, &e)
	if err != nil {
		log.Fatal(err)
	}
	//
	// Process response
	//
	println("")
	if resp.Status() == 201 {
		fmt.Printf("Github auth token: %s\n\n", res.Token)
	} else {
		fmt.Println("Bad response status from Github server")
		fmt.Printf("\t Status:  %v\n", resp.Status())
		fmt.Printf("\t Message: %v\n", e.Message)
		fmt.Printf("\t Errors: %v\n", e.Message)
		pretty.Println(e.Errors)
	}
	println("")
}

func Setup() napping.Session {
	s := napping.Session{Log: false}
	s.Client = &http.Client{}
	return s
}

func SendRequest(u string, method int, sess *napping.Session, pload interface{}, res interface{}) (error, *napping.Response) {

	//
	// Send request to server
	//
	e := httperr{}
	var (
		err  error
		resp *napping.Response
	)
	sess.Log = debug

	switch method {
	case GET:
		resp, err = sess.Get(u, nil, &res, &e)
	case POST:
		resp, err = sess.Post(u, &pload, &res, &e)
	case PUT:
		resp, err = sess.Put(u, &pload, &res, &e)
	case PATCH:
		resp, err = sess.Patch(u, &pload, &res, &e)
	case DELETE:
		resp, err = sess.Delete(u, &res, &e)
	}

	if err != nil {
		return err, resp
	}
	if resp.Status() == 401 {
		return errors.New("unauthorised - check your username and passwd"), resp
	}
	if resp.Status() >= 300 {
		return errors.New(e.Message), resp
	} else {
		// all is good in the world
		return nil, resp
	}
}