Golang NewRetryCassandraClientTimeout Examples

Example #1

File: db.go Project: starshipfactory/membersys

// Create a new connection to the membership database on the given "host".
// Will set the keyspace to "dbname".
func NewMembershipDB(host, dbname string, timeout time.Duration) (*MembershipDB, error) {
	var conn *cassandra.RetryCassandraClient
	var err error
	conn, err = cassandra.NewRetryCassandraClientTimeout(host, timeout)
	if err != nil {
		return nil, err
	}
	err = conn.SetKeyspace(dbname)
	if err != nil {
		return nil, err
	}
	return &MembershipDB{
		conn: conn,
	}, nil
}

Example #2

File: main.go Project: starshipfactory/starstock

func main() {
	var help bool
	var bindto, template_dir string
	var lockserv, lockboot, servicename string
	var ca, pub, priv, authserver string
	var requested_scope string
	var dbserver, keyspace string
	var searchif_tmpl *template.Template
	var permission_denied_tmpl *template.Template
	var exporter *exportedservice.ServiceExporter
	var authenticator *ancientauth.Authenticator
	var client *cassandra.RetryCassandraClient
	var ire *cassandra.InvalidRequestException
	var err error

	flag.BoolVar(&help, "help", false, "Display help")
	flag.StringVar(&bindto, "bind", "[::1]:8080",
		"The address to bind the web server to")
	flag.StringVar(&lockserv, "lockserver-uri",
		os.Getenv("DOOZER_URI"),
		"URI of a Doozer cluster to connect to")
	flag.StringVar(&ca, "cacert", "cacert.pem",
		"Path to the X.509 certificate of the certificate authority")
	flag.StringVar(&pub, "cert", "starstock.pem",
		"Path to the X.509 certificate")
	flag.StringVar(&priv, "key", "starstock.key",
		"Path to the X.509 private key file")
	flag.StringVar(&authserver, "auth-server",
		"login.ancient-solutions.com",
		"The server to send the user to")
	flag.StringVar(&template_dir, "template-dir", "",
		"Path to the directory with the HTML templates")
	flag.StringVar(&lockboot, "lockserver-boot-uri",
		os.Getenv("DOOZER_BOOT_URI"),
		"Boot URI to resolve the Doozer cluster name (if required)")
	flag.StringVar(&servicename, "service-name",
		"", "Service name to publish as to the lock server")
	flag.StringVar(&requested_scope, "scope",
		"staff", "People need to be in this scope to use the application")
	flag.StringVar(&dbserver, "cassandra-server", "localhost:9160",
		"Cassandra database server to use")
	flag.StringVar(&keyspace, "keyspace", "starstock",
		"Cassandra keyspace to use for accessing stock data")
	flag.Parse()

	if help {
		flag.Usage()
		os.Exit(1)
	}

	if len(template_dir) <= 0 {
		log.Fatal("The --template-dir flag must not be empty")
	}

	// Load and parse the HTML templates to be displayed.
	searchif_tmpl, err = template.ParseFiles(template_dir + "/search.tmpl")
	if err != nil {
		log.Fatal("Unable to parse search template: ", err)
	}

	// Load and parse the HTML templates to be displayed.
	permission_denied_tmpl, err = template.ParseFiles(template_dir +
		"/permission_denied.tmpl")
	if err != nil {
		log.Fatal("Unable to parse form template: ", err)
	}

	// Create the AncientAuth client
	authenticator, err = ancientauth.NewAuthenticator("StarStock", pub,
		priv, ca, authserver)
	if err != nil {
		log.Fatal("NewAuthenticator: ", err)
	}

	// Connect to the Cassandra server.
	client, err = cassandra.NewRetryCassandraClientTimeout(dbserver,
		10*time.Second)
	if err != nil {
		log.Fatal("Error opening connection to ", dbserver, ": ", err)
	}

	ire, err = client.SetKeyspace(keyspace)
	if ire != nil {
		log.Fatal("Error setting keyspace to ", keyspace, ": ", ire.Why)
	}
	if err != nil {
		log.Fatal("Error setting keyspace to ", keyspace, ": ", err)
	}

	// Register the URL handler to be invoked.
	http.Handle("/css/", http.FileServer(http.Dir(template_dir)))
	http.Handle("/js/", http.FileServer(http.Dir(template_dir)))
	http.Handle("/api/product", &ProductViewAPI{
		authenticator: authenticator,
		client:        client,
		scope:         requested_scope,
	})
	http.Handle("/api/edit-product", &ProductEditAPI{
		authenticator: authenticator,
		client:        client,
		scope:         requested_scope,
	})
	http.Handle("/api/products", &ProductSearchAPI{
		authenticator: authenticator,
		client:        client,
		scope:         requested_scope,
	})
	http.Handle("/", &ProductSearchForm{
		authenticator:        authenticator,
		scope:                requested_scope,
		searchifTmpl:         searchif_tmpl,
		permissionDeniedTmpl: permission_denied_tmpl,
	})

	// If a lock server was specified, attempt to use an anonymous port as
	// a Doozer exported HTTP service. Otherwise, just bind to the address
	// given in bindto, for debugging etc.
	if len(lockserv) > 0 {
		exporter, err = exportedservice.NewExporter(lockserv, lockboot)
		if err != nil {
			log.Fatal("doozer.DialUri ", lockserv, " (",
				lockboot, "): ", err)
		}

		defer exporter.UnexportPort()
		err = exporter.ListenAndServeNamedHTTP(servicename, bindto, nil)
		if err != nil {
			log.Fatal("ListenAndServe: ", err)
		}
	} else {
		err = http.ListenAndServe(bindto, nil)
		if err != nil {
			log.Fatal("ListenAndServe: ", err)
		}
	}
}