LOC: request device configuration and publish metrics/info

pkg/pillar/cmd/zedagent/handleappInstMetadata.go

@@ -20,14 +20,14 @@ func handleAppInstMetaDataModify(ctxArg interface{}, key string,
 func handleAppInstMetaDataDelete(ctxArg interface{}, key string, statusArg interface{}) {
 	appInstMetaData := statusArg.(types.AppInstMetaData)
 	ctx := ctxArg.(*zedagentContext)
-	PublishAppInstMetaDataToZedCloud(ctx, &appInstMetaData, true)
+	PublishAppInstMetaDataToZedCloud(ctx, &appInstMetaData, true, AllDest)
 	ctx.iteration++
 }
 
 func handleAppInstMetaDataImpl(ctxArg interface{}, key string, statusArg interface{}) {
 
 	appInstMetaData := statusArg.(types.AppInstMetaData)
 	ctx := ctxArg.(*zedagentContext)
-	PublishAppInstMetaDataToZedCloud(ctx, &appInstMetaData, false)
+	PublishAppInstMetaDataToZedCloud(ctx, &appInstMetaData, false, AllDest)
 	ctx.iteration++
 }

pkg/pillar/cmd/zedagent/handleblob.go

@@ -28,14 +28,14 @@ func handleBlobStatusImpl(ctxArg interface{}, key string,
 	status := statusArg.(types.BlobStatus)
 	ctx := ctxArg.(*zedagentContext)
 	uuidStr := status.Key()
-	PublishBlobInfoToZedCloud(ctx, uuidStr, &status, ctx.iteration)
+	PublishBlobInfoToZedCloud(ctx, uuidStr, &status, ctx.iteration, AllDest)
 	ctx.iteration++
 }
 
 func handleBlobDelete(ctxArg interface{}, key string, statusArg interface{}) {
 	status := statusArg.(types.BlobStatus)
 	ctx := ctxArg.(*zedagentContext)
 	uuidStr := status.Key()
-	PublishBlobInfoToZedCloud(ctx, uuidStr, nil, ctx.iteration)
+	PublishBlobInfoToZedCloud(ctx, uuidStr, nil, ctx.iteration, AllDest)
 	ctx.iteration++
 }

pkg/pillar/cmd/zedagent/handlecertconfig.go

@@ -428,9 +428,9 @@ func sendAttestReqProtobuf(attestReq *attest.ZAttestReq, iteration int) {
 	//We queue the message and then get the highest priority message to send.
 	//If there are no failures and defers we'll send this message,
 	//but if there is a queue we'll retry sending the highest priority message.
-	zedcloud.SetDeferred(zedcloudCtx, deferKey, buf, size, attestURL,
-		false, false, attestReq.ReqType)
-	zedcloud.HandleDeferred(zedcloudCtx, time.Now(), 0, true)
+	zedcloudCtx.DeferredEventCtx.SetDeferred(deferKey, buf, size, attestURL,
+		false, false, false, attestReq.ReqType)
+	zedcloudCtx.DeferredEventCtx.HandleDeferred(time.Now(), 0, true)
 }
 
 // initialize cipher pubsub trigger handlers and channels

pkg/pillar/cmd/zedagent/handleconfig.go

@@ -116,6 +116,7 @@ type getconfigContext struct {
 	localProfileTrigger       chan Notify
 	localServerMap            *localServerMap
 	lastDevCmdTimestamp       uint64 // From lastDevCmdTimestampFile
+	locConfig                 *types.LOCConfig
 
 	// parsed L2 adapters
 	vlans []L2Adapter
@@ -137,8 +138,6 @@ type getconfigContext struct {
 	// This information is persisted under /persist/checkpoint/localcommands
 	localCommands *types.LocalCommands
 
-	callProcessLocalProfileServerChange bool //did we already call processLocalProfileServerChange
-
 	configRetryUpdateCounter uint32 // received from config
 
 	// Frequency in seconds at which metrics is published to the controller.
@@ -352,10 +351,9 @@ func initZedcloudContext(networkSendTimeout uint32, agentMetrics *zedcloud.Agent
 // Run a periodic fetch of the config
 func configTimerTask(getconfigCtx *getconfigContext, handleChannel chan interface{}) {
 	ctx := getconfigCtx.zedagentCtx
-	configUrl := zedcloud.URLPathString(serverNameAndPort, zedcloudCtx.V2API, devUUID, "config")
 	iteration := 0
 	withNetTracing := traceNextConfigReq(ctx)
-	retVal, tracedReqs := getLatestConfig(getconfigCtx, configUrl, iteration, withNetTracing)
+	retVal, tracedReqs := getLatestConfig(getconfigCtx, iteration, withNetTracing)
 	configProcessingSkipFlag := retVal == skipConfig
 	if configProcessingSkipFlag != getconfigCtx.configProcessingSkipFlag {
 		getconfigCtx.configProcessingSkipFlag = configProcessingSkipFlag
@@ -395,12 +393,9 @@ func configTimerTask(getconfigCtx *getconfigContext, handleChannel chan interfac
 		case <-ticker.C:
 			start := time.Now()
 			iteration += 1
-			// In case devUUID changed we re-generate
-			configUrl = zedcloud.URLPathString(serverNameAndPort,
-				zedcloudCtx.V2API, devUUID, "config")
 			withNetTracing = traceNextConfigReq(ctx)
 			retVal, tracedReqs = getLatestConfig(
-				getconfigCtx, configUrl, iteration, withNetTracing)
+				getconfigCtx, iteration, withNetTracing)
 			configProcessingSkipFlag = retVal == skipConfig
 			if configProcessingSkipFlag != getconfigCtx.configProcessingSkipFlag {
 				getconfigCtx.configProcessingSkipFlag = configProcessingSkipFlag
@@ -476,7 +471,7 @@ func updateCertTimer(configInterval uint32, tickerHandle interface{}) {
 // until one succeeds in communicating with the cloud.
 // We use the iteration argument to start at a different point each time.
 // Returns a configProcessingSkipFlag
-func getLatestConfig(getconfigCtx *getconfigContext, url string,
+func requestConfigByURL(getconfigCtx *getconfigContext, url string,
 	iteration int, withNetTracing bool) (configProcessingRetval, []netdump.TracedNetRequest) {
 
 	log.Tracef("getLatestConfig(%s, %d)", url, iteration)
@@ -495,8 +490,7 @@ func getLatestConfig(getconfigCtx *getconfigContext, url string,
 	getconfigCtx.configGetStatus = types.ConfigGetFail
 	b, cr, err := generateConfigRequest(getconfigCtx)
 	if err != nil {
-		// XXX	fatal?
-		return configReqFailed, nil
+		log.Fatal(err)
 	}
 	buf := bytes.NewBuffer(b)
 	size := int64(proto.Size(cr))
@@ -579,9 +573,17 @@ func getLatestConfig(getconfigCtx *getconfigContext, url string,
 				if config != nil {
 					log.Noticef("Using saved config dated %s",
 						ts.Format(time.RFC3339Nano))
+
+					cfgRetval := inhaleDeviceConfig(getconfigCtx, config, savedConfig)
+					if cfgRetval != configOK {
+						log.Errorf("inhaleDeviceConfig failed: %d", cfgRetval)
+						return cfgRetval, rv.TracedReqs
+					}
+
 					getconfigCtx.readSavedConfig = true
 					getconfigCtx.configGetStatus = types.ConfigGetReadSaved
-					return inhaleDeviceConfig(getconfigCtx, config, savedConfig), rv.TracedReqs
+
+					return configOK, rv.TracedReqs
 				}
 			}
 		}
@@ -643,27 +645,67 @@ func getLatestConfig(getconfigCtx *getconfigContext, url string,
 		return invalidConfig, rv.TracedReqs
 	}
 
+	cfgRetval := configOK
+	if !changed {
+		log.Tracef("Configuration from zedcloud is unchanged")
+		// Update modification time since checked by readSavedConfig
+		touchReceivedProtoMessage()
+		goto cfgReceived
+	}
+
+	cfgRetval = inhaleDeviceConfig(getconfigCtx, config, fromController)
+	if cfgRetval != configOK {
+		log.Errorf("inhaleDeviceConfig failed: %d", cfgRetval)
+		return cfgRetval, rv.TracedReqs
+	}
+
 	// Inform ledmanager about config received from cloud
 	utils.UpdateLedManagerConfig(log, types.LedBlinkOnboarded)
 	getconfigCtx.ledBlinkCount = types.LedBlinkOnboarded
 
-	if !getconfigCtx.configReceived {
-		getconfigCtx.configReceived = true
-	}
 	getconfigCtx.configGetStatus = types.ConfigGetSuccess
 	publishZedAgentStatus(getconfigCtx)
 
-	if !changed {
-		log.Tracef("Configuration from zedcloud is unchanged")
-		// Update modification time since checked by readSavedConfig
-		touchReceivedProtoMessage()
-		return configOK, rv.TracedReqs
-	}
-
 	// Save configuration wrapped in AuthContainer.
 	saveReceivedProtoMessage(authWrappedRV.RespContents)
 
-	return inhaleDeviceConfig(getconfigCtx, config, fromController), rv.TracedReqs
+cfgReceived:
+	getconfigCtx.configReceived = true
+
+	return configOK, rv.TracedReqs
+}
+
+// Returns true if attempt to get a configuration has failed, but initial
+// configuration was received (either from the controller, either successfully
+// read from the file)
+func needRequestLocConfig(getconfigCtx *getconfigContext,
+	rv configProcessingRetval) bool {
+
+	return (rv != configOK && getconfigCtx.locConfig != nil)
+}
+
+func getLatestConfig(getconfigCtx *getconfigContext, iteration int,
+	withNetTracing bool) (configProcessingRetval, []netdump.TracedNetRequest) {
+
+	url := zedcloud.URLPathString(serverNameAndPort, zedcloudCtx.V2API,
+		devUUID, "config")
+
+	rv, tracedReqs := requestConfigByURL(getconfigCtx, url,
+		iteration, withNetTracing)
+
+	// Request configuration from the LOC
+	if needRequestLocConfig(getconfigCtx, rv) {
+		locURL := getconfigCtx.locConfig.LocURL
+		url = zedcloud.URLPathString(locURL, zedcloudCtx.V2API, devUUID, "config")
+
+		// If LOC configuration is outdated, then we get @obsoleteConfig
+		// return value (see parseConfig() for details) and we repeat on
+		// the next fetch attempt
+		rv, tracedReqs = requestConfigByURL(getconfigCtx, url,
+			iteration, withNetTracing)
+	}
+
+	return rv, tracedReqs
 }
 
 func saveReceivedProtoMessage(contents []byte) {
@@ -863,7 +905,7 @@ func inhaleDeviceConfig(getconfigCtx *getconfigContext, config *zconfig.EdgeDevC
 		if controllerEpoch != newControllerEpoch {
 			log.Noticef("Controller epoch changed from %d to %d", controllerEpoch, newControllerEpoch)
 			controllerEpoch = newControllerEpoch
-			triggerPublishAllInfo(getconfigCtx.zedagentCtx)
+			triggerPublishAllInfo(getconfigCtx.zedagentCtx, AllDest)
 		}
 	}
 

pkg/pillar/cmd/zedagent/handlecontent.go

@@ -141,7 +141,7 @@ func handleContentTreeStatusImpl(ctxArg interface{}, key string,
 	status := statusArg.(types.ContentTreeStatus)
 	ctx := ctxArg.(*zedagentContext)
 	uuidStr := status.Key()
-	PublishContentInfoToZedCloud(ctx, uuidStr, &status, ctx.iteration)
+	PublishContentInfoToZedCloud(ctx, uuidStr, &status, ctx.iteration, AllDest)
 	ctx.iteration++
 }
 
@@ -150,6 +150,6 @@ func handleContentTreeStatusDelete(ctxArg interface{}, key string,
 
 	ctx := ctxArg.(*zedagentContext)
 	uuidStr := key
-	PublishContentInfoToZedCloud(ctx, uuidStr, nil, ctx.iteration)
+	PublishContentInfoToZedCloud(ctx, uuidStr, nil, ctx.iteration, AllDest)
 	ctx.iteration++
 }

pkg/pillar/cmd/zedagent/handlelocation.go

@@ -28,7 +28,8 @@ const (
 )
 
 // Run a periodic post of the location information.
-func locationTimerTask(ctx *zedagentContext, handleChannel chan interface{}) {
+func locationTimerTask(ctx *zedagentContext, handleChannel chan interface{},
+	triggerLocationInfo chan destinationBitset) {
 	var cloudIteration int
 
 	// Ticker for periodic publishing to the controller.
@@ -59,28 +60,11 @@ func locationTimerTask(ctx *zedagentContext, handleChannel chan interface{}) {
 	for {
 		select {
 		case <-cloudTicker.C:
-			locInfo := getLocationInfo(ctx)
-			if locInfo == nil {
-				// Not available.
-				break
-			}
-			start := time.Now()
-			cloudIteration++
-			publishLocationToController(locInfo, cloudIteration)
-			ctx.ps.CheckMaxTimeTopic(wdName, "publishLocationToController", start,
-				warningTime, errorTime)
-
+			publishLocation(ctx, &cloudIteration, wdName, ControllerDest)
+		case dest := <-triggerLocationInfo:
+			publishLocation(ctx, &cloudIteration, wdName, dest)
 		case <-appTicker.C:
-			locInfo := getLocationInfo(ctx)
-			if locInfo == nil {
-				// Not available.
-				break
-			}
-			start := time.Now()
-			publishLocationToLocalServer(ctx.getconfigCtx, locInfo)
-			ctx.ps.CheckMaxTimeTopic(wdName, "publishLocationToLocalServer", start,
-				warningTime, errorTime)
-
+			publishLocation(ctx, &cloudIteration, wdName, LPSDest)
 		case <-stillRunning.C:
 		}
 		ctx.ps.StillRunning(wdName, warningTime, errorTime)
@@ -121,8 +105,31 @@ func updateLocationAppTimer(ctx *getconfigContext, appInterval uint32) {
 	flextimer.TickNow(ctx.locationAppTickerHandle)
 }
 
-func publishLocationToController(locInfo *info.ZInfoLocation, iteration int) {
-	log.Functionf("publishLocationToController: iteration %d", iteration)
+func publishLocation(ctx *zedagentContext, iter *int, wdName string,
+	dest destinationBitset) {
+	locInfo := getLocationInfo(ctx)
+	if locInfo == nil {
+		// Not available.
+		return
+	}
+	if dest&(ControllerDest|LOCDest) != 0 {
+		*iter++
+		start := time.Now()
+		publishLocationToDest(ctx, locInfo, *iter, dest)
+		ctx.ps.CheckMaxTimeTopic(wdName, "publishLocationToDest", start,
+			warningTime, errorTime)
+	}
+	if dest&LPSDest != 0 {
+		start := time.Now()
+		publishLocationToLocalServer(ctx.getconfigCtx, locInfo)
+		ctx.ps.CheckMaxTimeTopic(wdName, "publishLocationToLocalServer", start,
+			warningTime, errorTime)
+	}
+}
+
+func publishLocationToDest(ctx *zedagentContext, locInfo *info.ZInfoLocation,
+	iteration int, dest destinationBitset) {
+	log.Functionf("publishLocationToDest: iteration %d", iteration)
 	infoMsg := &info.ZInfoMsg{
 		Ztype: info.ZInfoTypes_ZiLocation,
 		DevId: devUUID.String(),
@@ -132,14 +139,11 @@ func publishLocationToController(locInfo *info.ZInfoLocation, iteration int) {
 		AtTimeStamp: ptypes.TimestampNow(),
 	}
 
-	log.Functionf("publishLocationToController: sending %v", infoMsg)
+	log.Functionf("publishLocationToDest: sending %v", infoMsg)
 	data, err := proto.Marshal(infoMsg)
 	if err != nil {
-		log.Fatal("publishLocationToController: proto marshaling error: ", err)
+		log.Fatal("publishLocationToDest: proto marshaling error: ", err)
 	}
-	infoURL := zedcloud.URLPathString(serverNameAndPort, zedcloudCtx.V2API,
-		devUUID, "info")
-
 	buf := bytes.NewBuffer(data)
 	if buf == nil {
 		log.Fatal("malloc error")
@@ -148,15 +152,13 @@ func publishLocationToController(locInfo *info.ZInfoLocation, iteration int) {
 
 	const bailOnHTTPErr = false
 	const withNetTrace = false
-	ctxWork, cancel := zedcloud.GetContextForAllIntfFunctions(zedcloudCtx)
-	defer cancel()
-	rv, err := zedcloud.SendOnAllIntf(ctxWork, zedcloudCtx, infoURL,
-		size, buf, iteration, bailOnHTTPErr, withNetTrace)
-	if err != nil {
-		// Hopefully next timeout will be more successful
-		log.Errorf("publishLocationToController: failed (status %d): %v", rv.Status, err)
-		return
-	}
+	key := "location:" + devUUID.String()
+
+	// Even for the controller destination we can't stall the queue on error,
+	// because this is recurring call, so set @forcePeriodic to true
+	forcePeriodic := true
+	queueInfoToDest(ctx, dest, key, buf, size, bailOnHTTPErr, withNetTrace,
+		forcePeriodic, info.ZInfoTypes_ZiLocation)
 }
 
 func publishLocationToLocalServer(ctx *getconfigContext, locInfo *info.ZInfoLocation) {