예제 #1
0
파일: user.go 프로젝트: uhhhclem/werks
// Register creates a new user, with the given nickname and password.  It returns
// the user created, or an error if the nickname already exists.  The nickname
// is canonicalized, and the password is salted and hashed.
func (s *Users) Register(nickname string, password string) (*User, error) {

	if s.passwordSalt == "" {
		return nil, errors.New("No password salt found.")
	}

	id, err := uuid.GenUUID()
	if err != nil {
		return nil, err
	}

	u := &User{
		Id:       id,
		Nickname: nickname,
		Pwhash:   s.hashPassword(canonicalizePassword(password))}

	u.Token, err = uuid.GenUUID()
	if err != nil {
		return nil, err
	}

	key := canonicalizeNickname(u.Nickname)
	if s.usersByNickname[key] != nil {
		return nil, errors.New("Duplicate nickname.")
	}

	s.users = append(s.users, u)
	s.usersByNickname[key] = u
	s.usersById[u.Id] = u
	s.usersByToken[u.Token] = u

	return u, nil
}
예제 #2
0
파일: game.go 프로젝트: uhhhclem/werks
// initPlayers sets up the Players array with initial values.
func (g *Game) initPlayers(names []string) {
	g.addMessage("Initializing players...")

	g.Players = make([]*Player, len(names))

	for i, name := range names {
		id, err := uuid.GenUUID()
		if err != nil {
			panic(err)
		}
		p := &Player{
			ID:           id,
			Name:         name,
			Factories:    make([]Factory, 1),
			Money:        12,
			ChatMessages: Queue{Capacity: 500},
			TurnOrder:    i}

		p.Factories[0] = Factory{Key: "p1", Capacity: 1}

		g.Players[i] = p
	}

	p := g.Players[0]
	p.IsCurrent = true
}
예제 #3
0
파일: golem.go 프로젝트: colinmarc/golem
func Instance() {
  g = Golem.new()
  g.cluster_time = Time.now()
  g.me = uuid.GenUUID()

  g.wake_up = make(chan int)
  g.known_nodes = make(map[string]*Node)
  g.request_queue = RequestQueue.new()

  g.zcontext, _ = zmq.NewContext()
}
예제 #4
0
파일: game.go 프로젝트: uhhhclem/werks
// makeNewGame creates a new game with the provided player names.
func makeNewGame(name string, playerNames []string) *Game {
	var g = new(Game)
	id, err := uuid.GenUUID()
	if err != nil {
		panic(err)
	}
	g.ID = id
	g.Name = name
	g.Messages.Capacity = 500
	g.Phase = Development
	Games[g.ID] = g
	g.addMessage(fmt.Sprintf("Created game %s...", g.Name))
	g.loadLocos()
	g.prepareLocos()
	g.initPlayers(playerNames)
	g.determineTurnOrder()

	return g
}
예제 #5
0
파일: user.go 프로젝트: uhhhclem/werks
// Login validates a user login and returns the User.  If a user is
// logged in, he gets assigned a Token.
func (s *Users) Login(nickname, password string) (*User, error) {
	u := s.LookupByNickname(nickname)
	if u == nil {
		return nil, InvalidNicknameError
	}
	if u.Pwhash != s.hashPassword(canonicalizePassword(password)) {
		return nil, InvalidPasswordError
	}

	// login succeeded, so assign token if it hasn't already been assigned.
	if u.Token == "" {
		var err error
		u.Token, err = uuid.GenUUID()
		if err != nil {
			return nil, err
		}
		s.usersByToken[u.Token] = u
	}
	return u, nil
}
예제 #6
0
func handleHello(client *Client, f map[string]interface{}) {

	status := 200

	if f["uaid"] == nil {
		uaid, err := uuid.GenUUID()
		if err != nil {
			status = 400
			log.Println("GenUUID error %s", err)
		}
		client.UAID = uaid
	} else {
		client.UAID = f["uaid"].(string)

		resetClient := false

		if f["channelIDs"] != nil {
			for _, foo := range f["channelIDs"].([]interface{}) {
				channelID := foo.(string)

				if gServerState.UAIDToChannelIDs[client.UAID] == nil {
					gServerState.UAIDToChannelIDs[client.UAID] = make(ChannelIDSet)
					// since we don't have any channelIDs, don't bother looping any more
					resetClient = true
					break
				}

				if _, ok := gServerState.UAIDToChannelIDs[client.UAID][channelID]; !ok {
					resetClient = true
					break
				}
			}
		}

		if resetClient {
			// delete the older connection
			delete(gServerState.ConnectedClients, client.UAID)
			delete(gServerState.UAIDToChannelIDs, client.UAID)
			// TODO(nsm) clear up ChannelIDToChannels which now has extra
			// channelIDs not associated with any client

			uaid, err := uuid.GenUUID()
			if err != nil {
				status = 400
				log.Println("GenUUID error %s", err)
			}
			client.UAID = uaid
		}
	}

	gServerState.ConnectedClients[client.UAID] = client

	if f["wakeup_hostport"] != nil {
		m := f["wakeup_hostport"].(map[string]interface{})
		client.Ip = m["ip"].(string)
		client.Port = m["port"].(float64)
		log.Println("Got hostport pair ", client.Ip, client.Port)
	} else {
		log.Println("No hostport ", f)
	}

	type HelloResponse struct {
		Name   string `json:"messageType"`
		Status int    `json:"status"`
		UAID   string `json:"uaid"`
	}

	hello := HelloResponse{"hello", status, client.UAID}

	j, err := json.Marshal(hello)
	if err != nil {
		log.Println("Could not convert hello response to json %s", err)
		return
	}

	if err = websocket.Message.Send(client.Websocket, string(j)); err != nil {
		log.Println("Could not send message to ", client.Websocket, err.Error())
	}
}
예제 #7
0
func handleHello(client *Client, f map[string]interface{}) {

	status := 200
	var candidateUAID string
	var err error

	if _, ok := f["uaid"]; !ok {
		f["uaid"] = ""
	}
	candidateUAID = f["uaid"].(string)
	if filter.Find([]byte(candidateUAID)) != nil {
		handleError(client, f, 503, "Service Unavailable")
		verbose("Only use characters from \"A-Za-z0-9._-\" for UAIDs")
		return
	}
	if len(candidateUAID) > 0 && len(client.UAID) > 0 &&
		(candidateUAID != client.UAID) {
		handleError(client, f, 503, "Service Unavaliable")
		verbose("If you've already sent a \"hello\", the UAID must either be",
			"blank, or the same value passed previously.")
		return
	}

	if f["channelIDs"] == nil {
		handleError(client, f, 401, "Invalid Command")
		verbose("ChannelIDs must be specified, even if there is no content.",
			"e.g. channelIDs:[]")
		return
	}

	if len(candidateUAID) == 0 && len(client.UAID) > 0 {
		candidateUAID = client.UAID
	}

	log.Printf("=== uaid: ", f["uaid"])

	if candidateUAID == "" {
		verbose("No \"uaid\" found. Creating one...")
		candidateUAID, err = uuid.GenUUID()
		if err != nil {
			status = 400
			handleError(client, f, 500, "UUID Generation error")
			log.Println("GenUUID error %s", err)
		}
	} else {
		if filter.Find([]byte(candidateUAID)) != nil {
			handleError(client, f, 401, "Invalid Command")
			verbose("Only use characters from \"A-Za-z0-9._-\" for UAIDs")
			return
		}

		if len(candidateUAID) > 100 {
			handleError(client, f, 401, "Invalid Command")
			verbose(
				"UAIDs should be less than 100 characters long.",
				"Try using a UUID4 value.")
			return
		}
	}
	prevUAID := client.UAID
	client.UAID = candidateUAID

	resetClient := false
	for _, chid := range f["channelIDs"].([]interface{}) {
		channelID := chid.(string)
		if filter.Find([]byte(channelID)) != nil {
			verbose(fmt.Sprintf("Skipping invalid channel %s", chid))
			continue
		}

		if gServerState.UAIDToChannelIDs[client.UAID] == nil {
			//gServerState.UAIDToChannelIDs[client.UAID] = make(ChannelIDSet)
			// since we don't have any channelIDs, don't bother looping
			//any more
			verbose("No channels found for UAID, resetting...")
			resetClient = true
			break
		}

		if _, ok := gServerState.UAIDToChannelIDs[client.UAID][channelID]; !ok {
			verbose("Channel not found for UAID, resetting...")
			resetClient = true
			break
		}
	}

	if resetClient {
		// delete the older connection
		for _, channel := range gServerState.UAIDToChannelIDs[prevUAID] {
			delete(gServerState.UAIDToChannelIDs[prevUAID], channel.ChannelID)
			delete(gServerState.ChannelIDToChannel, channel.ChannelID)
		}
		delete(gServerState.ConnectedClients, client.UAID)
		delete(gServerState.UAIDToChannelIDs, client.UAID)
		// TODO(nsm) clear up ChannelIDToChannels which now has extra
		// channelIDs not associated with any client

		uaid, err := uuid.GenUUID()
		if err != nil {
			status = 400
			log.Println("GenUUID error %s", err)
		}
		client.UAID = uaid
	}

	gServerState.ConnectedClients[client.UAID] = client

	if f["wakeup_hostport"] != nil {
		m := f["wakeup_hostport"].(map[string]interface{})
		client.Ip = m["ip"].(string)
		client.Port = m["port"].(float64)
		log.Println("Got hostport pair ", client.Ip, client.Port)
	} else {
		log.Println("No hostport ", f)
	}

	type HelloResponse struct {
		Name   string `json:"messageType"`
		Status int    `json:"status"`
		UAID   string `json:"uaid"`
	}

	hello := HelloResponse{"hello", status, client.UAID}

	j, err := json.Marshal(hello)
	if err != nil {
		log.Println("Could not convert hello response to json %s", err)
		return
	}

	if err = websocket.Message.Send(client.Websocket, string(j)); err != nil {
		log.Println("Could not send message to ", client.Websocket, err.Error())
	}
}