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 Get(url string, token oauth2.Token) string {
ns := napping.Session{}
ns.Header = &http.Header{}
ns.Header.Add("Authorization", "Bearer "+token.AccessToken)
resp, err := ns.Get(url, nil, nil, nil)
if err != nil {
log.Fatal(err)
}
fmt.Println("Status : %i", resp.Status())
fmt.Println("Server response %s", resp.RawText())
dst := new(bytes.Buffer)
src := []byte(resp.RawText())
json.Indent(dst, src, "", "\t")
return dst.String()
}
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 {
record, err := reader.Read()
if err == io.EOF {
break
}
stationID, err := strconv.ParseInt(record[0], 10, 64)
fatalCheck(err)
systemID, err := strconv.ParseInt(record[1], 10, 64)
fatalCheck(err)
stations[stationID] = systemID
}
log.Printf("Loaded %d NPC Stations", len(stations))
// Load player stations from API
getStationsFromAPI()
log.Printf("Added Player Stations: %d Total Stations", len(stations))
}
// FanOut response channel for posters
postChannel := make(chan []byte)
// Pool of transports.
transport := &http.Transport{DisableKeepAlives: false}
client := &http.Client{Transport: transport}
go func() {
for i := 0; i < 11; i++ {
// Don't spawn them all at once.
time.Sleep(time.Second / 2)
go func() {
for {
msg := <-postChannel
response, err := client.Post(uploadUrl, "application/json", bytes.NewBuffer(msg))
if err != nil {
log.Println("EMDRCrestBridge:", err)
} else {
if response.Status != "200 OK" {
body, _ := ioutil.ReadAll(response.Body)
log.Println("EMDRCrestBridge:", string(body))
log.Println("EMDRCrestBridge:", string(response.Status))
}
// Must read everything to close the body and reuse connection
ioutil.ReadAll(response.Body)
response.Body.Close()
}
}
}()
}
}()
// Throttle Crest Requests
rate := time.Second / 30
throttle := time.Tick(rate)
// semaphore to prevent runaways
sem := make(chan bool, maxGoRoutines)
sem2 := make(chan bool, maxGoRoutines)
for {
// loop through all regions
for _, r := range regions {
log.Printf("Scanning Region: %s", r.RegionName)
// and each item per region
for _, t := range types {
<-throttle // impliment throttle
sem2 <- true
rk := regionKey{r.RegionID, t.TypeID}
go func() {
defer func() { <-sem2 }()
// Process Market History
h := marketHistory{}
url := fmt.Sprintf("https://public-crest.eveonline.com/market/%d/types/%d/history/", rk.RegionID, rk.TypeID)
response, err := crestSession.Get(url, nil, &h, nil)
if err != nil {
log.Printf("EMDRCrestBridge: %s", err)
return
}
if response.Status() == 200 {
sem <- true
go postHistory(sem, postChannel, h, rk.RegionID, rk.TypeID)
}
}()
sem2 <- true
go func() {
defer func() { <-sem2 }()
// Process Market Buy Orders
b := marketOrders{}
url := fmt.Sprintf("https://public-crest.eveonline.com/market/%d/orders/buy/?type=https://public-crest.eveonline.com/types/%d/", rk.RegionID, rk.TypeID)
response, err := crestSession.Get(url, nil, &b, nil)
if err != nil {
log.Printf("EMDRCrestBridge: %s", err)
return
}
if response.Status() == 200 {
sem <- true
go postOrders(sem, postChannel, b, 1, rk.RegionID, rk.TypeID)
}
}()
sem2 <- true
go func() {
defer func() { <-sem2 }()
// Process Market Sell Orders
s := marketOrders{}
url := fmt.Sprintf("https://public-crest.eveonline.com/market/%d/orders/sell/?type=https://public-crest.eveonline.com/types/%d/", rk.RegionID, rk.TypeID)
response, err := crestSession.Get(url, nil, &s, nil)
if err != nil {
log.Printf("EMDRCrestBridge: %s", err)
return
}
if response.Status() == 200 {
sem <- true
go postOrders(sem, postChannel, s, 0, rk.RegionID, rk.TypeID)
}
}()
}
}
}
}
func main() {
//
// Prompt user for Github username/password
//
var username string
fmt.Printf("Github username: "******"%s", &username)
if err != nil {
log.Fatal(err)
}
passwd, err := gopass.GetPass("Github password: "******"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
}
}