def Read(self, spec=None):
node = self.Node
logger.info("Reading objects from pds-agent for node ", node)
if (EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled()):
logger.info("Wait 15 seconds for control-plane convergence")
utils.Sleep(15)
failingObjects = []
for objtype in APIObjTypes:
objname = objtype.name
client = ObjectInfo.get(objname.lower(), None)
if not client:
logger.error(f"Skipping read validation for {objname}")
continue
if not client.IsReadSupported():
logger.error(f"Read unsupported for {objname}")
continue
if not client.ReadObjects(node):
logger.error(f"Read validation failed for {objname}")
failingObjects.append(objname)
if len(failingObjects):
logger.error(f"Read validation failed for {failingObjects}")
# assert here as there is no point in proceeding further
assert (0)
return True
def SetupCfgFilesForUpgrade(self, spec=None):
# For hardware nothing to setup specifically
if not utils.IsDol():
return True
if utils.IsDryRun():
return True
mode = "hitless"
self.failure_stage = None
self.failure_reason = None
args = ""
if hasattr(spec, "UpgMode"):
mode = getattr(spec, "UpgMode", "hitless")
if hasattr(spec, "failure_stage"):
self.failure_stage = getattr(spec, "failure_stage", None)
if hasattr(spec, "failure_reason"):
self.failure_reason = getattr(spec, "failure_reason", None)
logger.info("Setup Upgrade Config Files for %s mode" % mode)
logger.info("Setup Upgrade failure stage %s, failure reason %s" %
(self.failure_stage, self.failure_reason))
if self.failure_stage != None and self.failure_reason != None:
args = "%s %s" % (self.failure_stage, self.failure_reason)
# For now cfg file setup done only for hitless mode
if mode == "hitless":
# setup hitless upgrade config files
upg_setup_cmds = "apollo/test/tools/apulu/setup_hitless_upgrade_cfg_sim.sh %s" % args
if not RunCmd(upg_setup_cmds, timeout=20, background=True):
logger.error("Command Execution Failed: %s" % upg_setup_cmds)
return False
utils.Sleep(10) # setup is executed in the background.
return True
def CreateObjects(self, node):
super().CreateObjects(node)
# Create Metaswitch objects
evpnevi.client.CreateObjects(node)
evpnevirt.client.CreateObjects(node)
if (EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled()):
print("Wait to ensure that subnets are active")
utils.Sleep(3)
# Create VNIC objects
vnic.client.CreateObjects(node)
rmapping.client.CreateObjects(node)
return True
def Write(self, lgh=logger):
if GlobalOptions.skipverify:
return
# post devcmd
data = self.data[self.__data_class__]
# set cmd done
data.done = 0
# set doorbell
data.doorbell = 1
lgh.info("Writing %s @0x%x size: %d" %
(self.__data_class__.__name__, self.addr, self.size))
self.Show()
model_wrap.write_mem_pcie(self.addr, bytes(self.data), len(self.data))
# wait for nicmgr to process this devcmd
utils.Sleep(NICMGR_DEV_CMD_TIMEOUT)
def PollConfigReplayReady(self, spec=None):
retry = getattr(spec, "retry", 600)
sleep_interval = getattr(spec, "sleep_interval", 1)
while retry:
logger.info(
f"retry{retry}: Polling upgrade manager for ConfigReplay state"
)
retry -= 1
if self.ConfigReplayReadyCheck():
logger.info("PollConfigReplayReady: Success")
return True
if not retry:
logger.info("PollConfigReplayReady: Failed")
return False
utils.Sleep(sleep_interval)
return False
def VerifyUpgradeDoneStatus(self, spec=None):
if utils.IsDryRun():
return True
retry = 1200
while retry:
with open("/update/pds_upg_status.txt", 'r') as fp:
status = fp.read()
logger.info("upgrade status %s" % status)
if status.find("success") != -1:
return True
if status.find("failed") != -1:
if self.failure_stage != None:
return True
return False
retry = retry - 1
utils.Sleep(10)
return False
def CreateObjects(self, node):
if EzAccessStoreClient[node].IsDeviceOverlayRoutingEnabled() or\
EzAccessStoreClient[node].IsBitwMode():
logger.info(f"Skip Creating {self.ObjType.name} Objects in {node}")
return
cookie = utils.GetBatchCookie(node)
if utils.IsPipelineApulu():
if utils.IsBatchingDisabled():
# L3 interfaces go via MS and they need time to make it to HAL before
# we can push nexthops pointing to them
utils.Sleep(5)
logger.info(
f"Creating {len(self.__underlay_objs[node])} underlay {self.ObjType.name} Objects in {node}"
)
msgs = list(
map(lambda x: x.GetGrpcCreateMessage(cookie),
self.__underlay_objs[node].values()))
list(map(lambda x: x.SetHwHabitant(False), self.Objects(node)))
list(
map(lambda x: x.SetHwHabitant(True),
self.__underlay_objs[node].values()))
else:
logger.info(
f"Creating {len(self.Objects(node))} {self.ObjType.name} Objects in {node}"
)
msgs = list(
map(lambda x: x.GetGrpcCreateMessage(cookie),
self.Objects(node)))
list(map(lambda x: x.SetHwHabitant(True), self.Objects(node)))
api.client[node].Create(self.ObjType, msgs)
# Note: Tunnel objects depends on nhgroup with underlay ecmp, hence create those nhgroups
# along with nexthop objects. Since nh objects are always created before tunnel objects
NHGroupClient.CreateObjectsOfType(
node, nh_pb2.NEXTHOP_GROUP_TYPE_UNDERLAY_ECMP)
return