// Add a new Broker
func (command *Command) AddBroker(r *http.Request, broker *m.Broker, done *bool) error {
*done = false
keyId := fmt.Sprintf("%s:%d", BROKERS, broker.Id)
key, _ := as.NewKey(NAMESPACE, BROKERS, keyId)
db.Delete(nil, key)
bins := as.BinMap{
"broker_id": broker.Id,
"broker_name": broker.Name,
"credit": broker.Credit,
}
policy := &as.WritePolicy{
BasePolicy: *as.NewPolicy(),
RecordExistsAction: as.CREATE_ONLY,
GenerationPolicy: as.NONE,
Generation: 0,
Expiration: 0,
SendKey: false,
}
if err := db.Put(policy, key, bins); err != nil {
return err
}
*done = true
return nil
}
// Connect to the database, and initial setup
func connectToDatabase(host string, port int) {
var err error
// connect to the db
if db, err = as.NewClient(host, port); err != nil {
panic(err)
}
readPolicy = as.NewPolicy()
writePolicy = as.NewWritePolicy(0, 0)
scanPolicy = as.NewScanPolicy()
// index on offer_id of bids, so we can find bids on a given offer
if _, err := db.CreateIndex(writePolicy, "test", BIDS, "idx:br:1", "offer_id", as.NUMERIC); err != nil {
fmt.Printf("Create Index Failed: %s\n", err.Error())
}
// index on broker_id of bids, so we can find bids by a particular broker
if _, err := db.CreateIndex(writePolicy, "test", BIDS, "idx:br:2", "broker_id", as.NUMERIC); err != nil {
fmt.Printf("Create Index Failed: %s\n", err.Error())
}
// index on broker_id of offers, so we can find offers by a particular broker
if _, err := db.CreateIndex(writePolicy, "test", OFFERS, "idx:br:3", "broker_id", as.NUMERIC); err != nil {
fmt.Printf("Create Index Failed: %s\n", err.Error())
}
// index on ticker of prices
if _, err := db.CreateIndex(writePolicy, "test", PRICES, "idx:br:4", "ticker", as.STRING); err != nil {
fmt.Printf("Create Index Failed: %s\n", err.Error())
}
}
func loadASRecord(ns string, set string, pkey string) *as.Record {
var err error
key, err := as.NewKey(ns, set, pkey)
panicOnError(err)
policy := as.NewPolicy()
rec, err := client.Get(policy, key)
panicOnError(err)
return rec
}
func (c *client) getData(key *as.Key, result interface{}) bool {
policy := as.NewPolicy()
policy.Timeout = 3 * time.Second
policy.MaxRetries = 3
record, err := c.asClient.Get(policy, key)
panicOnError(err)
if record != nil {
if data, ok := record.Bins[binDataName]; ok {
json.Unmarshal([]byte(data.(string)), result)
return true
} else {
return false
}
} else {
return false
}
}
func NewAeroSpikeClient(cfg *Config) (*AeroSpikeClient, error) {
clientPolicy := aerospike.NewClientPolicy()
clientPolicy.ConnectionQueueSize = ConnectionQueueSize
clientPolicy.LimitConnectionsToQueueSize = true
clientPolicy.Timeout = 50 * time.Millisecond
hosts := []*aerospike.Host{}
for _, connStr := range cfg.AeroHostsPots {
hostStr, portStr, err := net.SplitHostPort(connStr)
if err != nil {
return nil, err
}
port, err := strconv.Atoi(portStr)
if err != nil {
return nil, err
}
hosts = append(hosts, aerospike.NewHost(hostStr, port))
}
client, err := aerospike.NewClientWithPolicyAndHost(clientPolicy, hosts...)
if err != nil {
return nil, err
}
getPolicy := aerospike.NewPolicy()
getPolicy.Timeout = time.Millisecond * 50
getPolicy.MaxRetries = maxRetries
out := &AeroSpikeClient{
namespace: cfg.AeroNamespace,
prefix: cfg.AeroPrefix,
getPolicy: getPolicy,
client: client,
}
return out, nil
}
func NewDB(host string, port int, namespace string) *DB {
return &DB{host, port, namespace, "", as.NewWritePolicy(0, 0), as.NewPolicy(), nil}
}
package shared
import (
"bytes"
"flag"
"fmt"
"log"
"math"
"os"
"runtime"
as "github.com/aerospike/aerospike-client-go"
)
var WritePolicy = as.NewWritePolicy(0, 0)
var Policy = as.NewPolicy()
var Host = flag.String("h", "127.0.0.1", "Aerospike server seed hostnames or IP addresses")
var Port = flag.Int("p", 3000, "Aerospike server seed hostname or IP address port number.")
var Namespace = flag.String("n", "test", "Aerospike namespace.")
var Set = flag.String("s", "testset", "Aerospike set name.")
var showUsage = flag.Bool("u", false, "Show usage information.")
var Client *as.Client
func ValidateBin(key *as.Key, bin *as.Bin, record *as.Record) {
if !bytes.Equal(record.Key.Digest(), key.Digest()) {
log.Fatalln(fmt.Sprintf("key `%s` is not the same as key `%s`.", key, record.Key))
}
if record.Bins[bin.Name] != bin.Value.GetObject() {
log.Fatalln(fmt.Sprintf("bin `%s: %v` is not the same as bin `%v`.", bin.Name, bin.Value, record.Bins[bin.Name]))