func (h *MsgPackUdpHandler) decode(buffer []byte) (*common.SmapMessage, error) {
var (
uuid string
)
msg := h.msgpool.Get().(*common.SmapMessage)
msgMap, err := doDecode(buffer)
if err != nil {
log.Errorf("Error decoding msgpack %v", err)
return nil, err
}
// get Path
if msg.Path, err = getStringValue(msgMap, "Path"); err != nil {
return msg, err
}
// get UUID
if uuid, err = getStringValue(msgMap, "uuid"); err != nil {
return msg, err
}
msg.UUID = common.UUID(uuid)
// test for readings
rdgs, err := getReadings(msgMap)
if err != nil && err != ReadingsNotFound {
return msg, err // return early if we found readings and it still gave error
} else if err == ReadingsNotFound { // otherwise look for Value field
var value float64
if value, err = getValue(msgMap); err != nil {
return msg, err
}
msg.Readings = []common.Reading{&common.SmapNumberReading{Time: common.GetNow(common.UOT_MS), Value: value}}
} else if err == nil { // readings are ok
msg.Readings = rdgs
}
//get Metadata
md, err := getMetadata(msgMap)
if err != nil && err != MetadataNotFound {
return msg, err
} else if err == nil {
msg.Metadata = md
}
//get Properties
props, err := getProperties(msgMap)
if err != nil && err != PropertiesNotFound {
return msg, err
} else if err == nil {
msg.Properties = props
}
return msg, nil
}
func (req *ArchiveRequest) GetSmapMessage(thing interface{}) *common.SmapMessage {
var msg = new(common.SmapMessage)
var rdg = new(common.SmapNumberReading)
value := ob.Eval(req.value, thing)
switch t := value.(type) {
case int64:
rdg.Value = float64(t)
case uint64:
rdg.Value = float64(t)
case float64:
rdg.Value = t
}
rdg.Time = req.getTime(thing)
if len(req.uuid) > 0 && req.uuidActual == "" {
req.uuidActual = common.UUID(ob.Eval(req.uuid, thing).(string))
} else if req.uuidActual == "" {
req.uuidActual = common.UUID(req.UUID)
}
msg.UUID = req.uuidActual
msg.Path = req.URI + "/" + req.Value
msg.Readings = []common.Reading{rdg}
if len(req.metadataExpr) > 0 {
msg.Metadata = make(common.Dict)
msg.Properties = new(common.SmapProperties)
if md, ok := ob.Eval(req.metadataExpr, thing).(map[string]interface{}); ok {
for k, v := range md {
val := fmt.Sprintf("%s", v)
if k == "UnitofTime" {
msg.Properties.UnitOfTime, _ = common.ParseUOT(val)
} else if k == "UnitofMeasure" {
msg.Properties.UnitOfMeasure = val
}
msg.Metadata[k] = val
}
}
}
return msg
}
func (m *mongoStore) GetUUIDs(where bson.M) ([]common.UUID, error) {
var results []common.UUID
var x []bson.M
var whereClause bson.M
if len(where) != 0 {
whereClause = make(bson.M)
for wk, wv := range where {
whereClause[common.FixMongoKey(wk)] = wv
}
}
selectClause := bson.M{"_id": 0, "uuid": 1}
err := m.metadata.Find(where).Select(selectClause).All(&x)
results = make([]common.UUID, len(x))
for i, doc := range x {
results[i] = common.UUID(doc["uuid"].(string))
}
return results, err
}
func (req *ArchiveRequest) GetMetadata(msg *bw.SimpleMessage) *common.SmapMessage {
var ret = new(common.SmapMessage)
req.Lock()
if req.UUID != "" && req.uuidActual == "" {
req.uuidActual = common.UUID(req.UUID)
}
req.Unlock()
ret.UUID = req.uuidActual
ret.Path = req.URI + "/" + req.Value
ret.Metadata = make(common.Dict)
ret.Properties = new(common.SmapProperties)
for _, po := range msg.POs {
var md map[string]interface{}
if po.IsTypeDF(bw.PODFMsgPack) {
err := po.(bw.MsgPackPayloadObject).ValueInto(&md)
if err != nil {
log.Error(errors.Wrap(err, "Could not unmarshal msgpack metadata"))
return nil
}
} else if po.IsTypeDF(bw.PODFSMetadata) {
md = make(map[string]interface{})
tuple := po.(bw.MetadataPayloadObject).Value()
md[getMetadataKey(msg.URI)] = tuple.Value
}
for k, v := range md {
val := fmt.Sprintf("%s", v)
if k == "UnitofTime" {
ret.Properties.UnitOfTime, _ = common.ParseUOT(val)
} else if k == "UnitofMeasure" {
ret.Properties.UnitOfMeasure = val
}
ret.Metadata[k] = val
}
}
return ret
}
// First, we check that all the fields are valid and the necessary ones are populated.
// This also involves filling in the optional ones with sane values.
// Then we build a chain on the URI to the VK -- if this fails, then we stop
// Then we build the operator chains for the expressions required
// Then we subscribe to the URI indicated.
func (bwh *BOSSWaveHandler) ParseArchiveRequest(request *ArchiveRequest) (*URIArchiver, error) {
if request.FromVK == "" {
return nil, errors.New("VK was empty in ArchiveRequest")
}
request.value = ob.Parse(request.Value)
if request.UUID == "" {
request.UUID = uuid.NewV3(NAMESPACE_UUID, request.URI+string(request.PO)+request.Value).String()
} else {
request.uuid = ob.Parse(request.UUID)
}
if request.Time != "" {
request.time = ob.Parse(request.Time)
}
if request.MetadataExpr != "" {
request.metadataExpr = ob.Parse(request.MetadataExpr)
}
if request.InheritMetadata {
md, _, err := bwh.bw.GetMetadata(request.URI)
if err != nil {
return nil, err
}
var ret = new(common.SmapMessage)
request.Lock()
if request.UUID != "" && request.uuidActual == "" {
request.uuidActual = common.UUID(request.UUID)
}
request.Unlock()
ret.UUID = request.uuidActual
ret.Path = request.URI + "/" + request.Value
ret.Metadata = make(common.Dict)
ret.Properties = new(common.SmapProperties)
for k, v := range md {
val := fmt.Sprintf("%s", v.Value)
if k == "UnitofTime" {
ret.Properties.UnitOfTime, _ = common.ParseUOT(val)
} else if k == "UnitofMeasure" {
ret.Properties.UnitOfMeasure = val
}
ret.Metadata[k] = val
}
if err = bwh.a.AddData(ret); err != nil {
log.Error(errors.Wrap(err, "Could not add data"))
}
}
var metadataChan = make(chan *bw.SimpleMessage)
if len(request.MetadataURIs) > 0 {
for _, metadataURI := range request.MetadataURIs {
sub1, err := bwh.bw.Subscribe(&bw.SubscribeParams{
URI: strings.TrimSuffix(metadataURI, "/") + "/!meta/+",
})
if err != nil {
return nil, err
}
go func() {
for msg := range sub1 {
metadataChan <- msg
}
}()
q1, err := bwh.bw.Query(&bw.QueryParams{
URI: strings.TrimSuffix(metadataURI, "/") + "/!meta/+",
})
if err != nil {
return nil, err
}
go func() {
for msg := range q1 {
metadataChan <- msg
}
}()
}
}
//TODO: subscribe then query MetadataBlock
log.Debugf("Subscribing for Archival on %s", request.URI)
sub, err := bwh.bw.Subscribe(&bw.SubscribeParams{
URI: request.URI,
})
if err != nil {
return nil, errors.Wrap(err, "Could not subscribe")
}
log.Debugf("Got archive request")
request.Dump()
archiver := &URIArchiver{sub, metadataChan, request}
go archiver.Listen(bwh.a)
return archiver, nil
}
