func (repo *CassandraChatRepo) GetUserPerfectMatch(rpf types.PerfectNumber) (types.PerfectNumber, error) { // get match for user by id var perfectNumber types.PerfectNumber var user_id string var err error err = nil sql := fmt.Sprintf(`SELECT user_id, perfect_number FROM perfect_numbers WHERE perfect_number < %v LIMIT 1 ALLOW FILTERING`, rpf.PerfectNumber) log.Printf(sql) if err = session.Query(sql).Scan(&user_id, &perfectNumber.PerfectNumber); err != nil { log.Printf(fmt.Sprintf("CassandraChatRepo.GetUserPerfectMatch() - Error: %v", err.Error())) sql := fmt.Sprintf("SELECT user_id, perfect_number FROM perfect_numbers LIMIT 1") log.Printf(sql) if err = session.Query(sql).Scan(&user_id, &perfectNumber.PerfectNumber); err != nil { log.Printf(fmt.Sprintf("CassandraChatRepo.GetUserPerfectMatch() - Error: %v", err.Error())) } else { if user_id != rpf.UserId.String() { perfectNumber.UserId = uuid.Parse(user_id) } else { err = errors.New("not found") } } } else { perfectNumber.UserId = uuid.Parse(user_id) } return perfectNumber, err }
func CreateMessage(userId string, receiverId string, mr types.MessageRequest) error { var err error err = nil if err = utilsservice.CheckIfMatchExists(userId, receiverId); err == nil { var m types.Message m.SenderId = uuid.Parse(userId) m.ReceiverId = uuid.Parse(receiverId) m.MessageId = uuid.NewRandom() m.IsRead = false m.Text = strings.Replace(mr.Text, "'", "''", -1) if mr.Timestamp != 0 { m.Timestamp = int64(time.Unix(mr.Timestamp, 0).UTC().Unix()) } else { m.Timestamp = int64(time.Now().UTC().Unix()) } if err = messageRepo.CreateMessage(m); err == nil { err = chatservice.UpdateLastMessageChat(userId, receiverId, m.Text) if lastActivity, errA := activityservice.GetUserActivity(receiverId); errA == nil { senderUsername, _ := utilsservice.GetUserUsername(userId) pushMessage := fmt.Sprintf("%s: %s", senderUsername, m.Text) notificationsservice.SendPushNotification(lastActivity.DeviceType, lastActivity.PushToken, pushMessage) } } } return err }
func (repo *CassandraMatchRepo) GetUserMatch(userId string) (types.Match, error) { // get match for user by id log.Printf(fmt.Sprintf("CassandraMatchRepo.GetUserMatch() - Received userId: %v", userId)) var match types.Match var user_id string var matched_user_id string var err error err = nil sql := fmt.Sprintf(`SELECT user_id, matched_user_id, matched_username, timestamp FROM matches WHERE user_id = %v LIMIT 1`, userId) log.Printf(sql) if err = session.Query(sql).Scan(&user_id, &matched_user_id, &match.MatchedUsername, &match.Timestamp); err != nil { log.Printf(fmt.Sprintf("CassandraMatchRepo.GetUserMatch() - Error: %v", err.Error())) } else { match.UserId = uuid.Parse(user_id) match.MatchedUserId = uuid.Parse(matched_user_id) } return match, err }
func (repo *CassandraMessageRepo) GetUserLastMessageByReceiverId(userId string, receiverId string) (types.Message, error) { // get last message for user log.Printf(fmt.Sprintf("CassandraMessageRepo.GetUserLastMessageByReceiverId() - Received userId: %v", userId)) log.Printf(fmt.Sprintf("CassandraMessageRepo.GetUserLastMessageByReceiverId() - Received receiverId: %v", receiverId)) var messages types.Messages var err error err = nil var message_id, sender_id, receiver_id string var text string var is_read bool var timestamp int64 var sql string //sender messages sql = fmt.Sprintf(`SELECT message_id, sender_id, receiver_id, text, is_read, timestamp FROM messages WHERE sender_id = %v AND receiver_id = %v LIMIT 1`, userId, receiverId) log.Printf(sql) iter := session.Query(sql).Iter() for iter.Scan(&message_id, &sender_id, &receiver_id, &text, &is_read, ×tamp) { messages = append(messages, types.Message{MessageId: uuid.Parse(message_id), SenderId: uuid.Parse(sender_id), ReceiverId: uuid.Parse(receiver_id), Text: text, IsRead: is_read, Timestamp: timestamp}) } if err = iter.Close(); err != nil { log.Printf(fmt.Sprintf("CassandraMessageRepo.GetUserLastMessageByReceiverId() - Error: %v", err.Error())) } //receiver messages sql = fmt.Sprintf(`SELECT message_id, sender_id, receiver_id, text, is_read, timestamp FROM messages WHERE sender_id = %v AND receiver_id = %v`, receiverId, userId) log.Printf(sql) iter2 := session.Query(sql).Iter() for iter2.Scan(&message_id, &sender_id, &receiver_id, &text, &is_read, ×tamp) { messages = append(messages, types.Message{MessageId: uuid.Parse(message_id), SenderId: uuid.Parse(sender_id), ReceiverId: uuid.Parse(receiver_id), Text: text, IsRead: is_read, Timestamp: timestamp}) } if err = iter2.Close(); err != nil { log.Printf(fmt.Sprintf("CassandraMessageRepo.GetUserLastMessageByReceiverId() - Error: %v", err.Error())) } if messages != nil { sort.Sort(ByTimestamp(messages)) } var message types.Message if len(messages) > 0 { message = messages[0] } return message, err }
func TestUniqueKeyCreation(t *testing.T) { uniqueKey := NewUniqueKey("") if uuid.Parse(uniqueKey.String()) == nil { t.Error("Invalid uuid generated") } uniqueKey.Next() if uuid.Parse(uniqueKey.String()) == nil { t.Error("Invalid uuid generated") } }
func CreateMatch(mr types.MatchRequest) error { var err error err = nil if err = utilsservice.CheckIfUserExists(mr.FirstUserId); err == nil { if err = utilsservice.CheckIfUserExists(mr.SecondUserId); err == nil { var firstUsername string var secondUsername string if firstUsername, err = utilsservice.GetUserUsername(mr.FirstUserId); err == nil { if secondUsername, err = utilsservice.GetUserUsername(mr.SecondUserId); err == nil { var m types.Match m.UserId = uuid.Parse(mr.FirstUserId) m.MatchedUserId = uuid.Parse(mr.SecondUserId) m.MatchedUsername = secondUsername m.Timestamp = int64(time.Now().UTC().Unix()) //create first match if err = chatRepo.CreateMatch(m); err == nil { m.UserId = uuid.Parse(mr.SecondUserId) m.MatchedUserId = uuid.Parse(mr.FirstUserId) m.MatchedUsername = firstUsername m.Timestamp = int64(time.Now().UTC().Unix()) //create second match if err = chatRepo.CreateMatch(m); err == nil { var cr types.ChatRequest //create chat cr.FirstUserId = mr.FirstUserId cr.SecondUserId = mr.SecondUserId err = CreateChat(cr) //send push message to first user if lastActivity, errA := activityservice.GetUserActivity(mr.FirstUserId); errA == nil { notificationsservice.SendPushNotification(lastActivity.DeviceType, lastActivity.PushToken, "you've been matched!") } //send push message to second user if lastActivity, errA := activityservice.GetUserActivity(mr.SecondUserId); errA == nil { notificationsservice.SendPushNotification(lastActivity.DeviceType, lastActivity.PushToken, "you've been matched!") } } } } } } } return err }
// LookUpServers attempts to return identifiers matching a pattern func (c *ScalewayCache) LookUpServers(needle string, acceptUUID bool) []string { c.Lock.Lock() defer c.Lock.Unlock() var res []string var exactMatches []string if acceptUUID && uuid.Parse(needle) != nil { res = append(res, needle) } nameRegex := regexp.MustCompile(`(?i)` + regexp.MustCompile(`[_-]`).ReplaceAllString(needle, ".*")) for identifier, name := range c.Servers { if name == needle { exactMatches = append(exactMatches, identifier) } if strings.HasPrefix(identifier, needle) || nameRegex.MatchString(name) { res = append(res, identifier) } } if len(exactMatches) == 1 { return exactMatches } return utils.RemoveDuplicates(res) }
func request_get_NEAREST(q *btrdb.Quasar, w http.ResponseWriter, r *http.Request) { atomic.AddInt32(&outstandingHttpReqs, 1) defer func() { atomic.AddInt32(&outstandingHttpReqs, -1) }() r.ParseForm() ids := r.Form.Get(":uuid") id := uuid.Parse(ids) if id == nil { doError(w, "malformed uuid") return } t, ok, msg := parseInt(r.Form.Get("time"), -(16 << 56), (48 << 56)) if !ok { doError(w, "bad time: "+msg) return } bws := r.Form.Get("backwards") bw := bws != "" rec, _, err := q.QueryNearestValue(id, t, bw, btrdb.LatestGeneration) if err != nil { doError(w, "Bad query: "+err.Error()) return } w.Write([]byte(fmt.Sprintf("[%d, %f]", rec.Time, rec.Val))) }
func parseRow(row connection.Row) (Record, error) { r := Record{} var rUUID, dUUID string var rtID int32 var pID int32 var jsonBuf []byte err := row.Scan(&rUUID, &dUUID, &r.Name, &jsonBuf, &rtID, &r.Date, &pID, &r.Added) if err != nil { return r, err } err = json.Unmarshal(jsonBuf, &r.Args) if err != nil { return r, err } r.UUID = uuid.Parse(rUUID) r.Domain, err = domains.GetByUUID(dUUID).One() if err != nil { return r, err } r.Type, err = types.GetByID(rtID).One() if err != nil { return r, err } // ignore error as we dont need a Parser p, _ := parser.Get(parser.GetByID(), pID) r.Parser = p return r, nil }
func getTestMessageWithFunnyFields() *message.Message { field, _ := message.NewField(`"foo`, "bar\n", "") field1, _ := message.NewField(`"number`, 64, "") field2, _ := message.NewField("\xa3", "\xa3", "") field3, _ := message.NewField("idField", "1234", "") msg := &message.Message{} msg.SetType("TEST") loc, _ := time.LoadLocation("UTC") t, _ := time.ParseInLocation("2006-01-02T15:04:05.000Z", "2013-07-16T15:49:05.070Z", loc) msg.SetTimestamp(t.UnixNano()) msg.SetUuid(uuid.Parse("87cf1ac2-e810-4ddf-a02d-a5ce44d13a85")) msg.SetLogger("GoSpec") msg.SetSeverity(int32(6)) msg.SetPayload("Test Payload") msg.SetEnvVersion("0.8") msg.SetPid(14098) msg.SetHostname("hostname") msg.AddField(field) msg.AddField(field1) msg.AddField(field2) msg.AddField(field3) return msg }
func (m *OpsConfigManager) handleNeighborUpdate(update ovsdb.TableUpdate) []*server.GrpcRequest { _, id, _ := m.getBGPRouterUUID() addrs, ids, err := m.getBGPNeighborUUIDs(id) if err != nil { return nil } reqs := make([]*server.GrpcRequest, 0, len(addrs)) for k, v := range update.Rows { for idx, id := range ids { if uuid.Equal(id, uuid.Parse(k)) { asn, ok := v.New.Fields["remote_as"].(float64) if !ok { log.Debugf("remote-as is not configured yet") continue } reqs = append(reqs, server.NewGrpcRequest(server.REQ_MOD_NEIGHBOR, "", bgp.RouteFamily(0), &api.ModNeighborArguments{ Operation: api.Operation_ADD, Peer: &api.Peer{ Conf: &api.PeerConf{ NeighborAddress: addrs[idx].String(), PeerAs: uint32(asn), }, }, })) } } } return reqs }
func (m *OpsConfigManager) getBGPNeighborUUIDs(id uuid.UUID) ([]net.IP, []uuid.UUID, error) { global, ok := m.cache["BGP_Router"] if !ok { return nil, nil, fmt.Errorf("BGP_Router table not found") } for k, v := range global { if uuid.Equal(id, uuid.Parse(k)) { neighbors := v.Fields["bgp_neighbors"].(ovsdb.OvsMap).GoMap if len(neighbors) < 1 { return nil, nil, fmt.Errorf("no bgp neighbor configured") } addrs := make([]net.IP, 0, len(neighbors)) ids := make([]uuid.UUID, 0, len(neighbors)) for k, v := range neighbors { addrs = append(addrs, net.ParseIP(k.(string))) id := extractUUID(v) if id == nil { return nil, nil, fmt.Errorf("invalid uuid schema") } ids = append(ids, id) } return addrs, ids, nil } } return nil, nil, fmt.Errorf("not found") }
func CreateAccelerations(userId string, accelerations types.AccelerationsRequest) error { var err error err = nil if err = utilsservice.CheckIfUserExists(userId); err == nil { for _, ar := range accelerations { var a types.Acceleration a.UserId = uuid.Parse(userId) a.X = ar.X a.Y = ar.Y a.Z = ar.Z if ar.Timestamp != 0 { a.Timestamp = int64(time.Unix(ar.Timestamp, 0).UTC().Unix()) } else { a.Timestamp = int64(time.Now().UTC().Unix()) } err = accelerationRepo.CreateAcceleration(a) if err != nil { break } } //increment walking progress for test users if err == nil { if user, errU := userservice.GetUser(userId); errU == nil { if userExtraInfo, errU := userservice.GetUserExtraInfo(userId); errU == nil { if userExtraInfo.WalkingProgress < 100 { if user.IsTest { var userExtraInfoRequest types.UserExtraInfoRequest if userExtraInfo.WalkingProgress >= 95 { userExtraInfoRequest.WalkingProgress = 100 } else { userExtraInfoRequest.WalkingProgress = userExtraInfo.WalkingProgress + 3 } if errU := userservice.UpdateUserExtraInfo(userId, userExtraInfoRequest); errU != nil { log.Printf(fmt.Sprintf("AccelerationService.CreateAccelerations() - Error: %v", errU.Error())) } } else { if accelerations != nil && len(accelerations) > 1 { kafkaMessage := fmt.Sprintf("%v,%v,%v", userId, accelerations[0].Timestamp, accelerations[len(accelerations)-1].Timestamp) kafkaservice.ProduceMessage(kafkaMessage) } } } } else { log.Printf(fmt.Sprintf("AccelerationService.CreateAccelerations() - Error: %v", errU.Error())) } } else { log.Printf(fmt.Sprintf("AccelerationService.CreateAccelerations() - Error: %v", errU.Error())) } } } return err }
func initdb() { if *showquery { // don't need a database for printing queries return } else if *dbname == "" { log.Fatal("must specify database with -db flag") } var err error db, err = sql.Open("sqlite3", *dbname) fatalif(err) if *simidstr == "" { ids, err := query.SimIds(db) fatalif(err) simid = ids[0] } else { simid = uuid.Parse(*simidstr) if simid == nil { log.Fatalf("invalid simid '%s'", *simidstr) } } post.Process(db) }
func (repo *CassandraUserRepo) GetUser(userId string) (types.User, error) { // get user by id var user types.User var user_id string var err error err = nil sql := fmt.Sprintf(`SELECT user_id, username, facebook_access_token, twitter_access_token, google_access_token, push_token, device_type, email, password, is_test, is_anonymous, gender_preference, timestamp FROM users WHERE user_id = %v LIMIT 1`, userId) log.Printf(sql) if err = session.Query(sql).Scan(&user_id, &user.Username, &user.FacebookAccessToken, &user.TwitterAccessToken, &user.GoogleAccessToken, &user.PushToken, &user.DeviceType, &user.Email, &user.Password, &user.IsTest, &user.IsAnonymous, &user.GenderPreference, &user.Timestamp); err != nil { log.Printf(fmt.Sprintf("CassandraUserRepo.GetUser() - Error: %v", err.Error())) } else { user.UserId = uuid.Parse(user_id) } return user, err }
func decryptKeyV1(keyProtected *encryptedKeyJSONV1, auth string) (keyBytes []byte, keyId []byte, err error) { keyId = uuid.Parse(keyProtected.Id) mac, err := hex.DecodeString(keyProtected.Crypto.MAC) if err != nil { return nil, nil, err } iv, err := hex.DecodeString(keyProtected.Crypto.CipherParams.IV) if err != nil { return nil, nil, err } cipherText, err := hex.DecodeString(keyProtected.Crypto.CipherText) if err != nil { return nil, nil, err } derivedKey, err := getKDFKey(keyProtected.Crypto, auth) if err != nil { return nil, nil, err } calculatedMAC := Sha3(derivedKey[16:32], cipherText) if !bytes.Equal(calculatedMAC, mac) { return nil, nil, errors.New("Decryption failed: MAC mismatch") } plainText, err := aesCBCDecrypt(Sha3(derivedKey[:16])[:16], cipherText, iv) if err != nil { return nil, nil, err } return plainText, keyId, err }
func (repo *CassandraAccelerationRepo) GetAccelerations(userId string) (types.Accelerations, error) { // get accelerations var accelerations types.Accelerations var err error err = nil var user_id string var x, y, z float64 var timestamp int64 sql := fmt.Sprintf("SELECT user_id, x, y, z, timestamp FROM accelerations WHERE user_id = %v", userId) log.Printf(sql) iter := session.Query(sql).Iter() for iter.Scan(&user_id, &x, &y, &z, ×tamp) { accelerations = append(accelerations, types.Acceleration{UserId: uuid.Parse(user_id), X: x, Y: y, Z: z, Timestamp: timestamp}) } if err = iter.Close(); err != nil { log.Printf(fmt.Sprintf("CassandraAccelerationRepo.GetAccelerations() - Error: %v", err.Error())) } return accelerations, err }
func (k *Key) UnmarshalJSON(j []byte) (err error) { keyJSON := new(plainKeyJSON) err = json.Unmarshal(j, &keyJSON) if err != nil { return err } u := new(uuid.UUID) *u = uuid.Parse(keyJSON.Id) k.Id = *u addr, err := hex.DecodeString(keyJSON.Address) if err != nil { return err } privkey, err := hex.DecodeString(keyJSON.PrivateKey) if err != nil { return err } k.Address = common.BytesToAddress(addr) k.PrivateKey = ToECDSA(privkey) return nil }
func receiveGreeting(conn net.Conn) string { peerUUID := make([]byte, 36) read, err := conn.Read(peerUUID) if read != 36 { // FIXME does this mean the buffer hasn't filled or what? // treat this as invalid right now [and investigate] return "" } if err != nil { return "" } parsed := uuid.Parse(string(peerUUID)) if parsed == nil { // invalid uuid; die return "" } debug("received greeting from ", conn.RemoteAddr(), ": ", parsed.String()) // this is valid, return it return parsed.String() }
// LastEventHTTP handles HTTP requests for looking up a job's last event. The // job is looked up by its invocation ID. JSON is written to the response body // in the following format: // // { // "state" : { // "uuid" : "", // "status" : "", // "completion_date" : "" // } // } // // 'uuid' will be in the normal UUID format of 32 hex digits in 5 groups // delimited by '-'. For example: 'bf6ff4a0-7bcf-11e4-b116-123b93f75cba'. // // 'status' will be a one of 'Submitted', 'Running', 'Completed', or 'Failed'. // // 'completion_date' will be a timestamp that looks like // '2006-01-02T15:04:05Z07:00'. func (h *HTTPAPI) LastEventHTTP(writer http.ResponseWriter, request *http.Request) { logger.Printf("Handling GET request for %s", request.URL.Path) baseName := path.Base(request.URL.Path) if baseName == "" { WriteRequestError(writer, "The path must contain an invocation UUID") return } logger.Printf("Requested job UUID: %s", baseName) if uuid.Parse(baseName) == nil { WriteRequestError(writer, fmt.Sprintf("The base of the path must be a UUID: %s", baseName)) return } jr, err := h.d.GetJobByInvocationID(baseName) if err != nil { WriteRequestError(writer, err.Error()) return } if jr == nil { writer.WriteHeader(http.StatusNotFound) writer.Write([]byte(fmt.Sprintf("Job %s was not found", baseName))) return } lastCondorJobEvent, err := h.d.GetLastCondorJobEvent(jr.ID) if err != nil { writer.WriteHeader(http.StatusNotFound) writer.Write([]byte(fmt.Sprintf("Last event for job %s using invocation %s was not found", jr.ID, baseName))) return } lastJobEvent, err := h.d.GetCondorJobEvent(lastCondorJobEvent.CondorJobEventID) if err != nil { writer.WriteHeader(http.StatusNotFound) writer.Write([]byte(fmt.Sprintf("JobEvent %s was not found for last event lookup", lastCondorJobEvent.CondorJobEventID))) return } condorEvent, err := h.d.GetCondorEvent(lastJobEvent.CondorEventID) if err != nil { writer.WriteHeader(http.StatusNotFound) writer.Write([]byte(fmt.Sprintf("CondorEvent %s was not found for last event lookup", lastJobEvent.CondorEventID))) return } appEvent := &Event{ EventNumber: condorEvent.EventNumber, CondorID: jr.CondorID, AppID: jr.AppID, InvocationID: jr.InvocationID, User: jr.Submitter, EventName: condorEvent.EventName, ExitCode: jr.ExitCode, } jobState := NewJobState(appEvent) marshalled, err := json.Marshal(jobState) if err != nil { writer.WriteHeader(http.StatusInternalServerError) writer.Write([]byte(err.Error())) return } logger.Printf("Response for last event lookup by invocation %s:\n%s", baseName, string(marshalled[:])) writer.Write(marshalled) }
// JobHTTPGet is responsible for retrieving a Job from the database and returning // its record as a JSON object. The UUID for the job is extracted from the basename // of the URL path and must be a valid UUID. func (h *HTTPAPI) JobHTTPGet(writer http.ResponseWriter, request *http.Request) { logger.Printf("Handling GET request for %s", request.URL.Path) baseName := path.Base(request.URL.Path) if baseName == "" { WriteRequestError(writer, "The path must contain a job UUID") return } logger.Printf("Requested job UUID: %s", baseName) if uuid.Parse(baseName) == nil { WriteRequestError(writer, fmt.Sprintf("The base of the path must be a UUID: %s", baseName)) return } jr, err := h.d.GetJob(baseName) if err != nil { WriteRequestError(writer, err.Error()) return } if jr == nil { writer.WriteHeader(http.StatusNotFound) writer.Write([]byte(fmt.Sprintf("Job %s was not found", baseName))) return } marshalled, err := json.Marshal(jr) if err != nil { writer.WriteHeader(http.StatusInternalServerError) writer.Write([]byte(err.Error())) return } logger.Printf("Response for job lookup by UUID %s:\n%s", baseName, string(marshalled[:])) writer.Write(marshalled) }
func getOrPreparePod(args []string) (*jetpack.Pod, error) { switch len(args) { case 0: return nil, ErrUsage case 1: if id := uuid.Parse(args[0]); id != nil { // Pod UUID return Host.GetPod(id) } fallthrough default: if pm, err := getPodManifest(args); err != nil { return nil, err } else if pod, err := Host.CreatePod(pm); err != nil { return nil, err } else { if SaveID != "" { if err := ioutil.WriteFile(SaveID, []byte(pod.UUID.String()), 0644); err != nil { return nil, err } } return pod, nil } } }
func (m *ApiClient) FQNameByUuid(id string) ([]string, error) { obj, err := m.db.GetByUuid(uuid.Parse(id)) if err != nil { return []string{}, err } return obj.GetFQName(), nil }
// ResetUserPassword is a route which is called when accessing the page generated dispatched with // account recovery emails. func ResetUserPassword(w http.ResponseWriter, r *http.Request) { var user User r.ParseForm() user.Password = r.PostFormValue("password") vars := mux.Vars(r) id, err := strconv.Atoi(vars["id"]) if err != nil { log.Println("resetuserpassword id: ", err) rend.JSON(w, http.StatusBadRequest, map[string]interface{}{"error": "User ID could not be parsed from request URL."}) return } user.ID = int64(id) // FIXME entry? entry, err := user.Get() if err != nil { log.Println("resetuserpassword get: ", err) if err.Error() == "not found" { rend.JSON(w, http.StatusBadRequest, map[string]interface{}{"error": "User with that ID does not exist."}) return } rend.JSON(w, http.StatusInternalServerError, map[string]interface{}{"error": "Internal server error"}) return } // this ensures that accounts won't be compromised by posting recovery string as empty, // which would otherwise result in succesful password reset UUID := uuid.Parse(vars["recovery"]) if UUID == nil { log.Println("there was a problem trying to verify password reset UUID for", entry.Email) rend.JSON(w, http.StatusBadRequest, map[string]interface{}{"error": "Could not parse UUID from the request."}) return } if entry.Recovery == vars["recovery"] { entry.Password = user.Password digest, err := GenerateHash(entry.Password) if err != nil { log.Println("resertuserpassword genhash: ", err) rend.JSON(w, http.StatusInternalServerError, map[string]interface{}{"error": "Internal server error"}) return } entry.Digest = digest entry.Recovery = " " _, err = user.Update(r) if err != nil { log.Println("resetuserpassword update: ", err) rend.JSON(w, http.StatusInternalServerError, map[string]interface{}{"error": "Internal server error"}) return } switch root(r) { case "api": rend.JSON(w, http.StatusOK, map[string]interface{}{"success": "Password was updated successfully."}) return case "user": http.Redirect(w, r, "/user/login", http.StatusFound) return } } }
func (this *Session) SetAuthenticated(result bool) { if !result { this.Disconnect("Error: Authentication to Minecraft.net Failed") return } this.uuid = uuid.Parse(FormatUUID(this.profile.Id)) if this.server.SessionRegistry.HasName(this.name) { this.Disconnect(minecraft.Colorize(this.server.localizer.LocaleLoggedIn())) return } if this.server.SessionRegistry.HasUuid(this.uuid) { this.Disconnect(minecraft.Colorize(this.server.localizer.LocaleLoggedIn())) return } if this.server.MaxPlayers() > 1 && this.server.SessionRegistry.Len() >= int(this.server.MaxPlayers()) { this.Disconnect(minecraft.Colorize(this.server.localizer.LocaleFull())) return } servers := this.server.router.Route(this.serverAddress) activeServers := []string{} for _, serverName := range servers { if !this.server.connect.HasServer(serverName) { continue } activeServers = append(activeServers, serverName) } if len(activeServers) == 0 { this.Disconnect(minecraft.Colorize(this.server.localizer.LocaleOffline())) return } serverName := activeServers[RandomInt(len(activeServers))] server := this.server.connect.Server(serverName) if server == nil { this.Disconnect("Error: Outbound Server Mismatch: " + serverName) return } addResult := this.server.connect.AddLocalPlayer(this.name, this.uuid) if addResult == 0 { this.Disconnect(minecraft.Colorize(this.server.localizer.LocaleLoggedIn())) return } else if addResult == -1 { this.Disconnect(minecraft.Colorize(this.server.localizer.LocaleLoggedIn())) return } this.state = STATE_INIT if this.protocolVersion >= 5 { this.Write(minecraft.NewPacketClientLoginSuccess(FormatUUID(this.profile.Id), this.name)) } else { this.Write(minecraft.NewPacketClientLoginSuccess(this.profile.Id, this.name)) } if this.protocol17 { this.pipeline.Replace("registry", minecraft.PlayPacketServerCodec17) } else { this.pipeline.Replace("registry", minecraft.PlayPacketServerCodec) } this.connCodec.SetTimeout(20 * time.Second) this.server.SessionRegistry.Register(this) this.Redirect(server) }
func getPod(name string) (*jetpack.Pod, error) { if id := uuid.Parse(name); id != nil { // Pod UUID return Host.GetPod(id) } // TODO: pod name return nil, ErrUsage }
func (m *ApiClient) FindByUuid(typename string, id string) (contrail.IObject, error) { obj, err := m.db.GetByUuid(uuid.Parse(id)) if err != nil { return nil, err } m.interceptGet(obj) return obj, nil }
func (m *ApiClient) DeleteByUuid(typename string, id string) error { obj, err := m.db.GetByUuid(uuid.Parse(id)) if err != nil { return err } // Ensure the object has no children and/or back_refs return m.db.Delete(obj) }
func getClientSubscriberID(cl *data.QueueClient) bool { sClData := string(cl.DataIn) cUuid := uuid.Parse(sClData) if cUuid != nil { cl.SubscriberId = cUuid return true } return false }
// uUIDFromPath extracts the upload UUID from a given path // If the UUID is the last path component, this is the containing // directory for all upload files func uUIDFromPath(path string) (string, bool) { components := strings.Split(path, "/") for i := len(components) - 1; i >= 0; i-- { if uuid := uuid.Parse(components[i]); uuid != nil { return uuid.String(), i == len(components)-1 } } return "", false }