func Get(UUID gocql.UUID) (*Fields, error) {
var err error
uuid := UUID.String()
mutex.RLock()
m, ok := Models[uuid]
mutex.RUnlock()
if !ok {
m, err = Load(UUID)
if err != nil {
return nil, err
}
if m == nil {
return nil, nil
}
mutex.Lock()
m2, ok := Models[uuid]
if ok {
mutex.Unlock()
return m2, nil
}
Models[uuid] = m
mutex.Unlock()
m.Update(model.Fields{
"IsLock": true,
"LockServerUUID": LockServerUUID,
})
}
return m, nil
}
func Get(UUID gocql.UUID) *Server {
s := &Server{UUID: UUID, Exists: false}
var row = map[string]interface{}{}
var uuid = UUID.String()
if err := CQLSession.Query(`SELECT * FROM servers where server_uuid = ?`, uuid).MapScan(row); err != nil {
if err != gocql.ErrNotFound {
logger.Error(errors.New(err))
}
return s
}
s.Exists = true
s.IP = row["ip"].(string)
s.Port = uint16(row["port"].(int))
t := time.Now().Unix()
if t-row["live_ts"].(int64) > 10 {
s.Exists = false
}
return s
}
// Returns all oinks, from newest to oldest
func (r *CQLOinkRepo) All() ([]Oink, error) {
session, err := r.cluster.CreateSession()
if err != nil {
return nil, fmt.Errorf("Creating CQL Session: %s", err)
}
defer session.Close()
iter := session.Query(
"SELECT id, content, created_at, handle FROM oinks "+
"WHERE kind = ? ORDER BY created_at DESC",
"oink",
).Iter()
var (
id, content, handle string
creationTime gocql.UUID
)
oinks := make([]Oink, 0)
for iter.Scan(&id, &content, &creationTime, &handle) {
oink := Oink{
ID: id,
Content: content,
CreationTime: creationTime.Time(),
Handle: handle,
}
oinks = append(oinks, oink)
}
if err := iter.Close(); err != nil {
return nil, fmt.Errorf("Selecting oink (id: %s): %s", id, err)
}
return oinks, nil
}
func (storageCassandra *StorageCassandra) LoadImageRecord(imageInformationName string, version string) (*ImageRecord, error) {
session, err := cassandra.CassandraClient.GetSession()
if err != nil {
log.Error("Get session error %s", err)
return nil, err
}
imageRecord := new(ImageRecord)
var uuid gocql.UUID
err = session.Query("SELECT image_information, version, path, version_info, environment, description, created_time FROM image_record WHERE image_information = ? AND version = ?", imageInformationName, version).Scan(
&imageRecord.ImageInformation,
&imageRecord.Version,
&imageRecord.Path,
&imageRecord.VersionInfo,
&imageRecord.Environment,
&imageRecord.Description,
&uuid,
)
if err != nil {
log.Error("Load ImageRecord %s version %s error: %s", imageInformationName, version, err)
return nil, err
} else {
imageRecord.CreatedTime = uuid.Time()
return imageRecord, nil
}
}
func (querier Querier) QueryForPosts(subName string) ([]*Post, error) {
var id gocql.UUID
var title string
var upvotes int
var downvotes int
var commentCount int
var createdAt time.Time
var updatedAt time.Time
var posts []*Post
iter := querier.Session.Query(`SELECT id, title, upvotes, downvotes, created_at, updated_at, comment_count FROM posts WHERE sub_id = ?`,
subName).Iter()
for iter.Scan(&id, &title, &upvotes, &downvotes, &createdAt, &updatedAt, &commentCount) {
posts = append(posts, &Post{
id.String(),
title,
"",
"",
"",
subName,
upvotes,
downvotes,
commentCount,
createdAt,
updatedAt,
})
}
return posts, nil
}
func (storageCassandra *StorageCassandra) LoadImageRecordWithImageInformationName(imageInformationName string) ([]ImageRecord, error) {
session, err := cassandra.CassandraClient.GetSession()
if err != nil {
log.Error("Get session error %s", err)
return nil, err
}
iter := session.Query("SELECT image_information, version, path, version_info, environment, description, created_time FROM image_record WHERE image_information = ?", imageInformationName).Iter()
imageRecordSlice := make([]ImageRecord, 0)
imageRecord := new(ImageRecord)
var uuid gocql.UUID
for iter.Scan(&imageRecord.ImageInformation, &imageRecord.Version, &imageRecord.Path, &imageRecord.VersionInfo, &imageRecord.Environment, &imageRecord.Description, &uuid) {
imageRecord.CreatedTime = uuid.Time()
imageRecordSlice = append(imageRecordSlice, *imageRecord)
imageRecord = new(ImageRecord)
}
err = iter.Close()
if err != nil {
log.Error("Load ImageRecord %s error: %s", imageInformationName, err)
return nil, err
} else {
return imageRecordSlice, nil
}
}
func (r *CQLOinkRepo) FindByID(id string) (model.Oink, bool, error) {
r.lock.RLock()
defer r.lock.RUnlock()
if !r.initialized {
return model.Oink{}, false, errors.New("Uninitialized repo")
}
iter := r.session.Query("SELECT content, created_at, handle FROM oinker.oinks WHERE id = ?", id).Iter()
var (
content string
creationTime gocql.UUID
handle string
)
oink := model.Oink{
ID: id,
}
if iter.Scan(&content, &creationTime, &handle) {
oink.Content = content
oink.CreationTime = creationTime.Time()
oink.Handle = handle
}
if err := iter.Close(); err != nil {
return model.Oink{}, false, fmt.Errorf("Selecting oink (id: %s): %s", id, err)
}
return oink, false, nil
}
// Returns all oinks, from newest to oldest
func (r *CQLOinkRepo) All() ([]model.Oink, error) {
r.lock.RLock()
defer r.lock.RUnlock()
if !r.initialized {
return nil, errors.New("Uninitialized repo")
}
iter := r.session.Query(
"SELECT id, content, created_at, handle FROM oinker.oinks "+
"WHERE kind = ? ORDER BY created_at DESC",
"oink",
).Iter()
var (
id, content, handle string
creationTime gocql.UUID
)
oinks := make([]model.Oink, 0)
for iter.Scan(&id, &content, &creationTime, &handle) {
oink := model.Oink{
ID: id,
Content: content,
CreationTime: creationTime.Time(),
Handle: handle,
}
oinks = append(oinks, oink)
}
if err := iter.Close(); err != nil {
return nil, fmt.Errorf("Selecting oink (id: %s): %s", id, err)
}
return oinks, nil
}
func fuuidFunc(u gocql.UUID) string {
if u == zeroUuid {
return ""
} else {
return u.String()
}
}
func (r *CQLOinkRepo) FindByID(id string) (Oink, bool, error) {
session, err := r.cluster.CreateSession()
if err != nil {
return Oink{}, false, fmt.Errorf("Creating CQL Session: %s", err)
}
defer session.Close()
iter := session.Query("SELECT content, created_at, handle FROM oinks WHERE id = ?", id).Iter()
var (
content string
creationTime gocql.UUID
handle string
)
oink := Oink{
ID: id,
}
if iter.Scan(&content, &creationTime, &handle) {
oink.Content = content
oink.CreationTime = creationTime.Time()
oink.Handle = handle
}
if err := iter.Close(); err != nil {
return Oink{}, false, fmt.Errorf("Selecting oink (id: %s): %s", id, err)
}
return oink, false, nil
}
func (b *Fields) NCBuildingUpdate(uuid *gocql.UUID) string {
return fmt.Sprintf(`{"command":"nc_building_update","planet_uuid":"%s","building":{"uuid":"%s","type":"%s","level":%d,"turn_on":%v,"x":%v,"y":%v,"upgrade_in_progress":%v,"upgrade_duration":%v,"upgrade_elapsed":%v}}`,
uuid.String(),
b.UUID.String(),
b.Type,
b.Level,
b.TurnOn,
b.X,
b.Y,
b.UpgradeInProgress,
b.UpgradeDuration,
b.UpgradeElapsed)
}
func GetServer(serverUUID gocql.UUID) *Server {
// todo: add mutex
server, ok := servers[serverUUID.String()]
if !ok {
server = NewServer(serverUUID)
if server == nil {
return nil
}
servers[serverUUID.String()] = server
}
return server
}
func (querier *Querier) GetPost(postID string) (*Post, error) {
var id gocql.UUID
var comment, title, link, sub string
var upvotes int
var downvotes int
var commentCount int
var createdAt time.Time
var updatedAt time.Time
if err := querier.Session.Query(`SELECT id, title, link, sub_id, comment, upvotes, downvotes, comment_count, created_at, updated_at FROM posts WHERE id = ? LIMIT 1`,
postID).Consistency(gocql.One).Scan(&id, &title, &link, &sub, &comment, &upvotes, &downvotes, &commentCount, &createdAt, &updatedAt); err != nil {
log.Println(err)
return nil, err
}
return &Post{id.String(), title, link, comment, "", sub, upvotes, downvotes, commentCount, updatedAt, createdAt}, nil
}
func (querier Querier) GetSubs() ([]*Sub, error) {
var id gocql.UUID
var name string
var subscribers int
var createdAt time.Time
var updatedAt time.Time
var subs []*Sub
iter := querier.Session.Query(`SELECT id, name, subscribers, created_at, updated_at FROM subs`).Iter()
for iter.Scan(&id, &name, &subscribers, &createdAt, &updatedAt) {
subs = append(subs, &Sub{
id.String(),
name,
subscribers,
createdAt,
updatedAt,
})
}
return subs, nil
}
func (querier Querier) GetCommentsByPostID(postIDToQuery string) ([]*Comment, map[string]*Comment, map[string][]string, error) {
var id gocql.UUID
var idAsString string
var content string
var parentID string
var upvotes int
var downvotes int
var updatedAt time.Time
commentLookup := make(map[string]*Comment)
childrenLookup := make(map[string][]string)
var comments []*Comment
startTime := time.Now()
iter := querier.Session.Query(`SELECT id, parent_id, content, upvotes, downvotes, updated_at FROM comments WHERE post_id = ?`, postIDToQuery).Iter()
elapsed := time.Since(startTime)
log.Printf("Querying: elapsed %f milliseconds\n", elapsed.Seconds()*1000.0)
startTime = time.Now() // Timing building the tree
for iter.Scan(&id, &parentID, &content, &upvotes, &downvotes, &updatedAt) {
idAsString = id.String()
comment := &Comment{idAsString, parentID, content, upvotes, downvotes, time.Now(), updatedAt, nil}
comments = append(comments, comment)
commentLookup[idAsString] = comment
}
sort.Sort(UpvoteSorter(comments))
for _, node := range comments {
childrenLookup[node.ParentID] = append(childrenLookup[node.ParentID], node.ID)
}
elapsed = time.Since(startTime)
log.Printf("Building the tree: elapsed %f milliseconds\n", elapsed.Seconds()*1000.0)
if err := iter.Close(); err != nil {
return nil, nil, nil, err
}
return comments, commentLookup, childrenLookup, nil
}
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")
}
}
func Get(modelName string, UUID gocql.UUID) interface{} {
t, ok := Models[modelName]
if !ok {
return nil
}
o := (t.Get(UUID.String())).(*Model)
// o = o.(*Model)
if o == nil {
o = (t.New()).(*Model)
o.UUID = UUID
o.Load()
o.Lock()
if !o.Exists {
return nil
}
}
return o
}
func main() {
session := integration.TestSession("127.0.0.1", "cqlc")
integration.Truncate(session, SIGNIFICANT_EVENTS)
result := "FAILED"
ctx := cqlc.NewContext()
batch := gocql.NewBatch(gocql.LoggedBatch)
events := 100
var first, last gocql.UUID
for i := 0; i < events; i++ {
ts := gocql.TimeUUID()
ctx.Upsert(SIGNIFICANT_EVENTS).
SetInt64(SIGNIFICANT_EVENTS.SENSOR, 100).
SetTimeUUID(SIGNIFICANT_EVENTS.TIMESTAMP, ts).
SetInt32(SIGNIFICANT_EVENTS.SIGNIFICANCE, int32(i/10)).
SetFloat32(SIGNIFICANT_EVENTS.TEMPERATURE, 19.8).
SetInt32(SIGNIFICANT_EVENTS.PRESSURE, 357).
Batch(batch)
switch i {
case 0:
first = ts
case events - 1:
last = ts
}
}
if err := session.ExecuteBatch(batch); err != nil {
log.Fatalf("Could not execute batch: %v", err)
os.Exit(1)
}
count, err := checkOrdering(session, SIGNIFICANT_EVENTS.TIMESTAMP)
if err != nil {
log.Fatal(err)
os.Exit(1)
}
if count == events {
count, err = checkOrdering(session, SIGNIFICANT_EVENTS.TIMESTAMP.Desc())
if err != nil {
log.Fatal(err)
os.Exit(1)
}
if count == events {
firstRead, err := checkOrderedLimit(session, SIGNIFICANT_EVENTS.TIMESTAMP, SIGNIFICANT_EVENTS.SIGNIFICANCE)
if err != nil {
log.Fatal(err)
os.Exit(1)
}
lastRead, err := checkOrderedLimit(session, SIGNIFICANT_EVENTS.TIMESTAMP.Desc())
if err != nil {
log.Fatal(err)
os.Exit(1)
}
if first == firstRead {
if last == lastRead {
result = "PASSED"
} else {
result = fmt.Sprintf("Expected last %v; got %v", last.Time(), lastRead.Time())
}
} else {
result = fmt.Sprintf("Expected first %v; got %v", first.Time(), firstRead.Time())
}
}
} else {
result = fmt.Sprintf("Expected %d rows; got %d rows", events, count)
}
os.Stdout.WriteString(result)
}
func NewServer(serverUUID gocql.UUID) *Server {
s := &Server{isLocal: false}
e := model_server.Get(serverUUID)
if !e.Exists {
logger.String(fmt.Sprintf("server %s not found in storage", serverUUID.String()))
return nil
}
path := fmt.Sprintf("http://%s:%d/ws", e.IP, e.Port)
logger.String(fmt.Sprintf("connect to: %s", path))
u, err := url.Parse(path)
if err != nil {
logger.String(fmt.Sprintf("%v", err))
// return err
return nil
}
rawConn, err := net.Dial("tcp", u.Host)
if err != nil {
logger.String(fmt.Sprintf("%v", err))
// return err
return nil
}
wsHeaders := http.Header{
"Origin": {"http://local.host:80"},
// your milage may differ
"Sec-WebSocket-Extensions": {"permessage-deflate; client_max_window_bits, x-webkit-deflate-frame"},
"User-Agent": {"spacecrfat-agent"},
}
wsConn, _, err := websocket.NewClient(rawConn, u, wsHeaders, 4096, 4096)
if err != nil {
logger.String(fmt.Sprintf("%v", err))
// return fmt.Errorf("websocket.NewClient Error: %s\nResp:%+v", err, resp)
return nil
}
s.ws = wsConn
s.ws.SetWriteDeadline(time.Now().Add(10 * time.Second))
err = s.ws.WriteMessage(websocket.TextMessage, []byte(fmt.Sprintf(`{"command":"auth","server_uuid":"%s"}`, localServer.UUID.String())))
if err != nil {
logger.String(fmt.Sprintf("%v", err))
return nil
}
_, message, err := s.ws.ReadMessage()
// s.ws.ReadMessage()
if err != nil {
if err != io.EOF {
logger.Error(errors.New(err))
}
}
smessage := string(message)
logger.String(fmt.Sprintf("star auth answer: %v", smessage))
go s.Reading()
go s.Pinger()
return s
}
