本文整理汇总了Golang中github.com/gocql/gocql.NewCluster函数的典型用法代码示例。如果您正苦于以下问题:Golang NewCluster函数的具体用法?Golang NewCluster怎么用?Golang NewCluster使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NewCluster函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: TestCassandra
// Test a Cassandra database
func TestCassandra(t *testing.T) {
cluster := gocql.NewCluster("127.0.0.1")
cluster.Keyspace = "testkeyspace"
cluster.Consistency = gocql.Quorum
session, err := cluster.CreateSession()
if err != nil {
t.Fatal("createsession", err)
}
defer session.Close()
err = session.Query(`CREATE KEYSPACE IF NOT EXISTS testkeyspace with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };`).Exec()
if err != nil {
t.Fatal("createkeyspace", err)
}
_ = session.Query(`DROP TABLE IF EXISTS passwords`).Exec()
err = session.Query(`CREATE TABLE testkeyspace.passwords(password text, PRIMARY KEY(password));`).Exec()
if err != nil {
t.Fatal("createkeyspace", err)
}
defer session.Query(`DROP TABLE IF EXISTS passwords`).Exec()
db := New(session, "passwords")
err = drivers.TestImport(db)
if err != nil {
t.Fatal(err)
}
err = drivers.TestData(db)
if err != nil {
t.Fatal(err)
}
}
示例2: TestCreate
func TestCreate(t *testing.T) {
cluster := gocql.NewCluster("127.0.0.1")
cluster.ProtoVersion = 4
cluster.Keyspace = "aaas"
session, err := cluster.CreateSession()
if err != nil {
panic(err)
}
defer session.Close()
asset := &Asset{
Name: "test1",
Path: []string{"a", "b"},
ContentType: "image/jpeg",
}
err = asset.Save(session)
if err != nil {
log.Panic(err)
}
err = asset.Delete(session, asset.Id.String())
if err != nil {
log.Panic(err)
}
log.Println(asset)
}
示例3: NewAPI
// NewAPI creates a new instance of API from the given configuration.
func NewAPI(config api.Config) (api.API, error) {
file, err := os.Open(config.ConversionRulesPath)
if err != nil {
return nil, err
}
bytes, err := ioutil.ReadAll(file)
if err != nil {
return nil, err
}
ruleset, err := LoadYAML(bytes)
if err != nil {
return nil, err
}
clusterConfig := gocql.NewCluster()
clusterConfig.Hosts = config.Hosts
clusterConfig.Keyspace = config.Keyspace
clusterConfig.Timeout = time.Second * 30
db, err := NewCassandraDatabase(clusterConfig)
if err != nil {
return nil, err
}
return &defaultAPI{
db: db,
ruleset: ruleset,
}, nil
}
示例4: newCassandraDriver
func newCassandraDriver(ctx *cli.Context) (drivers.Driver, error) {
urls := strings.Split(ctx.String("cassandra-hosts"), ",")
cluster := gocql.NewCluster()
cluster.Hosts = urls
cluster.Port = ctx.Int("cassandra-port")
cluster.Keyspace = ctx.String("cassandra-keyspace")
cluster.Consistency = gocql.Quorum
session, err := cluster.CreateSession()
if err != nil {
log.Errorf("cassandra.go: Error while creating cassandra cluster: hosts:%v err:%v", cluster.Hosts, err)
return nil, err
}
log.Infoln("cassandra.go: connected to cassandra cluster")
d := &CassandraDriver{
Session: session,
Cluster: cluster,
}
return d, nil
}
示例5: main
func main() {
// connect to the cluster
cluster := gocql.NewCluster("192.168.1.54")
cluster.Keyspace = "example"
cluster.Consistency = gocql.Quorum
session, _ := cluster.CreateSession()
defer session.Close()
// insert a tweet
// if err := session.Query(`INSERT INTO tweet (timeline, id, text, name, time) VALUES (?, ?, ?, ?, ?)`,
// "me", gocql.TimeUUID(), "hello world", "Ninoy", time.Now()).Exec(); err != nil {
// log.Fatal(err)
// }
var id gocql.UUID
var text string
/* Search for a specific set of records whose 'timeline' column matches
* the value 'me'. The secondary index that we created earlier will be
* used for optimizing the search */
// if err := session.Query(`SELECT id, text FROM tweet WHERE timeline = ? LIMIT 1`,
// "me").Scan(&id, &text); err != nil {
// log.Fatal(err)
// }
// fmt.Println("Tweet:", id, text)
// list all tweets
iter := session.Query(`SELECT id, text FROM tweet WHERE time < ? allow filtering`, time.Now()).Iter()
for iter.Scan(&id, &text) {
fmt.Println("Tweet:", id, text)
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
}
示例6: getTracingLog
//getTracingLog gets the tracing log by scanning the cql database
func getTracingLog() string {
// connect to the cluster
cluster := gocql.NewCluster(config.Cassandra.IP)
cluster.Keyspace = "system_traces"
cluster.Consistency = gocql.Quorum
session, err := cluster.CreateSession()
if err != nil {
panic(fmt.Sprintf("error creating session: %v", err))
}
defer session.Close()
e := events{}
var queryEvents = `SELECT session_id, event_id, activity, source, source_elapsed, thread FROM system_traces.events;`
iter := session.Query(queryEvents).Consistency(gocql.One).Iter()
fmt.Println("Fetched events")
var eOutput = ""
for iter.Scan(&e.SessionID, &e.EventID, &e.Activity, &e.Source, &e.SourceElapsed, &e.Thread) {
fmt.Println("Event: ", e.EventID, e.Activity, e.Source, e.SourceElapsed, e.Thread)
eOutput += "Event: " + "\t" + e.EventID + "\t" + e.Activity + "\t" + e.Source + "\t" + e.SourceElapsed + "\t" + e.Thread + "\n"
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
return eOutput
}
示例7: init
func init() {
kname := "test_ihopeudonthaveakeyspacenamedlikedthis"
var err error
cluster := gocql.NewCluster(getTestHosts()...)
cluster.Consistency = gocql.One
cluster.Timeout = 10 * time.Second // Travis' C* is sloooow
cluster.MaxWaitSchemaAgreement = 2 * time.Minute // travis might be slow
cluster.RetryPolicy = &gocql.SimpleRetryPolicy{
NumRetries: 3}
sess, err := cluster.CreateSession()
if err != nil {
panic(err)
}
conn := &connection{q: goCQLBackend{session: sess}}
ns = conn.KeySpace(kname)
err = conn.DropKeySpace(kname)
if err != nil {
panic(err)
}
err = conn.CreateKeySpace(kname)
if err != nil {
panic(err)
}
}
示例8: NewAdaptor
// New db adaptor
func NewAdaptor(urls []string, username, password string) *Adaptor {
cluster := gocql.NewCluster(urls...)
cluster.Keyspace = "events"
cluster.ProtoVersion = 3
// cluster.Authenticator = gocql.PasswordAuthenticator{
// Username: username,
// Password: password,
// }
session, err := cluster.CreateSession()
if err != nil {
log.Fatalf("Cassandra conn error: %s", err.Error())
}
qe := gocassa.GoCQLSessionToQueryExecutor(session)
conn := gocassa.NewConnection(qe)
gocassaSession := conn.KeySpace("events")
return &Adaptor{
Session: gocassaSession,
urls: urls,
eventTimeDateRange: 7 * 24 * time.Hour,
Username: username,
Password: password,
}
}
示例9: init
func init() {
kname := "test_ihopeudonthaveakeyspacenamedlikedthis"
var err error
c, err := Connect(getTestHosts(), "", "")
if err != nil {
panic(err)
}
err = c.DropKeySpace(kname)
if err != nil {
panic(err)
}
err = c.CreateKeySpace(kname)
if err != nil {
panic(err)
}
cluster := gocql.NewCluster(getTestHosts()...)
cluster.Consistency = gocql.One
cluster.Timeout = 1500 * time.Millisecond // Travis' C* is sloooow
cluster.RetryPolicy = &gocql.SimpleRetryPolicy{
NumRetries: 3}
sess, err := cluster.CreateSession()
if err != nil {
panic(err)
}
conn := &connection{q: goCQLBackend{session: sess}}
ns = conn.KeySpace(kname)
}
示例10: NewServer
// NewServer returns a new instance of Server built from a config.
func NewServer(c *Config, buildInfo *BuildInfo) (*Server, error) {
elasticsearch := elastigo.NewConn()
elasticsearch.SetFromUrl(c.Meta.ElasticSearchUrl)
db := gocql.NewCluster(c.Database.CassandraNodes...)
db.Keyspace = c.Database.CassandraKeyspace
db.NumConns = c.Database.CassandraConns
db.Discovery = gocql.DiscoveryConfig{
DcFilter: "",
RackFilter: "",
Sleep: 30 * time.Second,
}
s := &Server{
buildInfo: *buildInfo,
err: make(chan error),
closing: make(chan struct{}),
Hostname: c.Meta.Hostname,
BindAddress: c.Meta.BindAddress,
elasticsearch: elasticsearch,
cassandra: db,
}
// Append services.
//s.appendMongoService(c.Mongo)
s.appendMetricsReportingService(c.Meta)
s.appendHTTPDService(c.HTTPD)
s.appendRegistrationService(c.Registration, c.RegMeta)
return s, nil
}
示例11: main
func main() {
// set the parameters for our cassandra connection
cluster := gocql.NewCluster("127.0.0.1")
cluster.DiscoverHosts = true
cluster.DefaultTimestamp = false
// establish the cassandra session
session, err := cluster.CreateSession()
if err != nil {
fmt.Println("could not create session")
os.Exit(1)
}
defer session.Close()
// get a list of iles in the logs folder
files, err := ioutil.ReadDir(path.Join("..", logDir))
if err != nil {
fmt.Println("could not read logs folder")
os.Exit(1)
}
// iterate through files for processing
for _, file := range files {
err := process(file)
if err != nil {
fmt.Printf("%v", err)
}
}
fmt.Printf("processed %v files\n", len(files))
os.Exit(0)
}
示例12: main
func main() {
log.Println("Main")
db := gocql.NewCluster("127.0.0.1", "127.0.0.2", "127.0.0.3")
db.Keyspace = "test"
db.ProtoVersion = 4
db.Consistency = gocql.Quorum
log.Println(db)
now := time.Now()
//numberOfWorker := 1
//w := Writer{100000, db}
//w.Run()
numberOfWorker := 3
var wg sync.WaitGroup
wg.Add(numberOfWorker)
for i := 0; i < numberOfWorker; i++ {
go func(i int, conn *gocql.ClusterConfig, wg *sync.WaitGroup) {
w := Writer{100000, conn}
w.Run()
log.Println("Writer", i, "finished")
wg.Done()
}(i, db, &wg)
}
wg.Wait()
log.Println(numberOfWorker, "Writer", "took", time.Now().Sub(now))
}
示例13: getSessionLog
//getSessionLog returns the cassandra session log by scanning the database
func getSessionLog() string {
// connect to the cluster
cluster := gocql.NewCluster(config.Cassandra.IP)
cluster.Keyspace = "system_traces"
cluster.Consistency = gocql.Quorum
session, err := cluster.CreateSession()
if err != nil {
panic(fmt.Sprintf("error creating session: %v", err))
}
defer session.Close()
s := sessions{}
var querySessions = `SELECT session_id, coordinator, duration, parameters, request, started_at FROM system_traces.sessions;`
iter := session.Query(querySessions).Consistency(gocql.One).Iter()
fmt.Println("Fetched sessions")
var sOutput = ""
for iter.Scan(&s.SessionID, &s.Coordinator, &s.Duration, &s.Parameters, &s.Request, &s.StartedAt) {
//fmt.Println("Session: ", &s.SessionID, s.Coordinator, s.Duration, s.Parameters, s.Request, s.StartedAt)
var param = "{"
for paramKeys, paramValue := range s.Parameters {
param = param + paramKeys + ": " + paramValue + ", "
}
param += "} "
sOutput += "Session:\t" + s.SessionID + "\t" + s.Coordinator + "\t" + s.Duration + "\t" + param + "\t" + s.Request + "\t" + s.StartedAt.String() + "\n"
}
if err := iter.Close(); err != nil {
log.Fatal(err)
}
log.Println(sOutput)
return sOutput
}
示例14: Initialize
// Cassandra Driver URL format:
// cassandra://host:port/keyspace
//
// Example:
// cassandra://localhost/SpaceOfKeys
func (driver *Driver) Initialize(rawurl string) error {
u, err := url.Parse(rawurl)
cluster := gocql.NewCluster(u.Host)
cluster.Keyspace = u.Path[1:len(u.Path)]
cluster.Consistency = gocql.All
cluster.Timeout = 1 * time.Minute
// Check if url user struct is null
if u.User != nil {
password, passwordSet := u.User.Password()
if passwordSet == false {
return fmt.Errorf("Missing password. Please provide password.")
}
cluster.Authenticator = gocql.PasswordAuthenticator{
Username: u.User.Username(),
Password: password,
}
}
driver.session, err = cluster.CreateSession()
if err != nil {
return err
}
if err := driver.ensureVersionTableExists(); err != nil {
return err
}
return nil
}
示例15: main
func main() {
cluster := gocql.NewCluster("127.0.0.1")
for v := 3; v < 4; v++ {
cluster.ProtoVersion = v
session, err := cluster.CreateSession()
if err != nil {
log.Printf("Error openning session: %s\n", err.Error())
continue
}
session.SetPageSize(123)
session.SetConsistency(gocql.LocalQuorum)
qry := session.Query(`
CREATE KEYSPACE foo
WITH REPLICATION {
'class': 'SimpleStrategy',
'replication_factor': 3
}`,
"foo",
"bar",
)
// qry.Consistency(gocql.Any).PageSize(987)
qry.SerialConsistency(gocql.LocalSerial)
if err := qry.Exec(); err != nil {
log.Printf("Error executing query: %s\n", err.Error())
}
session.Close()
}
}