func (cp *Provider) getBucket() *couchbase.Bucket {
c, err := couchbase.Connect(cp.savePath)
if err != nil {
return nil
}
pool, err := c.GetPool(cp.pool)
if err != nil {
return nil
}
bucket, err := pool.GetBucket(cp.bucket)
if err != nil {
return nil
}
return bucket
}
func (r *Couchbase) gatherServer(addr string, acc telegraf.Accumulator, pool *couchbase.Pool) error {
if pool == nil {
client, err := couchbase.Connect(addr)
if err != nil {
return err
}
// `default` is the only possible pool name. It's a
// placeholder for a possible future Couchbase feature. See
// http://stackoverflow.com/a/16990911/17498.
p, err := client.GetPool("default")
if err != nil {
return err
}
pool = &p
}
for i := 0; i < len(pool.Nodes); i++ {
node := pool.Nodes[i]
tags := map[string]string{"cluster": addr, "hostname": node.Hostname}
fields := make(map[string]interface{})
fields["memory_free"] = node.MemoryFree
fields["memory_total"] = node.MemoryTotal
acc.AddFields("couchbase_node", fields, tags)
}
for bucketName, _ := range pool.BucketMap {
tags := map[string]string{"cluster": addr, "bucket": bucketName}
bs := pool.BucketMap[bucketName].BasicStats
fields := make(map[string]interface{})
fields["quota_percent_used"] = bs["quotaPercentUsed"]
fields["ops_per_sec"] = bs["opsPerSec"]
fields["disk_fetches"] = bs["diskFetches"]
fields["item_count"] = bs["itemCount"]
fields["disk_used"] = bs["diskUsed"]
fields["data_used"] = bs["dataUsed"]
fields["mem_used"] = bs["memUsed"]
acc.AddFields("couchbase_bucket", fields, tags)
}
return nil
}
func loadNamespace(s *site, name string) (*namespace, errors.Error) {
cbpool, err := s.client.GetPool(name)
if err != nil {
if name == "default" {
// if default pool is not available, try reconnecting to the server
url := s.URL()
var client cb.Client
if s.CbAuthInit == true {
client, err = cb.ConnectWithAuth(url, cbauth.NewAuthHandler(nil))
} else {
client, err = cb.Connect(url)
}
if err != nil {
return nil, errors.NewCbNamespaceNotFoundError(err, "Namespace "+name)
}
// check if the default pool exists
cbpool, err = client.GetPool(name)
if err != nil {
return nil, errors.NewCbNamespaceNotFoundError(err, "Namespace "+name)
}
s.client = client
}
}
rv := namespace{
site: s,
name: name,
cbNamespace: cbpool,
keyspaceCache: make(map[string]datastore.Keyspace),
}
return &rv, nil
}
func (p *namespace) refresh(changed bool) {
// trigger refresh of this pool
logging.Debugf("Refreshing pool %s", p.name)
newpool, err := p.site.client.GetPool(p.name)
if err != nil {
var client cb.Client
logging.Errorf("Error updating pool name %s: Error %v", p.name, err)
url := p.site.URL()
/*
transport := cbauth.WrapHTTPTransport(cb.HTTPTransport, nil)
cb.HTTPClient.Transport = transport
*/
if p.site.CbAuthInit == true {
client, err = cb.ConnectWithAuth(url, cbauth.NewAuthHandler(nil))
} else {
client, err = cb.Connect(url)
}
if err != nil {
logging.Errorf("Error connecting to URL %s", url)
return
}
// check if the default pool exists
newpool, err = client.GetPool(p.name)
if err != nil {
logging.Errorf("Retry Failed Error updating pool name %s: Error %v", p.name, err)
return
}
p.site.client = client
}
p.lock.Lock()
defer p.lock.Unlock()
for name, ks := range p.keyspaceCache {
logging.Debugf(" Checking keyspace %s", name)
newbucket, err := newpool.GetBucket(name)
if err != nil {
changed = true
ks.(*keyspace).deleted = true
logging.Errorf(" Error retrieving bucket %s", name)
delete(p.keyspaceCache, name)
} else if ks.(*keyspace).cbbucket.UUID != newbucket.UUID {
logging.Debugf(" UUid of keyspace %v uuid now %v", ks.(*keyspace).cbbucket.UUID, newbucket.UUID)
// UUID has changed. Update the keyspace struct with the newbucket
ks.(*keyspace).cbbucket = newbucket
}
// Not deleted. Check if GSI indexer is available
if ks.(*keyspace).gsiIndexer == nil {
ks.(*keyspace).refreshIndexer(p.site.URL(), p.Name())
}
}
if changed == true {
p.setPool(newpool)
}
}
// NewSite creates a new Couchbase site for the given url.
func NewDatastore(u string) (s datastore.Datastore, e errors.Error) {
var client cb.Client
var cbAuthInit bool
// try and initialize cbauth
c, err := initCbAuth(u)
if err != nil {
logging.Errorf(" Unable to initialize cbauth. Error %v", err)
url, err := url.Parse(u)
if err != nil {
return nil, errors.NewCbUrlParseError(err, "url "+u)
}
if url.User != nil {
password, _ := url.User.Password()
if password == "" {
logging.Errorf("No password found in url %s", u)
}
// intialize cb_auth variables manually
logging.Infof(" Trying to init cbauth with credentials %s %s", url.Host, url.User.Username())
set, err := cbauth.InternalRetryDefaultInit(url.Host, url.User.Username(), password)
if set == false || err != nil {
logging.Errorf(" Unable to initialize cbauth variables. Error %v", err)
} else {
c, err = initCbAuth("http://" + url.Host)
if err != nil {
logging.Errorf("Unable to initliaze cbauth. Error %v", err)
} else {
client = *c
cbAuthInit = true
}
}
}
} else {
client = *c
cbAuthInit = true
}
if cbAuthInit == false {
// connect without auth
logging.Warnf("Unable to intialize cbAuth, access to couchbase buckets may be restricted")
cb.HTTPClient = &http.Client{}
client, err = cb.Connect(u)
if err != nil {
return nil, errors.NewCbConnectionError(err, "url "+u)
}
}
site := &site{
client: client,
namespaceCache: make(map[string]*namespace),
CbAuthInit: cbAuthInit,
}
// initialize the default pool.
// TODO can couchbase server contain more than one pool ?
defaultPool, Err := loadNamespace(site, "default")
if Err != nil {
logging.Errorf("Cannot connect to default pool")
return nil, Err
}
site.namespaceCache["default"] = defaultPool
logging.Infof("New site created with url %s", u)
return site, nil
}