// PutItem puts an item on the table.
func (t *Table) PutItem(v interface{}, opts ...option.PutItemInput) error {
req := &dynamodb.PutItemInput{
TableName: t.Name,
}
var itemMapped map[string]*dynamodb.AttributeValue
var err error
if marshaller, ok := v.(item.Marshaler); ok {
itemMapped, err = marshaller.MarshalItem()
} else {
itemMapped, err = dynamodbattribute.ConvertToMap(v)
}
if err != nil {
return err
}
req.Item = itemMapped
for _, f := range opts {
f(req)
}
_, err = t.DynamoDB.PutItem(req)
return err
}
func main() {
svc := dynamodb.New(session.New(), &aws.Config{Region: aws.String("eu-central-1")})
k := Key{
Email: "*****@*****.**",
}
item, err := dynamodbattribute.ConvertToMap(k)
if err != nil {
panic(err)
}
result, err := svc.GetItem(&dynamodb.GetItemInput{
TableName: aws.String("Users"),
Key: item,
})
if err != nil {
panic(err)
}
r := Record{}
err = dynamodbattribute.ConvertFromMap(result.Item, &r)
fmt.Println(r)
}
func (i *TestItem) PrimaryKey() map[string]*dynamodb.AttributeValue {
primaryKey := i.PrimaryKeyMap()
item, _ := dynamodbattribute.ConvertToMap(primaryKey)
return item
}
// Record marshals the job result into a dynamodb.AttributeValue struct, and writes
// the result item to DyanmoDB.
func (r *ResultRecorder) Record(result *wordfreq.JobResult) error {
// Construct a result item representing what data we want to write to DynamoDB.
recordItem := resultRecord{
Filename: path.Join(result.Job.Bucket, result.Job.Key),
Words: map[string]int{},
}
for _, w := range result.Words {
recordItem.Words[w.Word] = w.Count
}
// Use the ConvertToX helpers to marshal a Go struct to a dyanmodb.AttributeValue
// type. This greatly simplifies the code needed to create the attribute
// value item.
av, err := dynamodbattribute.ConvertToMap(recordItem)
if err != nil {
return fmt.Errorf("unable to serialize result to dyanmoDB.AttributeValue, %v", err)
}
_, err = r.svc.PutItem(&dynamodb.PutItemInput{
TableName: aws.String(r.tableName),
Item: av,
})
if err != nil {
return fmt.Errorf("unable to record result, %v", err)
}
return nil
}
func BenchmarkPutItem(b *testing.B) {
cfg := aws.Config{
DisableSSL: aws.Bool(true),
Credentials: credentials.NewStaticCredentials("AKID", "SECRET", ""),
}
server := successRespServer([]byte(`{}`))
cfg.Endpoint = aws.String(server.URL)
svc := dynamodb.New(&cfg)
svc.Handlers.Send.Clear()
svc.Handlers.Send.PushBack(func(r *service.Request) {
r.HTTPResponse = &http.Response{
StatusCode: http.StatusOK,
Status: http.StatusText(http.StatusOK),
Body: noopBody,
}
})
b.ResetTimer()
for i := 0; i < b.N; i++ {
av, err := dynamodbattribute.ConvertToMap(dbItem{Key: "MyKey", Data: "MyData"})
if err != nil {
b.Fatal("benchPutItem, expect no ConvertToMap errors", err)
}
params := &dynamodb.PutItemInput{
Item: av,
TableName: aws.String("tablename"),
}
_, err = svc.PutItem(params)
if err != nil {
b.Error("benchPutItem, expect no request errors", err)
}
}
}
func benchPutItemParallel(p, c int, b *testing.B) {
svc := dynamodb.New(&aws.Config{
DisableSSL: aws.Bool(true),
})
av, err := dynamodbattribute.ConvertToMap(dbItem{Key: "MyKey", Data: "MyData"})
if err != nil {
b.Fatal("expect no ConvertToMap errors", err)
}
params := &dynamodb.PutItemInput{
Item: av,
TableName: aws.String(testTableName),
}
b.N = c
b.ResetTimer()
b.SetParallelism(p)
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, err = svc.PutItem(params)
if err != nil {
b.Error("expect no request errors", err)
}
}
})
}
// output expects key value data to print to stdout
func (out stdout) output(data record) error {
item, err := dynamodbattribute.ConvertToMap(data.Data)
if err != nil {
return err
}
fmt.Println(item)
return nil
}
func main() {
//testTableDelete()
//chack table status
//testTableCreate()
//chack table status
//if creating,wait for active
svc := dynamodb.New(&aws.Config{Region: aws.String("ap-northeast-1")})
/*
scanParams := &dynamodb.ScanInput{
TableName:aws.String("access_log_range"),
AttributesToGet:[]*string{
aws.String("id"),
aws.String("time"),
aws.String("body_bytes_sent"),
aws.String("bytes_sent"),
aws.String("forwardedfor"),
aws.String("query_string"),
aws.String("referer"),
aws.String("remote_addr"),
aws.String("request_length"),
aws.String("request_method"),
aws.String("request_time"),
aws.String("request_uri"),
aws.String("status"),
aws.String("tag"),
aws.String("useragent"),
},
//Limit: aws.Int64(1000000),
}
*/
r := Record{
Key: "key127.0.0.1",
RemoteID: "abc-001",
OtherData: map[string]int{"a": 1, "b": 2, "c": 3},
Timestamp: time.Now().UTC().Unix(),
}
item, err := dynamodbattribute.ConvertToMap(r)
log.Println(item)
result, err := svc.PutItem(&dynamodb.PutItemInput{
Item: item,
TableName: aws.String("result"),
})
fmt.Println(result, err)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
fmt.Println(result)
}
// Register the service in the registry
func (c *Client) Register(name string, endpoint string) (*Service, error) {
// Check whether the registry has been previously created. If not create before registration.
if exists, err := c.Registry.Exists(); err != nil {
return nil, err
} else if !exists {
if err := c.Registry.Create(); err != nil {
return nil, err
}
}
// Create Service
service := &Service{Name: name, Endpoint: endpoint, stopHeartbeat: make(chan bool)}
// Heartbeat function - updates expiry
heartbeat := func() {
// Update service Expiry based on TTL and current time
service.Expiry = time.Now().Unix() + ServiceTTL
// Update service entry in registry
if av, err := dynamodbattribute.ConvertToMap(*service); err != nil {
return
} else {
_, err := c.svc.PutItem(&dynamodb.PutItemInput{
Item: av,
TableName: c.config.GetRegistryName(),
})
if err != nil {
return
}
}
}
// Ensure call heartbeat at least once
heartbeat()
// Start goroutine to send heartbeat
go func() {
for {
select {
case <-service.stopHeartbeat:
return
default:
// Pause for interval
time.Sleep(HeartbeatInterval)
// Call heartbeat function
heartbeat()
}
}
}()
return service, nil
}
// tryToLock tries to create a new item in DynamoDB
// every `DynamoDBLockRetryInterval`. As long as the item
// cannot be created (because it already exists), it will
// be retried. If the operation fails due to an error, it
// is sent to the errors channel.
// When the lock could be acquired successfully, the success
// channel is closed.
func (l *DynamoDBLock) tryToLock(stop, success chan struct{}, errors chan error) {
ticker := time.NewTicker(DynamoDBLockRetryInterval)
record := DynamoDBRecord{
Path: recordPathForVaultKey(l.key),
Key: recordKeyForVaultKey(l.key),
Value: []byte(l.value),
}
item, err := dynamodbattribute.ConvertToMap(record)
if err != nil {
errors <- err
return
}
for {
select {
case <-stop:
ticker.Stop()
case <-ticker.C:
_, err := l.backend.client.PutItem(&dynamodb.PutItemInput{
TableName: aws.String(l.backend.table),
Item: item,
ConditionExpression: aws.String("attribute_not_exists(#p) or attribute_not_exists(#k)"),
ExpressionAttributeNames: map[string]*string{
"#p": aws.String("Path"),
"#k": aws.String("Key"),
},
})
if err != nil {
if err, ok := err.(awserr.Error); ok && err.Code() != "ConditionalCheckFailedException" {
errors <- err
}
if l.recovery {
_, err := l.backend.client.DeleteItem(&dynamodb.DeleteItemInput{
TableName: aws.String(l.backend.table),
Key: map[string]*dynamodb.AttributeValue{
"Path": {S: aws.String(record.Path)},
"Key": {S: aws.String(record.Key)},
},
})
if err != nil {
errors <- fmt.Errorf("could not delete lock record: %s", err)
} else {
l.recovery = false
}
}
} else {
ticker.Stop()
close(success)
}
}
}
}
func putResource(svc *dynamodb.DynamoDB, resource Resource, tableName string) error {
item, err := dynamodbattribute.ConvertToMap(resource)
if err != nil {
return err
}
_, err = svc.PutItem(&dynamodb.PutItemInput{
Item: item,
TableName: aws.String(tableName),
})
return err
}
func getDynamodbPutItemParams(b *testing.B) *dynamodb.PutItemInput {
av, err := dynamodbattribute.ConvertToMap(struct {
Key string
Data string
}{Key: "MyKey", Data: "MyData"})
if err != nil {
b.Fatal("benchPutItem, expect no ConvertToMap errors", err)
}
return &dynamodb.PutItemInput{
Item: av,
TableName: aws.String("tablename"),
}
}
// output just writes to dynamodb
func (out dynamodbOut) output(data record) error {
input := &dynamodb.PutItemInput{
TableName: aws.String(out.table),
}
item, err := dynamodbattribute.ConvertToMap(data)
if err != nil {
return err
}
input.Item = item
_, err = out.db.PutItem(input)
return err
}
// Put is used to insert or update an entry
func (d *DynamoDBBackend) Put(entry *Entry) error {
defer metrics.MeasureSince([]string{"dynamodb", "put"}, time.Now())
record := DynamoDBRecord{
Path: recordPathForVaultKey(entry.Key),
Key: recordKeyForVaultKey(entry.Key),
Value: entry.Value,
}
item, err := dynamodbattribute.ConvertToMap(record)
if err != nil {
return fmt.Errorf("could not convert prefix record to DynamoDB item: %s", err)
}
requests := []*dynamodb.WriteRequest{{
PutRequest: &dynamodb.PutRequest{
Item: item,
},
}}
for _, prefix := range prefixes(entry.Key) {
record = DynamoDBRecord{
Path: recordPathForVaultKey(prefix),
Key: fmt.Sprintf("%s/", recordKeyForVaultKey(prefix)),
}
item, err := dynamodbattribute.ConvertToMap(record)
if err != nil {
return fmt.Errorf("could not convert prefix record to DynamoDB item: %s", err)
}
requests = append(requests, &dynamodb.WriteRequest{
PutRequest: &dynamodb.PutRequest{
Item: item,
},
})
}
return d.batchWriteRequests(requests)
}
// MarshalItem implements ItemMarshaler interface.
func (i TestItem) MarshalItem() (map[string]*dynamodb.AttributeValue, error) {
if i.IsStartKey() {
item := i.PrimaryKey()
return item, nil
}
itemMapped, err := dynamodbattribute.ConvertToMap(i)
if err != nil {
return nil, err
}
if i.Password != "" {
itemMapped["password"] = attributes.String(hashedPassword(i.Password))
}
return itemMapped, nil
}
// Query the registry for named service
func (c *Client) Discover(name string) (*Service, error) {
// Make sure registry is active
if active, _ := c.Registry.IsActive(); active == true {
expressionAttributeValues := map[string]interface{}{
":NameVal": name,
":ExpiryVal": time.Now().Unix(),
}
ean := map[string]*string{
"#N": aws.String("Name"),
}
eav, err := dynamodbattribute.ConvertToMap(expressionAttributeValues)
if err != nil {
return nil, err
}
resp, err := c.svc.Query(&dynamodb.QueryInput{
TableName: c.config.GetRegistryName(),
KeyConditionExpression: aws.String("#N = :NameVal"),
FilterExpression: aws.String("Expiry > :ExpiryVal"),
ExpressionAttributeValues: eav,
ExpressionAttributeNames: ean,
})
if err != nil {
return nil, err
}
if len(resp.Items) > 0 {
// Randomly select one of the available endpoints (in effect load balancing between available endpoints)
service := Service{}
err = dynamodbattribute.ConvertFromMap(resp.Items[rand.Intn(len(resp.Items))], &service)
if err != nil {
return nil, err
}
return &service, nil
} else {
// No service found
return nil, ErrServiceNotFound
}
} else {
return nil, ErrRegistryNotActive
}
}
func main() {
svc := dynamodb.New(session.New(), &aws.Config{Endpoint: aws.String("http://localhost:8000"), Region: aws.String("us-east-1")})
//var data map[string]interface{}
file, e := ioutil.ReadFile("./mockdata/MOCK_DATA-gym.json")
//fmt.Print(string(file))
if e != nil {
fmt.Printf("File error: %v\n", e)
os.Exit(1)
}
var u []Gym
json.Unmarshal(file, &u)
for i := 0; i < len(u); i++ {
fmt.Printf(" Name: %v\n", u[i].Name)
item, err := dynamodbattribute.ConvertToMap(u[i])
if err != nil {
fmt.Println("Failed to convert", err)
return
}
fmt.Printf("Item %v\n", item)
//fmt.Printf("Data %v\n", data[user])
params := &dynamodb.PutItemInput{
Item: item,
TableName: aws.String("gym"),
}
resp, err := svc.PutItem(params)
if err != nil {
// Print the error, cast err to awserr.Error to get the Code and
// Message from an error.
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
//fmt.Printf("AL: Data %v", data)
}
func main() {
svc := dynamodb.New(session.New(), &aws.Config{Endpoint: aws.String("http://localhost:8000"), Region: aws.String("us-east-1")})
file, e := ioutil.ReadFile("./mockdata/MOCK_DATA-user-2.json")
if e != nil {
fmt.Printf("File error: %v\n", e)
os.Exit(1)
}
var u []User
json.Unmarshal(file, &u)
for i := 0; i < len(u); i++ {
fmt.Printf(" First Name: %v\n", u[i].FirstName)
encPass, cryptErr := Crypt([]byte(u[i].Password))
if cryptErr != nil {
fmt.Println("Failed to hash password", cryptErr)
return
}
u[i].EncPassword = string(encPass)
u[i].Password = ""
item, err := dynamodbattribute.ConvertToMap(u[i])
if err != nil {
fmt.Println("Failed to convert", err)
return
}
fmt.Printf("Item %v\n", item)
params := &dynamodb.PutItemInput{
Item: item,
TableName: aws.String("user"),
}
resp, err := svc.PutItem(params)
if err != nil {
fmt.Println(err.Error())
return
}
fmt.Println(resp)
}
}
// PutItem puts an item on the table.
func (t *Table) PutItem(item interface{}, opts ...option.PutItemInput) error {
req := &dynamodb.PutItemInput{
TableName: t.Name,
}
itemMapped, err := dynamodbattribute.ConvertToMap(item)
if err != nil {
return err
}
req.Item = itemMapped
for _, f := range opts {
f(req)
}
_, err = t.DynamoDB.PutItem(req)
return err
}
// ExclusiveStartKey sets an ExclusiveStartKey in dynamodb.QueryInput.
func ExclusiveStartKey(v interface{}) QueryInput {
return func(req *dynamodb.QueryInput) error {
var err error
var esk map[string]*dynamodb.AttributeValue
if key, ok := v.(map[string]*dynamodb.AttributeValue); ok {
esk = key
} else if marshaller, ok := v.(item.Marshaler); ok {
esk, err = marshaller.MarshalItem()
} else {
esk, err = dynamodbattribute.ConvertToMap(v)
}
if err != nil {
return err
}
req.ExclusiveStartKey = esk
return nil
}
}
func main() {
svc := dynamodb.New(session.New(), &aws.Config{Region: aws.String("eu-central-1")})
r := Record{
Email: "*****@*****.**",
CheckEmailToken: "29jd9j2dm3932jdhewk4",
}
item, err := dynamodbattribute.ConvertToMap(r)
if err != nil {
panic(err)
}
result, err := svc.PutItem(&dynamodb.PutItemInput{
TableName: aws.String("Users"),
Item: item,
})
if err != nil {
panic(err)
}
fmt.Println(result)
}
func main() {
svc := dynamodb.New(session.New(), &aws.Config{Endpoint: aws.String("http://localhost:8000"), Region: aws.String("us-east-1")})
file, e := ioutil.ReadFile("./mockdata/MOCK_DATA-workout.json")
if e != nil {
fmt.Printf("File error: %v\n", e)
os.Exit(1)
}
var u []Workout
json.Unmarshal(file, &u)
for i := 0; i < len(u); i++ {
fmt.Printf("Name: %v\n", u[i].Name)
item, err := dynamodbattribute.ConvertToMap(u[i])
if err != nil {
fmt.Println("Failed to convert", err)
return
}
fmt.Printf("Item %v\n", item)
params := &dynamodb.PutItemInput{
Item: item,
TableName: aws.String("workout"),
}
resp, err := svc.PutItem(params)
if err != nil {
fmt.Println(err.Error())
return
}
// Pretty-print the response data.
fmt.Println(resp)
}
}
// MarshalDynamoDB implements the dynamotree.Storable interface
func (a Account) MarshalDynamoDB() (map[string]*dynamodb.AttributeValue, error) {
return dynamodbattribute.ConvertToMap(a)
}
func (a AccountT) MarshalDynamoDB() (map[string]*dynamodb.AttributeValue, error) {
if a.MarshalFailPlease {
return nil, fmt.Errorf("could not grob the frob")
}
return dynamodbattribute.ConvertToMap(a)
}
// MarshalDynamoDB implements the dynamotree.Storable interface
func (l Link) MarshalDynamoDB() (map[string]*dynamodb.AttributeValue, error) {
return dynamodbattribute.ConvertToMap(l)
}
func realmain() error {
flag.Parse()
s := session.New(&aws.Config{Region: aws.String(*region)})
ddb := dynamodb.New(s)
tablename := aws.String(*table)
describeTableOutput, err := ddb.DescribeTable(&dynamodb.DescribeTableInput{
TableName: tablename,
})
if err != nil {
return err
}
fmt.Printf("%#v\n", describeTableOutput)
// if table not exists, create one.
if describeTableOutput == nil {
// create table should specify primary key.
// on DynamoDB, not primary key fields are not necessary when creating table.
createTableOutput, err := ddb.CreateTable(&dynamodb.CreateTableInput{
AttributeDefinitions: []*dynamodb.AttributeDefinition{
{
AttributeName: aws.String("id"),
AttributeType: aws.String("S"),
},
},
KeySchema: []*dynamodb.KeySchemaElement{
{
AttributeName: aws.String("id"),
KeyType: aws.String("HASH"),
},
},
ProvisionedThroughput: &dynamodb.ProvisionedThroughput{
ReadCapacityUnits: aws.Int64(10),
WriteCapacityUnits: aws.Int64(10),
},
TableName: tablename,
})
if err != nil {
return err
}
fmt.Printf("%#v\n", createTableOutput)
}
item, err := dynamodbattribute.ConvertToMap(Item{"id1", "field1", 1})
if err != nil {
return err
}
fmt.Printf("%#v\n", item)
// PutItem request overwrite existed item (same primary key) by default.
putItemOutput, err := ddb.PutItem(&dynamodb.PutItemInput{
Item: item,
TableName: tablename,
})
if err != nil {
return err
}
// empty response even if successfly put
fmt.Printf("%#v\n", putItemOutput)
getItemOutput, err := ddb.GetItem(&dynamodb.GetItemInput{
Key: map[string]*dynamodb.AttributeValue{
"id": {
S: aws.String("id1"),
},
},
TableName: tablename,
})
if err != nil {
return err
}
fmt.Printf("%#v\n", getItemOutput)
var putreq []*dynamodb.WriteRequest
for i := 0; i < 10; i++ {
it, err := dynamodbattribute.ConvertToMap(Item{
ID: fmt.Sprintf("batchwrite_id%d", i+100),
Field1: fmt.Sprintf("batchwriteItem%d", i),
IntField: i,
})
if err != nil {
return err
}
putreq = append(putreq, &dynamodb.WriteRequest{
PutRequest: &dynamodb.PutRequest{
Item: it,
},
})
}
batchWriteItemOutput, err := ddb.BatchWriteItem(&dynamodb.BatchWriteItemInput{
RequestItems: map[string][]*dynamodb.WriteRequest{
*table: putreq,
},
})
if err != nil {
return err
}
fmt.Printf("%#v\n", batchWriteItemOutput)
batchGetItemOutput, err := ddb.BatchGetItem(&dynamodb.BatchGetItemInput{
RequestItems: map[string]*dynamodb.KeysAndAttributes{
*table: {
Keys: []map[string]*dynamodb.AttributeValue{
{
"id": {
S: aws.String("batchwrite_id100"),
},
},
{
"id": {
S: aws.String("batchwrite_id101"),
},
},
},
},
},
})
if err != nil {
return err
}
fmt.Printf("%#v\n", batchGetItemOutput)
deleteTableOutput, err := ddb.DeleteTable(&dynamodb.DeleteTableInput{
TableName: tablename,
})
if err != nil {
return err
}
fmt.Printf("%#v", deleteTableOutput)
return nil
}