Golang UUID.String方法代码示例

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 fuuidFunc(u gocql.UUID) string {
	if u == zeroUuid {
		return ""
	} else {
		return u.String()
	}
}

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