Golang aws.EnvAuth函数代码示例

func TestReadFromSQS(t *testing.T) {
	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err)
	}

	sqs := New(auth, aws.USWest2)
	queue, err := sqs.GetQueue("tracker-alpha-matt")
	if err != nil {
		panic(err)
	}

	results, err := queue.ReceiveMessage([]string{"All"}, 10, 600)
	count := len(results.Messages)
	deleteMessageBatch := make([]DeleteMessageBatch, count)
	for index, message := range results.Messages {
		fmt.Println(message.Body)
		deleteMessageBatch[index] = DeleteMessageBatch{
			Id:            strconv.Itoa(index),
			ReceiptHandle: message.ReceiptHandle,
		}
	}

	fmt.Println(fmt.Sprintf("%#v", deleteMessageBatch))
	response, err := queue.DeleteMessageBatch(deleteMessageBatch)
	if err != nil {
		panic(err)
	}
	fmt.Println(fmt.Sprintf("%#v", response))
}

func Sync(localPath, bucketName, awsRegion, acl string) {
	if localPath == "" || bucketName == "" {
		flag.PrintDefaults()
		return
	}
	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err.Error())
	}
	s3Conn := s3.New(auth, aws.Regions[awsRegion])
	bucket := s3Conn.Bucket(bucketName)
	pathChan := make(chan string)
	doneChan := make(chan int)
	go doTheWalk(localPath, pathChan)
	count := 0
	for path := range pathChan {
		if path == "" {
			break
		}
		go compareAndSync(acl, localPath, path, bucket, doneChan)
		count++
	}
	for i := 0; i < count; i++ {
		<-doneChan
	}
}

func main() {
	flag.Parse()

	cmds := flag.Args()

	if len(cmds) <= 0 {
		fmt.Println("Command required")
		os.Exit(1)
	}

	cmd := Cmd{}
	cmd.name = cmds[0]
	cmd.modifiers = cmds[1:]

	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err)
	}

	cmd.conn = s3.New(auth, getRegion(region))
	s3url, err := url.Parse(cmd.modifiers[0])
	cmd.url = s3url
	cmd.bucket = s3.Bucket{cmd.conn, cmd.url.Host}
	RunCommand(cmd)

}

func main() {
	flag.Parse()

	if *toHash == "" || *pkgDirs == "" || *cmd == "" || *bucketName == "" {
		log.Print("You are missing one or more mandatory command line arguments.")
		flag.Usage()
		os.Exit(1)
	}

	cred, err := aws.EnvAuth()
	if err != nil {
		log.Fatalf("Couldn't auth into s3. Did you set up ENV? Error: %s", err)
	}
	s3client := s3.New(cred, aws.USWest)
	bucket := s3client.Bucket(*bucketName)

	// extract.
	checksum := fmt.Sprintf("%x", hashFiles(*toHash).Sum(nil))

	filename := *outfile
	// consider bucket.GetReader to pipe directly into gunzip/untar
	file, err := bucket.Get(fmt.Sprintf("%s/%s", checksum, filename))
	if err != nil {
		fmt.Printf("%s\n", err)
		build(*cmd)
		archive(*pkgDirs, filename)
		upload(bucket, checksum, filename)
	} else {
		extract(file)
	}
}

func PostSignup(w *rest.ResponseWriter, req *rest.Request) {
	signup := Signup{}
	err := req.DecodeJsonPayload(&signup)
	if err != nil {
		rest.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if signup.Email == "" {
		rest.Error(w, "email is required", 400)
		return
	}

	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err.Error())
	}

	s := s3.New(auth, aws.EUWest)
	bucket := s.Bucket("seq-signup")
	data := []byte(signup.Email)
	err = bucket.Put(signup.Email, data, "text/plain", s3.BucketOwnerFull)
	if err != nil {
		panic(err.Error())
	}

	fmt.Println(signup)
	w.Header().Set("Access-Control-Allow-Origin", "http://sequenceiq.com")
	w.WriteJson(&signup)
}

// Goroutine for saving the state.
func saver(ticker *time.Ticker) {
	for {
		select {
		case <-ticker.C:
			println("Writing state")
			lock.Lock()
			if dirty {
				dirty = false
				state := State{folders}

				bytes, err := json.Marshal(state)
				if err != nil {
					panic(err)
				}

				// write to S3
				auth, err := aws.EnvAuth()
				if err != nil {
					panic(err)
				}
				s := s3.New(auth, aws.USEast)
				bucket := s.Bucket(s3_bucket)
				err = bucket.Put("rss.json", bytes, "application/json", s3.ACL("private"))
				if err != nil {
					panic(err)
				}
			}
			lock.Unlock()
		}
	}
}

// Load a brain
func (brain *Brain) Load() {
	// The AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are used.
	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err.Error())
	}

	// Open Bucket
	s := s3.New(auth, aws.USEast)

	// Load the database from an S3 bucket
	bucket := s.Bucket(bucketName)

	// Create a bytes.Buffer
	n, err := bucket.Get(filename)
	if err != nil {
		panic(err)
	}

	p := bytes.NewBuffer(n)
	dec := gob.NewDecoder(p)

	err = dec.Decode(&brain)

	if err != nil {
		log.Print("There was an error loading the brain. Using a blank one.")
	}
}

// Persist a brain
func (brain *Brain) Save() {
	// Persist the database to file
	var data bytes.Buffer
	contents := gob.NewEncoder(&data)
	err := contents.Encode(brain)
	if err != nil {
		panic(err)
	}

	// The AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables are used.
	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err.Error())
	}

	// Open Bucket
	s := s3.New(auth, aws.USEast)

	// Load the database from an S3 bucket
	bucket := s.Bucket(bucketName)

	err = bucket.Put(filename, data.Bytes(), "text/plain", s3.BucketOwnerFull)
	if err != nil {
		panic(err.Error())
	}
}

func main() {
	flag.Parse()
	if flag.Arg(0) == "" {
		errorf("no command")
		os.Exit(2)
	}
	auth, err := aws.EnvAuth()
	if err != nil {
		fatalf("envauth: %v", err)
	}
	conn := ec2.New(auth, aws.USEast)

	if flag.Arg(0) == "help" {
		for _, c := range cmds {
			c.printUsage()
		}
		return
	}

	for _, c := range cmds {
		if flag.Arg(0) == c.name {
			c.run(conn, flag.Args()[1:])
			return
		}
	}
	errorf("unknown command %q", flag.Arg(0))
	os.Exit(2)
}

func (s *AmazonServer) SetUp(c *C) {
	auth, err := aws.EnvAuth()
	if err != nil {
		c.Fatal(err)
	}
	s.auth = auth
}

// Read the state from S3.
func readState() {
	state := State{}
	wd, err := os.Getwd()
	fmt.Printf("wd: %s\n", wd)

	// read from S3
	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err.Error())
	}
	s := s3.New(auth, aws.USEast)
	bucket := s.Bucket(s3_bucket)
	data, err := bucket.Get("rss.json")
	if err != nil {
		panic(err)
	}
	fmt.Printf("Data read from S3\n")

	// old way
	/*
		file, err := os.Open("state.json")
		if err != nil {
			panic(err)
		}
		data, err := ioutil.ReadAll(file)
		if err != nil {
			panic(err)
		}
	*/
	err = json.Unmarshal(data, &state)
	if err != nil {
		panic(err)
	}
	folders = state.Folders
}

func TestRealtimeTrace(t *testing.T) {

	auth, err := aws.EnvAuth()
	if err != nil {
		panic(err)
	}
	s := ec2.New(auth, aws.EUWest)

	m, err := NewEC2Monitor(s, "m1.medium",
		"Linux/UNIX",
		"eu-west-1b", nil)

	to := time.Now()
	from := to.AddDate(0, -3, 0)

	trace, err := m.Trace(from, to)
	if err != nil {
		t.Fatal(err)
	}

	if len(trace) == 0 {
		t.Fatal("trace did not produce any history")
	}

	if len(trace) < 5 {
		for i := 0; i < len(trace); i++ {
			pp := trace[i]
			fmt.Printf("\t%.4f - %v\n", pp.Price(), pp.Time())
		}
	} else {
		fmt.Println("last 5 traces:")
		for i := 0; i < 5; i++ {
			pp := trace[i]
			fmt.Printf("\t%.4f - %v\n", pp.Price(), pp.Time())
		}
	}

	pChan, errChan := m.Start(time.Second * 5)

	ticker := time.NewTicker(time.Minute * 5)

	fmt.Println("Starting EC2 Spot Price Monitor.\n\tTimeout: 5 minutes")

	for {
		select {
		case p := <-pChan:
			fmt.Printf("PriceChange: %v On: %v\n", p.Price(), p.Time())
		case err := <-errChan:
			fmt.Println("error: ", err.Error())
			return
		case <-ticker.C:
			fmt.Println("test shut down after 5 minutes")
			return
		}
	}
	fmt.Println("Stopping ticker, and exiting test..")
	ticker.Stop()
	fmt.Println("Done")
}

func auth() aws.Auth {
	creds, err := aws.EnvAuth()
	if err != nil {
		log.Println("Error with aws credentials: %v", err)
		os.Exit(1)
	}
	return creds
}

func (s *S) TestEnvAuth(c *C) {
	os.Clearenv()
	os.Setenv("AWS_SECRET_ACCESS_KEY", "secret")
	os.Setenv("AWS_ACCESS_KEY_ID", "access")
	auth, err := aws.EnvAuth()
	c.Assert(err, IsNil)
	c.Assert(auth, Equals, aws.Auth{SecretKey: "secret", AccessKey: "access"})
}

func awsInit(config *ec2Config) (ec2Conn *ec2.EC2, err error) {
	auth, err := aws.EnvAuth()

	if err != nil {
		return nil, err
	}

	return ec2.New(auth, config.region), nil
}