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