func GetRecords(msg *bw.SimpleMessage) []*MetadataRecord {
parts := strings.Split(msg.URI, "/")
uri := strings.Join(parts[:len(parts)-2], "/") + "/*"
var records []*MetadataRecord
for _ = range msg.POs {
rec := &MetadataRecord{
Key: parts[len(parts)-1],
Namespace: parts[0],
URI: uri,
VK: msg.From,
Time: time.Now().UnixNano(),
Msg: msg,
}
meta, ok := msg.GetOnePODF(bw.PODFSMetadata).(bw.MetadataPayloadObject)
if ok {
val := meta.Value()
if val != nil {
rec.Value = []byte(val.Value)
} else {
rec.Value = meta.GetContents()
}
} else {
rec.Value = msg.POs[0].GetContents()
}
records = append(records, rec)
}
return records
}
func (bwh *BOSSWaveHandler) listenQueries(msg *bw.SimpleMessage) {
var (
// the publisher of the message. We incorporate this into the signal URI
fromVK string
// the computed signal based on the VK and query nonce
signalURI string
// query message
query KeyValueQuery
)
fromVK = msg.From
po := msg.GetOnePODF(GilesKeyValueQueryPIDString)
if po == nil { // no query found
return
}
if obj, ok := po.(bw.MsgPackPayloadObject); !ok {
log.Error("Received query was not msgpack")
} else if err := obj.ValueInto(&query); err != nil {
log.Error(errors.Wrap(err, "Could not unmarshal received query"))
return
}
signalURI = fmt.Sprintf("%s,queries", fromVK[:len(fromVK)-1])
log.Infof("Got query %+v", query)
res, err := bwh.a.HandleQuery(query.Query)
if err != nil {
msg := QueryError{
Query: query.Query,
Nonce: query.Nonce,
Error: err.Error(),
}
po, _ := bw.CreateMsgPackPayloadObject(GilesQueryErrorPID, msg)
log.Error(errors.Wrap(err, "Error evaluating query"))
if err := bwh.iface.PublishSignal(signalURI, po); err != nil {
log.Error(errors.Wrap(err, "Error sending response"))
}
}
var reply []bw.PayloadObject
switch t := res.(type) {
case common.SmapMessageList:
log.Debug("smap messages list")
pos := POsFromSmapMessageList(query.Nonce, t)
reply = append(reply, pos...)
case common.DistinctResult:
log.Debug("distinct list")
reply = append(reply, POFromDistinctResult(query.Nonce, t))
default:
log.Debug("type %T", res)
}
log.Debugf("Reply on %s: %d", bwh.iface.SignalURI(signalURI), len(reply))
if err := bwh.iface.PublishSignal(signalURI, reply...); err != nil {
log.Error(errors.Wrap(err, "Error sending response"))
}
}
func (f *forwarder) send(msg *bw.SimpleMessage) {
f.RLock()
for view := range f.forwardList {
select {
case view.C <- msg:
default:
log.Warningf("Dropping msg")
msg.Dump()
}
}
f.RUnlock()
}
func GetDistinctList(nonce uint32, msg *bw.SimpleMessage) (bool, messages.QueryListResult, error) {
var (
po bw.PayloadObject
listResult messages.QueryListResult
)
if po = msg.GetOnePODF(messages.GilesQueryListResultPIDString); po != nil {
if err := po.(bw.MsgPackPayloadObject).ValueInto(&listResult); err != nil {
return false, listResult, err
}
if listResult.Nonce != nonce {
return false, listResult, nil
}
return true, listResult, nil
}
return false, listResult, nil
}
// Extracts Timeseries from Giles response. Returns false if no related message was found
func GetTimeseries(nonce uint32, msg *bw.SimpleMessage) (bool, messages.QueryTimeseriesResult, error) {
var (
po bw.PayloadObject
timeseriesResults messages.QueryTimeseriesResult
)
if po = msg.GetOnePODF(messages.GilesQueryTimeseriesResultPIDString); po != nil {
if err := po.(bw.MsgPackPayloadObject).ValueInto(×eriesResults); err != nil {
return false, timeseriesResults, err
}
if timeseriesResults.Nonce != nonce {
return false, timeseriesResults, nil
}
return true, timeseriesResults, nil
}
return false, timeseriesResults, nil
}
// Extracts QueryError from Giles response. Returns false if no related message was found
func GetError(nonce uint32, msg *bw.SimpleMessage) (bool, error) {
var (
po bw.PayloadObject
queryError messages.QueryError
)
if po = msg.GetOnePODF(messages.GilesQueryErrorPIDString); po != nil {
if err := po.(bw.MsgPackPayloadObject).ValueInto(&queryError); err != nil {
return false, err
}
if queryError.Nonce != nonce {
return false, nil
}
return true, nil
}
return false, nil
}
func (bwh *BOSSWaveHandler) listenCQBS(msg *bw.SimpleMessage) {
var (
// the publisher of the message. We incorporate this into the signal URI
fromVK string
// query message
query KeyValueQuery
)
fromVK = msg.From
po := msg.GetOnePODF(GilesKeyValueQueryPIDString)
if po == nil { // no query found
return
}
if obj, ok := po.(bw.MsgPackPayloadObject); !ok {
log.Error("Received query was not msgpack")
} else if err := obj.ValueInto(&query); err != nil {
log.Error(errors.Wrap(err, "Could not unmarshal received query"))
}
subscription := bwh.StartSubscriber(fromVK, query)
go bwh.a.HandleNewSubscriber(subscription, query.Query)
}