Sample Code

package main

import (
    "github.com/couchbase/gocb"
    "log"
    "time"
)

func main() {
    // Access the cluster that is running on the local host, authenticating with
    // the username and password of the Full Administrator. This
    // provides all privileges.
    cluster, err := gocb.Connect("couchbase://localhost")
    if err != nil {
        panic(err)
}

    // Authenticate to the cluster
    log.Printf("Authenticating as administrator.")
    cluster.Authenticate(gocb.PasswordAuthenticator{
    "Administrator",
    "password"})

    // Create a user and assign roles.
    log.Printf("Upserting new user.")
    userSettings := gocb.UserSettings{
        Password: "cbtestuserpwd",
        Roles: []gocb.UserRole{
            // Roles required for the reading of data from the bucket.
            {"data_reader", "travel-sample"},
            {"query_select", "travel-sample"},
            // Roles required for the writing data into the bucket.
            {"data_writer", "travel-sample"},
            {"query_insert", "travel-sample"},
            {"query_delete", "travel-sample"},
            // Role required for the creation of indexes on the bucket.
            {"query_manage_index", "travel-sample"},
        },
    }
    err = cluster.Manager("", "").UpsertUser("cbtestuser", &userSettings)
    if err != nil {
        panic(err)
    }

    time.Sleep(100 * time.Millisecond)

    // List current users
    users, err := cluster.Manager("","").GetUsers()
    if err != nil {
        panic(err)
    }
    for i, user := range users {
        log.Printf("")
        log.Printf("USER # %d", i)

        if user.Name != "" {
            log.Printf("Users name is: %s", user.Name)
        }

        log.Printf("Users id is: %s", user.Id)
        //log.Printf("Users domain is: %s", user.Domain)

        for _, role := range user.Roles {
            log.Printf("User has the role: %s, for bucket %s", role.Role, role.BucketName)
        }
        log.Printf("")
    }

    // Access the cluster that is running on the local host, specifying
    // the username and password already assigned by the administrator
    log.Printf("Authenticating as user")
    cluster.Authenticate(gocb.PasswordAuthenticator{
        "cbtestuser",
        "cbtestuserpwd",
    })

    // Open a known, existing bucket (created by the administrator).
    log.Printf("Opening travel-sample bucket as user")
    travelSample, err := cluster.OpenBucket("travel-sample", "")
    if err != nil {
        panic(err)
    }

    // Create a N1QL Primary Index (but ignore if one already exists).
    err = travelSample.Manager("", "").CreatePrimaryIndex("", true, false)
    if err != nil {
        panic(err)
    }

    // Read out a known, existing document within the bucket (created
    // by the administrator).
    log.Printf("Reading out airline_10 document")
    var airline10doc interface{}
    _, err = travelSample.Get("airline_10", &airline10doc)
    if err != nil {
        panic(err)
    }
    log.Printf("Found: %+v", airline10doc)

    // Create a new document.
    log.Printf("Creating new document as user.")
    airlineObj := map[string]interface{}{
        "callsign": "MILE-AIR",
        "iata": "Q5",
        "icao": "MLA",
        "id": 11,
        "name": "40-Mile Air",
        "type": "airline",
    }

    // Upsert the document to the bucket
    log.Printf("Upserting new document as user.")
    _, err = travelSample.Upsert("airline_11", airlineObj, 0)
    if err != nil {
        panic(err)
    }

    log.Printf("Reading out ariline11 document as user.")
    var airline11doc interface{}
    _, err = travelSample.Get("airline_11", &airline11doc)
    if err != nil {
        panic(err)
    }
    log.Printf("Found: %+v", airline11doc)


    // Perform a N1QL Query.
    log.Printf("Performing query as user.")
    q := gocb.NewN1qlQuery("SELECT * FROM `travel-sample` LIMIT 5")
    rows, err := travelSample.ExecuteN1qlQuery(q, nil)
    if err != nil {
        panic(err)
    }

    log.Printf("Query-results are:")
    // Print each row returned by the query.
    var row interface{}
    for rows.Next(&row) {
        log.Printf("%+v", row)
}

    // Access the cluster that is running on the local host, authenticating with
    // the username and password of the Full Administrator. This
    // provides all privileges.
    log.Printf("Re-authenticating as administrator.")
    cluster.Authenticate(gocb.PasswordAuthenticator{
        "Administrator",
        "password"})

    // Remove known user.
    log.Printf("Removing user as administrator.")
    userToBeRemoved := "cbtestuser"
    err = cluster.Manager("", "").RemoveUser(userToBeRemoved)
    if err != nil {
        log.Printf("Could not delete user %s: %s", userToBeRemoved, err)
    } else {
        log.Printf("Deleted user %s", userToBeRemoved)
    }

}