func (agent *agent_t) handle_beacon() (err error) { msg, err := agent.udp.RecvMessage(0) if len(msg[0]) != 16 { return errors.New("Not a uuid") } // If we got a UUID and it's not our own beacon, we have a peer uuid := uuid.UUID(msg[0]) if bytes.Compare(uuid, agent.uuid_bytes) != 0 { // Find or create peer via its UUID string uuid_string := uuid.String() peer, ok := agent.peers[uuid_string] if !ok { peer = new_peer(uuid) agent.peers[uuid_string] = peer // Report peer joined the network agent.pipe.SendMessage("JOINED", uuid_string) } // Any activity from the peer means it's alive peer.is_alive() } return }
// String() returns the string-encoded version like in uuid.UUID. func (id ID) String() string { b := uuid.UUID(make([]byte, EncodedLength)) if err := id.Write([]byte(b)); err != nil { log.Errorf("Unable to write as string: %v", err) } return b.String() }
func ReadUUID(reader io.Reader, util []byte) (result uuid.UUID, err error) { bytes := make([]byte, 16) _, err = reader.Read(bytes) if err != nil { return } result = uuid.UUID(bytes) return }
func (ks keyStorePassphrase) GetKey(keyAddr common.Address, auth string) (key *Key, err error) { keyBytes, keyId, err := decryptKeyFromFile(ks.keysDirPath, keyAddr, auth) if err == nil { key = &Key{ Id: uuid.UUID(keyId), Address: keyAddr, PrivateKey: ToECDSA(keyBytes), } } return }
func (ks keyStorePassphrase) GetKey(keyAddr []byte, auth string) (key *Key, err error) { keyBytes, keyId, err := DecryptKey(ks, keyAddr, auth) if err != nil { return nil, err } key = &Key{ Id: uuid.UUID(keyId), Address: keyAddr, PrivateKey: ToECDSA(keyBytes), } return key, err }
func (driver *MesosExecutorDriver) statusUpdateAcknowledgement(from *upid.UPID, pbMsg proto.Message) { log.Infoln("Executor statusUpdateAcknowledgement") msg := pbMsg.(*mesosproto.StatusUpdateAcknowledgementMessage) log.Infof("Receiving status update acknowledgement %v", msg) frameworkID := msg.GetFrameworkId() taskID := msg.GetTaskId() uuid := uuid.UUID(msg.GetUuid()) if driver.stopped { log.Infof("Ignoring status update acknowledgement %v for task %v of framework %v because the driver is stopped!\n", uuid, taskID, frameworkID) } // Remove the corresponding update. delete(driver.updates, uuid.String()) // Remove the corresponding task. delete(driver.tasks, taskID.String()) }
func (fs *FileSystem) Stat(ctx context.Context, pathname string, opts ...grpc.CallOption) (*FileStat, error) { pathname = path.Clean(pathname) out, err := fs.Interface.Stat(ctx, &StatRequest{Path: pathname}, opts...) if err != nil { return nil, &os.PathError{Op: "Stat", Path: pathname, Err: err} } return &FileStat{ Inode: uuid.UUID(out.Inode), Version: out.Version, Size: out.Size, Attrs: out.Attr, Created: fromInodeTime(out.Created), LastModified: fromInodeTime(out.LastModified), LastChanged: fromInodeTime(out.LastChanged), AdminID: out.AdminId, QuotaID: out.QuotaId, WriterID: out.WriterId, ReaderID: out.ReaderId, IsDirectory: out.IsDirectory, IsFinal: out.IsFinal, }, nil }
// SendStatusUpdate sends status updates to the slave. func (driver *MesosExecutorDriver) SendStatusUpdate(taskStatus *mesosproto.TaskStatus) (mesosproto.Status, error) { log.V(3).Infoln("Sending task status update: ", taskStatus.String()) if stat := driver.Status(); stat != mesosproto.Status_DRIVER_RUNNING { return stat, fmt.Errorf("Unable to SendStatusUpdate, expecting driver.status %s, but got %s", mesosproto.Status_DRIVER_RUNNING, stat) } if taskStatus.GetState() == mesosproto.TaskState_TASK_STAGING { err := fmt.Errorf("Executor is not allowed to send TASK_STAGING status update. Aborting!") log.Errorln(err) if err0 := driver.stop(mesosproto.Status_DRIVER_ABORTED); err0 != nil { log.Errorln("Error while stopping the driver", err0) } return driver.Status(), err } // Set up status update. update := driver.makeStatusUpdate(taskStatus) log.Infof("Executor sending status update %v\n", update.String()) // Capture the status update. driver.lock.Lock() driver.updates[uuid.UUID(update.GetUuid()).String()] = update driver.lock.Unlock() // Put the status update in the message. message := &mesosproto.StatusUpdateMessage{ Update: update, Pid: proto.String(driver.self.String()), } // Send the message. if err := driver.send(driver.slaveUPID, message); err != nil { log.Errorf("Failed to send %v: %v\n", message, err) return driver.status, err } return driver.Status(), nil }
func (u *UID) Interface() uuid.UUID { return uuid.UUID(u[:]) }
func encodeUuid(e *encodeState, v reflect.Value) { e.WriteString("#uuid ") e.string(uuid.UUID(v.Bytes()).String()) }
func (i UUID) String() string { return uuid.UUID(i).String() }
func (c *WorkerConnection) handleResponse(response [][]byte) { key := string(response[1]) c.requestLock.Lock() request := c.requests[key] delete(c.requests, key) c.requestLock.Unlock() if request == nil { log.Println("Response received for invalid request - it may have already been answered: ", uuid.UUID(response[1])) return } request.ResponseChan <- response[2] }
func (c *CPInterface) dispatchCommands(q *btrdb.Quasar, conn net.Conn) { //This governs the stream rmtx := sync.Mutex{} wmtx := sync.Mutex{} log.Info("cpnp connection") for !c.isShuttingDown { rmtx.Lock() seg, err := capn.ReadFromStream(conn, nil) if err != nil { log.Warning("ERR (%v) :: %v", conn.RemoteAddr(), err) conn.Close() break } rmtx.Unlock() go func() { seg := seg req := ReadRootRequest(seg) mkresp := func() (Response, *capn.Segment) { rvseg := capn.NewBuffer(nil) resp := NewRootResponse(rvseg) resp.SetEchoTag(req.EchoTag()) return resp, rvseg } sendresp := func(seg *capn.Segment) { wmtx.Lock() seg.WriteTo(conn) wmtx.Unlock() } switch req.Which() { case REQUEST_QUERYSTANDARDVALUES: //log.Info("QSV\n") st := req.QueryStandardValues().StartTime() et := req.QueryStandardValues().EndTime() uuid := uuid.UUID(req.QueryStandardValues().Uuid()) ver := req.QueryStandardValues().Version() //log.Info("[REQ=QsV] st=%v, et=%v, uuid=%v, gen=%v", st, et, uuid, ver) if ver == 0 { ver = btrdb.LatestGeneration } recordc, errorc, gen := q.QueryValuesStream(uuid, st, et, ver) if recordc == nil { log.Warning("RESPONDING ERR: %v", err) resp, rvseg := mkresp() resp.SetStatusCode(STATUSCODE_INTERNALERROR) resp.SetFinal(true) sendresp(rvseg) return } else { bufarr := make([]qtree.Record, 0, 4096) for { resp, rvseg := mkresp() fail := false fin := false for { select { case _, ok := <-errorc: if ok { fin = true fail = true goto donestandard } case r, ok := <-recordc: if !ok { fin = true goto donestandard } bufarr = append(bufarr, r) if len(bufarr) == cap(bufarr) { goto donestandard } } } donestandard: if fail { resp.SetStatusCode(STATUSCODE_INTERNALERROR) resp.SetFinal(true) //consume channels go func() { for _ = range recordc { } }() go func() { for _ = range errorc { } }() sendresp(rvseg) return } records := NewRecords(rvseg) rl := NewRecordList(rvseg, len(bufarr)) rla := rl.ToArray() for i, v := range bufarr { rla[i].SetTime(v.Time) rla[i].SetValue(v.Val) } records.SetVersion(gen) records.SetValues(rl) resp.SetRecords(records) resp.SetStatusCode(STATUSCODE_OK) if fin { resp.SetFinal(true) } sendresp(rvseg) bufarr = bufarr[:0] if fin { return } } } case REQUEST_QUERYSTATISTICALVALUES: st := req.QueryStatisticalValues().StartTime() et := req.QueryStatisticalValues().EndTime() uuid := uuid.UUID(req.QueryStatisticalValues().Uuid()) pw := req.QueryStatisticalValues().PointWidth() ver := req.QueryStatisticalValues().Version() if ver == 0 { ver = btrdb.LatestGeneration } recordc, errorc, gen := q.QueryStatisticalValuesStream(uuid, st, et, ver, pw) if recordc == nil { log.Warning("RESPONDING ERR: %v", err) resp, rvseg := mkresp() resp.SetStatusCode(STATUSCODE_INTERNALERROR) resp.SetFinal(true) sendresp(rvseg) return } else { bufarr := make([]qtree.StatRecord, 0, 4096) for { resp, rvseg := mkresp() fail := false fin := false for { select { case _, ok := <-errorc: if ok { fin = true fail = true goto donestat } case r, ok := <-recordc: if !ok { fin = true goto donestat } bufarr = append(bufarr, r) if len(bufarr) == cap(bufarr) { goto donestat } } } donestat: if fail { resp.SetStatusCode(STATUSCODE_INTERNALERROR) resp.SetFinal(true) //consume channels go func() { for _ = range recordc { } }() go func() { for _ = range errorc { } }() sendresp(rvseg) return } records := NewStatisticalRecords(rvseg) rl := NewStatisticalRecordList(rvseg, len(bufarr)) rla := rl.ToArray() for i, v := range bufarr { rla[i].SetTime(v.Time) rla[i].SetCount(v.Count) rla[i].SetMin(v.Min) rla[i].SetMean(v.Mean) rla[i].SetMax(v.Max) } records.SetVersion(gen) records.SetValues(rl) resp.SetStatisticalRecords(records) resp.SetStatusCode(STATUSCODE_OK) if fin { resp.SetFinal(true) } sendresp(rvseg) bufarr = bufarr[:0] if fin { return } } } case REQUEST_QUERYVERSION: //ul := req. ul := req.QueryVersion().Uuids() ull := ul.ToArray() resp, rvseg := mkresp() rvers := NewVersions(rvseg) vlist := rvseg.NewUInt64List(len(ull)) ulist := rvseg.NewDataList(len(ull)) for i, v := range ull { ver, err := q.QueryGeneration(uuid.UUID(v)) if err != nil { resp.SetStatusCode(STATUSCODE_INTERNALERROR) resp.SetFinal(true) sendresp(rvseg) return } //I'm not sure that the array that sits behind the uuid slice will stick around //so I'm copying it. uuid := make([]byte, 16) copy(uuid, v) vlist.Set(i, ver) ulist.Set(i, uuid) } resp.SetStatusCode(STATUSCODE_OK) rvers.SetUuids(ulist) rvers.SetVersions(vlist) resp.SetVersionList(rvers) resp.SetFinal(true) sendresp(rvseg) case REQUEST_QUERYNEARESTVALUE: resp, rvseg := mkresp() t := req.QueryNearestValue().Time() id := uuid.UUID(req.QueryNearestValue().Uuid()) ver := req.QueryNearestValue().Version() if ver == 0 { ver = btrdb.LatestGeneration } back := req.QueryNearestValue().Backward() rv, gen, err := q.QueryNearestValue(id, t, back, ver) switch err { case nil: resp.SetStatusCode(STATUSCODE_OK) records := NewRecords(rvseg) rl := NewRecordList(rvseg, 1) rla := rl.ToArray() rla[0].SetTime(rv.Time) rla[0].SetValue(rv.Val) records.SetVersion(gen) records.SetValues(rl) resp.SetRecords(records) case qtree.ErrNoSuchPoint: resp.SetStatusCode(STATUSCODE_NOSUCHPOINT) default: resp.SetStatusCode(STATUSCODE_INTERNALERROR) } resp.SetFinal(true) sendresp(rvseg) case REQUEST_QUERYCHANGEDRANGES: resp, rvseg := mkresp() id := uuid.UUID(req.QueryChangedRanges().Uuid()) sgen := req.QueryChangedRanges().FromGeneration() egen := req.QueryChangedRanges().ToGeneration() if egen == 0 { egen = btrdb.LatestGeneration } resolution := req.QueryChangedRanges().Resolution() rv, ver, err := q.QueryChangedRanges(id, sgen, egen, resolution) switch err { case nil: resp.SetStatusCode(STATUSCODE_OK) ranges := NewRanges(rvseg) ranges.SetVersion(ver) crl := NewChangedRangeList(rvseg, len(rv)) crla := crl.ToArray() for i := 0; i < len(rv); i++ { crla[i].SetStartTime(rv[i].Start) crla[i].SetEndTime(rv[i].End) } ranges.SetValues(crl) resp.SetChangedRngList(ranges) default: log.Critical("qcr error: ", err) resp.SetStatusCode(STATUSCODE_INTERNALERROR) } resp.SetFinal(true) sendresp(rvseg) case REQUEST_INSERTVALUES: resp, rvseg := mkresp() uuid := uuid.UUID(req.InsertValues().Uuid()) rl := req.InsertValues().Values() rla := rl.ToArray() if len(rla) != 0 { qtr := make([]qtree.Record, len(rla)) for i, v := range rla { qtr[i] = qtree.Record{Time: v.Time(), Val: v.Value()} } q.InsertValues(uuid, qtr) } if req.InsertValues().Sync() { q.Flush(uuid) } resp.SetFinal(true) resp.SetStatusCode(STATUSCODE_OK) sendresp(rvseg) case REQUEST_DELETEVALUES: resp, rvseg := mkresp() id := uuid.UUID(req.DeleteValues().Uuid()) stime := req.DeleteValues().StartTime() etime := req.DeleteValues().EndTime() err := q.DeleteRange(id, stime, etime) switch err { case nil: resp.SetStatusCode(STATUSCODE_OK) default: resp.SetStatusCode(STATUSCODE_INTERNALERROR) } resp.SetFinal(true) sendresp(rvseg) default: log.Critical("weird segment") } }() } }
func (this *SessionOutBridge) HandlePacket(packet packet.Packet) (err error) { if !this.session.Authenticated() { this.conn.Close() return } switch this.state { case STATE_LOGIN: if packet.Id() == minecraft.PACKET_CLIENT_LOGIN_SUCCESS { this.session.redirectMutex.Lock() this.state = STATE_INIT this.session.redirecting = true this.EnsureCompression() if this.session.protocol17 { this.pipeline.Replace("registry", minecraft.PlayPacketClientCodec17) } else { this.pipeline.Replace("registry", minecraft.PlayPacketClientCodec) } } else if packet.Id() == minecraft.PACKET_CLIENT_LOGIN_DISCONNECT { this.session.DisconnectJson(packet.(*minecraft.PacketClientLoginDisconnect).Json) this.conn.Close() } else if packet.Id() == minecraft.PACKET_CLIENT_LOGIN_SET_COMPRESSION { this.SetCompression(packet.(*minecraft.PacketClientLoginSetCompression).Threshold) } else { if this.session.Initializing() { this.session.Disconnect("Error: Outbound Protocol Mismatch") } this.conn.Close() } case STATE_INIT: if packet.Id() == minecraft.PACKET_CLIENT_PLAYER_POSITION_AND_LOOK { this.session.outBridge = this this.session.redirecting = false this.session.state = STATE_CONNECTED this.state = STATE_CONNECTED this.session.redirectMutex.Unlock() } fallthrough case STATE_CONNECTED: if packet.Id() == minecraft.PACKET_CLIENT_DISCONNECT { this.state = STATE_DISCONNECTED } if this.state == STATE_CONNECTED { this.session.redirectMutex.Lock() if this.session.outBridge != this { this.session.outBridge.EnsureCompression() this.conn.Close() this.session.redirectMutex.Unlock() break } this.session.redirectMutex.Unlock() } switch packet.Id() { case minecraft.PACKET_CLIENT_JOIN_GAME: joinGamePacket := packet.(*minecraft.PacketClientJoinGame) if this.session.clientSettings != nil { this.Write(this.session.clientSettings) } this.session.serverEntityId = joinGamePacket.EntityId if this.session.state == STATE_INIT { this.session.clientEntityId = joinGamePacket.EntityId } else { var swapDimension int32 if joinGamePacket.Dimension == 0 { swapDimension = 1 } else { swapDimension = 0 } this.session.Write(minecraft.NewPacketClientRespawn(swapDimension, 2, 0, "DEFAULT")) this.session.Write(minecraft.NewPacketClientRespawn(int32(joinGamePacket.Dimension), joinGamePacket.Difficulty, joinGamePacket.Gamemode, joinGamePacket.LevelType)) if len(this.session.playerList) > 0 { if this.session.protocol17 { for player, _ := range this.session.playerList { this.session.Write(minecraft.NewPacketClientPlayerList17Remove(player)) } } else { items := make([]minecraft.PacketClientPlayerListItem, 0, len(this.session.playerList)) for uuidString, _ := range this.session.playerList { items = append(items, minecraft.PacketClientPlayerListItem{UUID: uuid.UUID(uuidString)}) } this.session.Write(minecraft.NewPacketClientPlayerList(minecraft.PACKET_CLIENT_PLAYER_LIST_ACTION_REMOVE, items)) } this.session.playerList = make(map[string]struct{}) } if len(this.session.scoreboards) > 0 { for scoreboard, _ := range this.session.scoreboards { this.session.Write(minecraft.NewPacketClientScoreboardObjectiveRemove(scoreboard)) } this.session.scoreboards = make(map[string]struct{}) } if len(this.session.teams) > 0 { for team, _ := range this.session.teams { this.session.Write(minecraft.NewPacketClientTeamsRemove(team)) } this.session.teams = make(map[string]struct{}) } if len(this.session.pluginChannels) > 0 { channels := make([][]byte, 0, len(this.session.pluginChannels)) for channel, _ := range this.session.pluginChannels { channels = append(channels, []byte(channel)) } this.Write(minecraft.NewPacketServerPluginMessage("REGISTER", bytes.Join(channels, []byte{0}))) } return } case minecraft.PACKET_CLIENT_PLAYER_LIST: if this.session.protocol17 { playerListPacket := packet.(*minecraft.PacketClientPlayerList17) if playerListPacket.Online { this.session.playerList[playerListPacket.Name] = struct{}{} } else { delete(this.session.playerList, playerListPacket.Name) } } else { playerListPacket := packet.(*minecraft.PacketClientPlayerList) if playerListPacket.Action == minecraft.PACKET_CLIENT_PLAYER_LIST_ACTION_ADD { for _, item := range playerListPacket.Items { this.session.playerList[string(item.UUID)] = struct{}{} } } else if playerListPacket.Action == minecraft.PACKET_CLIENT_PLAYER_LIST_ACTION_REMOVE { for _, item := range playerListPacket.Items { delete(this.session.playerList, string(item.UUID)) } } } case minecraft.PACKET_CLIENT_SCOREBOARD_OBJECTIVE: scoreboardPacket := packet.(*minecraft.PacketClientScoreboardObjective) if scoreboardPacket.Action == minecraft.PACKET_CLIENT_SCOREBOARD_OBJECTIVE_ACTION_ADD { this.session.scoreboards[scoreboardPacket.Name] = struct{}{} } else if scoreboardPacket.Action == minecraft.PACKET_CLIENT_SCOREBOARD_OBJECTIVE_ACTION_REMOVE { delete(this.session.scoreboards, scoreboardPacket.Name) } case minecraft.PACKET_CLIENT_TEAMS: teamPacket := packet.(*minecraft.PacketClientTeams) if teamPacket.Action == minecraft.PACKET_CLIENT_TEAMS_ACTION_ADD { this.session.teams[teamPacket.Name] = struct{}{} } else if teamPacket.Action == minecraft.PACKET_CLIENT_TEAMS_ACTION_REMOVE { delete(this.session.teams, teamPacket.Name) } case minecraft.PACKET_CLIENT_DISCONNECT: this.session.DisconnectJson(packet.(*minecraft.PacketClientDisconnect).Json) return case minecraft.PACKET_CLIENT_SET_COMPRESSION: this.SetCompression(packet.(*minecraft.PacketClientSetCompression).Threshold) return default: if genericPacket, ok := packet.(*minecraft.PacketGeneric); ok { genericPacket.SwapEntities(this.session.clientEntityId, this.session.serverEntityId, true, this.session.protocol17) } } this.session.Write(packet) } return }
func Equals(uuid1, uuid2 UUID) bool { return uuid.Equal(uuid.UUID(uuid1), uuid.UUID(uuid2)) }
func doCustom(w io.Writer, cmd string, args ...interface{}) { s, ok := customSql[cmd] if !ok { log.Fatalf("Invalid command/query %v", cmd) } else if *showquery { fmt.Fprint(w, s) return } rows, err := db.Query(s, args...) fatalif(err) tw := tabwriter.NewWriter(w, 4, 4, 1, ' ', 0) cols, err := rows.Columns() fatalif(err) simidcol := -1 if !*noheader { // write header line for i, c := range cols { if strings.Contains(strings.ToLower(c), "simid") { simidcol = i } _, err := tw.Write([]byte(c + "\t")) fatalif(err) } _, err = tw.Write([]byte("\n")) fatalif(err) } vs := make([]interface{}, len(cols)) vals := make([]*sql.NullString, len(cols)) for i := range vals { vals[i] = &sql.NullString{} vs[i] = vals[i] } for rows.Next() { for i := range vals { vals[i].Valid = false } err := rows.Scan(vs...) fatalif(err) for i, v := range vals { if v.Valid { s = v.String if i == simidcol { s = uuid.UUID(v.String).String() } tw.Write([]byte(s + "\t")) } else { tw.Write([]byte("NULL\t")) } } _, err = tw.Write([]byte("\n")) fatalif(err) } fatalif(rows.Err()) fatalif(tw.Flush()) }
// String() returns the string-encoded version like in uuid.UUID. func (id ID) String() string { b := uuid.UUID(make([]byte, EncodedLength)) id.Write([]byte(b)) return b.String() }