예제 #1
0
// NewRedisClient return a new RedisClient given the provided RedisOptions
func NewRedisClient(opts RedisOptions) (*RedisClient, error) {
	if opts.ClientID == "" {
		id, err := gocql.RandomUUID()
		if err != nil {
			return nil, err
		}
		opts.ClientID = id.String()
	}
	if opts.Network == "" {
		opts.Network = "tcp"
	}

	if opts.Namespace == "" {
		opts.Namespace = "glock:"
	}

	if opts.DialFunc == nil {
		opts.DialFunc = redis.Dial
	}
	c := RedisClient{nil, opts}
	err := c.Reconnect()
	if err != nil {
		return nil, err
	}
	return &c, nil
}
예제 #2
0
func TestUUID(t *testing.T) {
	type KeyValue struct {
		Id   gocql.UUID `json:"id" cql:"key"`
		Text string     `json:"id" cql:"value"`
	}

	s := setup(t, "key_value")
	defer s.Close()

	id, err := gocql.RandomUUID()
	assert.NoError(t, err)

	kv := KeyValue{
		Id:   id,
		Text: "hello world",
	}

	if err := Bind(`INSERT INTO key_value (key, value) VALUES (?, ?)`, &kv).Exec(s); err != nil {
		t.Fatal(err)
	}

	q := s.Query(`SELECT key, value FROM key_value LIMIT 1`)
	b := BindQuery(q)

	var read KeyValue

	b.Scan(&read)
	if err := b.Close(); err != nil {
		t.Fatal(err)
	}

	assert.Equal(t, kv, read)

}
예제 #3
0
//StoreBatchEvents stores multiple events from models.EventTrackingPayload within a batch
func (d *StorageDatastore) StoreBatchEvents(p *models.EventTrackingPayload) error {
	batch := gocql.NewBatch(gocql.LoggedBatch)

	statement := `INSERT INTO tracking.events (id, client, name, date, properties) VALUES (?, ?, ?, ?, ?)`

	for _, e := range p.Events {
		//Generate a new UUID
		u4, err := gocql.RandomUUID()
		if err != nil {
			return err
		}
		//map properties
		var propMap map[string]string
		propMap = make(map[string]string)
		for _, property := range e.Properties {
			propMap[property.Name] = property.Value
		}
		//Add to batch
		batch.Query(statement, u4.String(), p.Token, e.Name, e.Date, propMap)
	}

	err := d.Session.ExecuteBatch(batch)
	if err != nil {
		return err
	}

	return nil
}
func generateSerieIds(count int) []gocql.UUID {
	result := make([]gocql.UUID, count)

	for i := 0; i < count; i++ {
		result[i], _ = gocql.RandomUUID()
	}

	return result
}
예제 #5
0
func requestID(inner http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		//uid := uuid.TimeUUID()
		uuid, err := gocql.RandomUUID()
		if err == nil {
			r.Header.Set("Request-Id", uuid.String())
		}
		w.Header().Set("Request-Id", r.Header.Get("Request-Id"))

		inner.ServeHTTP(w, r)
	})
}
예제 #6
0
// NewCassandraLockClient creates a new client from options
func NewCassandraLockClient(opts CassandraOptions) (*CassandraClient, error) {
	if opts.ReplicationFactor <= 0 {
		opts.ReplicationFactor = 1
	}
	consistency := gocql.Quorum

	if opts.ReplicationFactor == 0 {
		consistency = gocql.One
	}

	var session *gocql.Session
	var err error
	var c CassandraClient
	for proto := 4; proto > 1; proto-- {
		c = CassandraClient{nil, opts.Hosts, "", "", "", nil, proto, consistency}
		c.cluster = gocql.NewCluster(opts.Hosts...)
		c.cluster.ProtoVersion = proto
		session, err = c.cluster.CreateSession()
		if err == nil {
			break
		}
	}
	if err != nil {
		return nil, err
	}
	err = session.Query(
		fmt.Sprintf(createKs, opts.KeySpace, opts.ReplicationFactor),
	).Exec()
	if err != nil {
		return nil, err
	}

	err = session.Query(
		fmt.Sprintf(createTable, opts.KeySpace, opts.TableName),
	).Exec()
	if err != nil {
		return nil, err
	}

	id, err := gocql.RandomUUID()
	if err != nil {
		return nil, err
	}

	c.hosts = opts.Hosts
	c.keyspace = opts.KeySpace
	c.table = opts.TableName
	c.clientID = id.String()
	c.Reconnect()

	return &c, nil
}
예제 #7
0
func fakeUuid() gocql.UUID {
	initUuids.Do(func() {
		for i := 0; i < 5; i++ {
			u, err := gocql.RandomUUID()
			if err != nil {
				panic(err)
			}
			selectUuids = append(selectUuids, u)
		}
	})

	return selectUuids[rand.Intn(len(selectUuids))]
}
예제 #8
0
func getRandom(session *gocql.Session) [][]string {
	var first, rest, defn string
	rval := make([][]string, 0)
	random, _ := gocql.RandomUUID()
	iter := session.Query(`select first, rest, defn from defs where TOKEN(first) > TOKEN(?) limit 1`, random.String()).Consistency(gocql.One).Iter()
	for iter.Scan(&first, &rest, &defn) {
		rval = append(rval, []string{first, rest, defn})
	}
	if err := iter.Close(); err != nil {
		log.Fatal(err)
	}
	return rval
}
예제 #9
0
func (conn *CassConnection) CreateDevice(
	name string,
	uuid *gocql.UUID,
	secretKey string,
	publicAccessLevel datalayer.AccessLevel) (datalayer.Device, error) {
	// TODO: validate parameters
	var id gocql.UUID
	var err error

	if uuid == nil {
		id, err = gocql.RandomUUID()
		if err != nil {
			return nil, err
		}
	} else {
		id = *uuid
	}

	if secretKey == "" {
		secretKey, err = random.Base64String(24)
		if err != nil {
			return nil, err
		}
	}

	err = conn.session.Query(`
            INSERT INTO devices (device_id, secret_key, friendly_name, public_access_level)
            VALUES (?, ?, ?, ?)
    `, id, secretKey, name, publicAccessLevel).Exec()
	if err != nil {
		canolog.Error("Error creating device:", err)
		return nil, err
	}
	return &CassDevice{
		conn:              conn,
		deviceId:          id,
		secretKey:         secretKey,
		name:              name,
		doc:               sddl.Sys.NewEmptyDocument(),
		docString:         "",
		publicAccessLevel: publicAccessLevel,
		locationNote:      "",
		wsConnected:       false,
	}, nil
}
// Retweet creates a new retweet (copy of) an existing tweet
func Retweet(s *gocql.Session, username string, id gocql.UUID) (*Tweet, error) {
	ot, err := GetTweet(s, id)
	if err != nil {
		return &Tweet{}, err
	}
	nid, err := gocql.RandomUUID()
	if err != nil {
		return &Tweet{}, err
	}
	t := Tweet{
		ID:         nid,
		Username:   username,
		Message:    ot.Message,
		IsRetweet:  true,
		OriginalID: id,
	}
	return &t, CreateTweet(s, &t)
}
예제 #11
0
func NewCassandraDatastore() (*CassandraDatastore, error) {
	ds := &CassandraDatastore{
		cf: GetCassandraConfig(),
	}
	var err error
	ds.db, err = ds.cf.CreateSession()
	if err != nil {
		return nil, fmt.Errorf("Failed to create cassandra datastore: %v", err)
	}
	ds.addedDomains = lrucache.New(Config.AddedDomainsCacheSize)

	u, err := gocql.RandomUUID()
	if err != nil {
		return ds, err
	}
	ds.crawlerUuid = u

	return ds, nil
}
예제 #12
0
func Create() (*Fields, error) {
	var err error
	m := &Fields{Exists: false}
	for {
		m.UUID, err = gocql.RandomUUID()
		if err != nil {
			return nil, err
		}
		var row = map[string]interface{}{}
		var apply bool
		if apply, err = CQLSession.Query(`insert into live_planets (planet_uuid,create_time) values (?,now()) if not exists`, m.UUID).MapScanCAS(row); err != nil {
			logger.Error(errors.New(err))
			return nil, err
		}
		if apply {
			break
		}
	}
	return m, nil
}
예제 #13
0
파일: century.go 프로젝트: mr-tron/century
func login(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	if r.Method == "POST" {
		r.ParseForm()
		login := r.Form["login"][0]
		password := password_hash((r.Form["password"][0]))
		var existed_login string
		var existed_cookie gocql.UUID
		var cookie gocql.UUID
		if err := session.Query("SELECT login FROM users WHERE login = ? and password = ?", login, password).Consistency(gocql.One).Scan(&existed_login); err != nil {
			fmt.Println(err)
		}
		if existed_login != "" {
			if err := session.Query("SELECT cookie FROM cookies WHERE login = ?", login).Consistency(gocql.One).Scan(&existed_cookie); err != nil {
				if err == gocql.ErrNotFound {
					cookie, _ = gocql.RandomUUID()
					if err := session.Query("INSERT INTO cookies (login, cookie) VALUES (?, ?)", login, cookie).Exec(); err != nil {
						w.WriteHeader(500)
						return
					}
				} else {
					w.WriteHeader(500)
					return
				}
			} else {
				cookie = existed_cookie
			}
			w.Header().Set("Set-Cookie", "sessionToken="+cookie.String())
			fmt.Fprintf(w, "{\"error\":\"\"}\n")
		} else {
			w.WriteHeader(403)
			fmt.Fprintf(w, "{\"error\":\"User or password is wrong\"}\n")
			return
		}
	} else {
		w.WriteHeader(405)
		fmt.Fprintf(w, "{\"error\":\"Allowed methods: POST\"}\n")
	}
}
예제 #14
0
파일: basic.go 프로젝트: arkxu/cqlc
func main() {

	session := integration.TestSession("127.0.0.1", "cqlc")
	cqlc.Truncate(session, BASIC)

	result := "FAILED"

	ctx := cqlc.NewContext()

	uuid, _ := gocql.RandomUUID()

	biggie := new(big.Int)
	biggie.SetString("830169365738487321165427203929228", 10)

	basic := Basic{
		Id:              "x",
		Int32Column:     111,
		Int64Column:     1 << 32,
		AsciiColumn:     "ABC",
		TimestampColumn: time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC), // Keep it simple for reflect.DeepEqual
		BooleanColumn:   true,
		TextColumn:      "foo",
		VarcharColumn:   "bar",
		FloatColumn:     math.MaxFloat32,
		DoubleColumn:    math.MaxFloat64,
		DecimalColumn:   inf.NewDec(1, 3),
		VarintColumn:    biggie,
		TimeuuidColumn:  gocql.TimeUUID(),
		UuidColumn:      uuid,
		MapColumn:       map[string]string{"baz": "quux"},
		ArrayColumn:     []string{"baz", "quux"},
		SetColumn:       []string{"baz", "quux"},
	}

	create(ctx, session, basic)

	iter, err := ctx.Select(
		BASIC.ID,
		BASIC.ASCII_COLUMN,
		BASIC.INT32_COLUMN,
		BASIC.INT64_COLUMN,
		BASIC.FLOAT_COLUMN,
		BASIC.DOUBLE_COLUMN,
		BASIC.DECIMAL_COLUMN,
		BASIC.VARINT_COLUMN,
		BASIC.TIMESTAMP_COLUMN,
		BASIC.TIMEUUID_COLUMN,
		BASIC.UUID_COLUMN,
		BASIC.BOOLEAN_COLUMN,
		BASIC.TEXT_COLUMN,
		BASIC.VARCHAR_COLUMN,
		BASIC.MAP_COLUMN,
		BASIC.ARRAY_COLUMN,
		BASIC.SET_COLUMN).
		From(BASIC).
		Where(BASIC.ID.Eq("x")).
		Fetch(session)

	if err != nil {
		log.Fatalf("Could not bind data: %v", err)
		os.Exit(1)
	}

	result, _ = checkBasics(iter, basic)

	iter, err = ctx.Select(
		BASIC.ID,
		BASIC.ASCII_COLUMN,
		BASIC.INT32_COLUMN,
		BASIC.INT64_COLUMN,
		BASIC.FLOAT_COLUMN,
		BASIC.DOUBLE_COLUMN,
		BASIC.DECIMAL_COLUMN,
		BASIC.VARINT_COLUMN,
		BASIC.TIMESTAMP_COLUMN,
		BASIC.TIMEUUID_COLUMN,
		BASIC.UUID_COLUMN,
		BASIC.BOOLEAN_COLUMN,
		BASIC.TEXT_COLUMN,
		BASIC.VARCHAR_COLUMN,
		BASIC.MAP_COLUMN,
		BASIC.ARRAY_COLUMN,
		BASIC.SET_COLUMN).
		From(BASIC).
		Fetch(session)

	if err != nil {
		log.Fatalf("Could not bind data: %v", err)
		os.Exit(1)
	}

	result, _ = checkBasics(iter, basic)

	// TODO write test case for a non-matching WHERE clause

	os.Stdout.WriteString(result)
}
예제 #15
0
//
// Config alteration right up front
//
func modifyConfigDataSource() {
	walker.Config.Cassandra.Keyspace = "walker_test_model"
	walker.Config.Cassandra.Hosts = []string{"localhost"}
	walker.Config.Cassandra.ReplicationFactor = 1
}

//
// Some global data
//
var fooTime = time.Now().AddDate(0, 0, -1)
var testTime = time.Now().AddDate(0, 0, -2)
var bazUuid, _ = gocql.RandomUUID()
var testComLinkOrder []console.LinkInfo
var testComLinkHash = map[string]console.LinkInfo{
	"http://test.com/page1.html": console.LinkInfo{
		Url:            "http://test.com/page1.html",
		Status:         200,
		Error:          "",
		RobotsExcluded: false,
		CrawlTime:      walker.NotYetCrawled,
	},

	"http://test.com/page2.html": console.LinkInfo{
		Url:            "http://test.com/page2.html",
		Status:         200,
		Error:          "",
		RobotsExcluded: false,