Example #1
1
func getServices(containerID string, svc *dynamodb.DynamoDB) ([]*Service, error) {
	context := Context{}
	params := &dynamodb.QueryInput{
		TableName: aws.String("Services"),
		KeyConditions: map[string]*dynamodb.Condition{
			"ContainerID": {
				ComparisonOperator: aws.String("EQ"), // Required
				AttributeValueList: []*dynamodb.AttributeValue{
					{
						S: aws.String(containerID),
					},
				},
			},
		},
	}
	resp, err := svc.Query(params)

	if err != nil {
		return context, err
	}
	// loop through the items and convert back to struct
	for _, item := range resp.Items {
		service := Service{}
		dynamodbattribute.ConvertFromMap(item, &service)
		context = append(context, &service)
	}
	return context, err
}
Example #2
0
// List is used to list all the keys under a given
// prefix, up to the next prefix.
func (d *DynamoDBBackend) List(prefix string) ([]string, error) {
	defer metrics.MeasureSince([]string{"dynamodb", "list"}, time.Now())

	prefix = strings.TrimSuffix(prefix, "/")

	keys := []string{}
	prefix = escapeEmptyPath(prefix)
	queryInput := &dynamodb.QueryInput{
		TableName:      aws.String(d.table),
		ConsistentRead: aws.Bool(true),
		KeyConditions: map[string]*dynamodb.Condition{
			"Path": {
				ComparisonOperator: aws.String("EQ"),
				AttributeValueList: []*dynamodb.AttributeValue{{
					S: aws.String(prefix),
				}},
			},
		},
	}
	err := d.client.QueryPages(queryInput, func(out *dynamodb.QueryOutput, lastPage bool) bool {
		var record DynamoDBRecord
		for _, item := range out.Items {
			dynamodbattribute.ConvertFromMap(item, &record)
			if !strings.HasPrefix(record.Key, DynamoDBLockPrefix) {
				keys = append(keys, record.Key)
			}
		}
		return !lastPage
	})
	if err != nil {
		return nil, err
	}

	return keys, nil
}
Example #3
0
// Get is used to fetch an entry
func (d *DynamoDBBackend) Get(key string) (*Entry, error) {
	defer metrics.MeasureSince([]string{"dynamodb", "get"}, time.Now())

	resp, err := d.client.GetItem(&dynamodb.GetItemInput{
		TableName:      aws.String(d.table),
		ConsistentRead: aws.Bool(true),
		Key: map[string]*dynamodb.AttributeValue{
			"Path": {S: aws.String(recordPathForVaultKey(key))},
			"Key":  {S: aws.String(recordKeyForVaultKey(key))},
		},
	})
	if err != nil {
		return nil, err
	}
	if resp.Item == nil {
		return nil, nil
	}

	record := &DynamoDBRecord{}
	if err := dynamodbattribute.ConvertFromMap(resp.Item, record); err != nil {
		return nil, err
	}

	return &Entry{
		Key:   vaultKey(record),
		Value: record.Value,
	}, nil
}
Example #4
0
// GetItem get the item from the table and convert it to v.
func (t *Table) GetItem(hashKeyValue, rangeKeyValue *dynamodb.AttributeValue, v interface{}, opts ...option.GetItemInput) error {
	req := &dynamodb.GetItemInput{
		TableName: t.Name,
	}

	key := make(map[string]*dynamodb.AttributeValue)
	key[*t.hashKey.AttributeDefinition.AttributeName] = hashKeyValue

	if t.rangeKey != nil {
		key[*t.rangeKey.AttributeDefinition.AttributeName] = rangeKeyValue
	}

	req.Key = key

	for _, f := range opts {
		f(req)
	}

	resp, err := t.DynamoDB.GetItem(req)
	if err != nil {
		return err
	}

	if len(resp.Item) == 0 {
		return ErrItemNotFound
	}

	// Use ItemUnmarshaler if available
	if unmarshaller, ok := v.(item.Unmarshaler); ok {
		return unmarshaller.UnmarshalItem(resp.Item)
	}

	return dynamodbattribute.ConvertFromMap(resp.Item, v)
}
func main() {
	svc := dynamodb.New(session.New(), &aws.Config{Region: aws.String("eu-central-1")})

	k := Key{
		Email: "[email protected]",
	}

	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)
}
Example #6
0
func (a *AccountT) UnmarshalDynamoDB(item map[string]*dynamodb.AttributeValue) error {
	if v, ok := item["UnmarshalFailPlease"]; ok {
		if *v.BOOL == true {
			return fmt.Errorf("could not grob the frob")
		}
	}
	return dynamodbattribute.ConvertFromMap(item, a)
}
Example #7
0
func (dynamoDBSource *DynamoDBSource) Get() (map[string]interface{}, error) {

	config := defaults.Config()

	if dynamoDBSource.AccessKey != "" {
		config = config.WithCredentials(credentials.NewCredentials(&credentials.StaticProvider{
			Value: credentials.Value{
				AccessKeyID:     dynamoDBSource.AccessKey,
				SecretAccessKey: dynamoDBSource.SecretKey,
			},
		}))
	}

	if dynamoDBSource.Endpoint != "" {
		config = config.WithEndpoint(dynamoDBSource.Endpoint)
	}

	if dynamoDBSource.Region != "" {
		config = config.WithRegion(dynamoDBSource.Region)
	} else {
		config = config.WithRegion("us-west-1")
	}

	client := dynamodb.New(session.New(config))

	tableName := aws.String(dynamoDBSource.Table)

	describeTableInput := &dynamodb.DescribeTableInput{TableName: tableName}

	if _, err := client.DescribeTable(describeTableInput); err != nil {
		return nil, err
	}

	if err := client.WaitUntilTableExists(describeTableInput); err != nil {
		return nil, err
	}

	key := dynamoDBSource.Key

	response, err := client.GetItem(&dynamodb.GetItemInput{
		Key: map[string]*dynamodb.AttributeValue{
			"key": {S: aws.String(key)},
		},
		TableName:      tableName,
		ConsistentRead: aws.Bool(true),
	})

	if err != nil {
		return nil, err
	}

	result := make(map[string]interface{})
	err = dynamodbattribute.ConvertFromMap(response.Item, &result)

	delete(result, key)

	return result, err
}
Example #8
0
// 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
	}
}
Example #9
0
// Query queries items to the table and convert it to v. v must be a slice of struct.
// If the Query operation does not return the last page, LastEvaluatedKey will be returned.
func (t *Table) Query(slice interface{}, opts ...option.QueryInput) (map[string]*dynamodb.AttributeValue, error) {
	req := &dynamodb.QueryInput{
		TableName: t.Name,
	}

	for _, f := range opts {
		if err := f(req); err != nil {
			return nil, err
		}
	}

	resp, err := t.DynamoDB.Query(req)
	if err != nil {
		return nil, err
	}

	v := reflect.ValueOf(slice)
	typ := v.Type()
	if !(typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Slice) {
		return nil, fmt.Errorf("dynamodb: slice must be a pointer to slice but %s", typ)
	}

	items := reflect.MakeSlice(typ.Elem(), 0, len(resp.Items))
	for _, i := range resp.Items {
		p := reflect.New(typ.Elem().Elem())

		// Use ItemUnmarshaler if available
		var err error
		if v, ok := p.Interface().(item.Unmarshaler); ok {
			err = v.UnmarshalItem(i)
		} else {
			err = dynamodbattribute.ConvertFromMap(i, p.Interface())
		}
		if err != nil {
			return nil, err
		}

		items = reflect.Append(items, p.Elem())
	}

	reflect.Indirect(v).Set(items)
	return resp.LastEvaluatedKey, nil
}
func TestNewMockCtrl(t *testing.T) {
	dynmodbservicemock := NewMockService(t)
	dynmodbservicemock.EXPECT().GetItem(&dynamodb.GetItemInput{
		TableName: aws.String("testtable"),
		Key: map[string]*dynamodb.AttributeValue{
			"IdKey": &dynamodb.AttributeValue{
				S: aws.String("mykey"),
			},
		},
	}).Return(&dynamodb.GetItemOutput{
		Item: map[string]*dynamodb.AttributeValue{
			"IdKey": &dynamodb.AttributeValue{
				S: aws.String("mykey"),
			},
			"TestValue": &dynamodb.AttributeValue{
				S: aws.String("test value"),
			},
		},
	}, nil)

	params := &dynamodb.GetItemInput{
		TableName: aws.String("testtable"),
		Key: map[string]*dynamodb.AttributeValue{
			"IdKey": &dynamodb.AttributeValue{
				S: aws.String("mykey"),
			},
		},
	}

	resp, err := dynmodbservicemock.GetItem(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
	}

	testObj := &TestStruct{}
	err = dynamodbattribute.ConvertFromMap(resp.Item, testObj)
	log.Printf("%+v\n", testObj)
}
Example #11
0
// UnmarshalItem implements ItemUnmarshaler interface.
func (i *TestItem) UnmarshalItem(item map[string]*dynamodb.AttributeValue) error {
	role := item["role"]

	// dynamodbattribute.ConvertFromMap does not support StringSet so unset it
	delete(item, "role")

	if err := dynamodbattribute.ConvertFromMap(item, i); err != nil {
		return err
	}

	// restore role by hand
	if role == nil || role.SS == nil {
		// empty role is still legal
		return nil
	}

	for _, s := range role.SS {
		i.Role = append(i.Role, *s)
	}

	return nil
}
Example #12
0
// UnmarshalDynamoDB implements the dynamotree.Storable interface
func (l *Link) UnmarshalDynamoDB(item map[string]*dynamodb.AttributeValue) error {
	return dynamodbattribute.ConvertFromMap(item, l)
}
Example #13
0
// UnmarshalDynamoDB implements the dynamotree.Storable interface
func (a *Account) UnmarshalDynamoDB(item map[string]*dynamodb.AttributeValue) error {
	return dynamodbattribute.ConvertFromMap(item, a)
}