Golang gocql.UUID类代码示例

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
}

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

}

// 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
}