def main():
signal.signal(signal.SIGINT, signalHandler)
cfg = JsonConfig()
logger = logging.getLogger('')
logger.setLevel(cfg.general.logLevel)
map = cv2.imread(cfg.mapData.map, cv2.CV_LOAD_IMAGE_GRAYSCALE)
lookupTable = np.load(cfg.mapData.dmap)
length = cfg.robot.length
forwardNoise = cfg.particle.forwardNoise
turnNoise = cfg.particle.turnNoise
senseNoise = cfg.particle.senseNoise
particleTopic = ParticleTopic()
particleFilter = ParticleFilter(length, map, lookupTable,
forwardNoise, turnNoise, senseNoise)
serverPort = cfg.particle.port
client = Client('', cfg.server.port, BetelbotClientConnection)
conn = client.connect()
server = ParticleFilterServer(connection=ParticleFilterConnection,
masterConn=conn, particleFilter=particleFilter, particleTopic=particleTopic)
server.listen(serverPort)
IOLoop.instance().start()
def main():
signal.signal(signal.SIGINT, signalHandler)
cfg = JsonConfig()
logger = logging.getLogger("")
logger.setLevel(cfg.general.logLevel)
grid = cv2.imread(cfg.mapData.map, cv2.CV_LOAD_IMAGE_GRAYSCALE)
lookupTable = np.load(cfg.mapData.dmap)
gridsize = cfg.map.gridsize
start = cfg.robosim.start
delay = cfg.robosim.delay
serverPort = cfg.robosim.port
client = Client("", cfg.server.port, BetelbotClientConnection)
conn = client.connect()
driver = BetelbotSimDriver(start, grid, gridsize, lookupTable, delay)
server = RobotServer(connection=RobotConnection, driver=driver, masterConn=conn)
server.listen(serverPort)
IOLoop.instance().start()
def check_apic_cluster(client: Client) -> State:
"""APIC cluster state"""
# Verify health == 'fully-fit' in infraWiNode
for controller in client.get_class("infraWiNode"):
if controller.get("health") != "fully-fit":
log.warning("not fully-fit")
return State.FAIL
return State.OK
def check_switch_scale(client: Client) -> State:
"""per-switch scale"""
# Verify counts from ctxClassCnt are < limits from fvcapRule
from collections import defaultdict
metrics = defaultdict(lambda: defaultdict(dict))
# map ctxClassCnt counts to fvcapRule limits
count_to_limit = {"l2BD": "fvBD", "fvEpP": "fvCEp", "l3Dom": "fvCtx"}
# Build dict with device/mo/metric
counts = client.get_class("ctxClassCnt",
params={"rsp-subtree-class": "l2BD,fvEpP,l3Dom"})
for record in counts:
node_dn = get_node_dn(record["dn"])
key = count_to_limit.get(record["name"])
if key:
metrics[node_dn][key]["count"] = get_path(int, record, "count")
# Add limits to the metrics dict
limits = client.get_class("fvcapRule", cache=True)
for record in limits:
if record["dn"].startswith("topology"):
node_dn = get_node_dn(record["dn"])
subj = record["subj"]
if node_dn in metrics and subj in count_to_limit.values():
limit = get_path(int, record, "constraint")
metrics[node_dn][subj]["limit"] = limit
# Validate metrics
over_limit = False
for node_dn, by_mo in metrics.items():
for mo, metric in by_mo.items():
count = metric.get("count", 0)
limit = metric.get("limit", 0)
if count > 0 and count >= limit:
over_limit = True
log.warning(f"Over scale limit on {node_dn}",
mo=mo,
count=count,
limit=limit)
if client.args["debug"]:
log.debug(f"Scale metric on {node_dn}:",
mo=mo,
count=count,
limit=limit)
return State.FAIL if over_limit else State.OK
def main():
sock = Client(("localhost", 50000))
p_read = Process(target=read, args=(sock, ))
p_read.daemon = True
p_read.start()
write(sock)
print("通信を終了しました")
def check_vpc_health(client: Client) -> State:
"""vPC health"""
# Verify peerSt == 'up' for vpcDom
for vpc in client.get_class("vpcDom"):
if vpc["peerSt"] != "up":
log.warning("vPC not up", id=vpc["id"], state=vpc["peerSt"])
return State.FAIL
log.debug("All vPCs are up")
return State.OK
def get_interpod_routes(client: Client) -> List[Dict[str, str]]:
"""Get current inter-pod routes"""
tepQueries = []
for pod in client.get_class("fabricSetupP"):
if pod.get("podType") == "physical":
tepPool = pod.get("tepPool")
if tepPool:
tepQueries.append(f'eq(isisRoute.pfx,"{tepPool}")')
if len(tepQueries) > 0:
tepQuery = ",".join(tepQueries)
return client.get_class(
"isisRoute",
params={
"rsp-subtree-include": "relations",
"query-target-filter": f"or({tepQuery})",
},
)
return []
def check_vcenter(client: Client) -> State:
"""VMware vCenter state"""
# Verify operSt == 'online' in compCtrlr
for ctrlr in client.get_class("compCtrlr"):
if ctrlr.get("operSt", "") != "online":
log.warning("vCenter offline", name=ctrlr["name"])
return State.FAIL
log.debug("All vCenter(s) online")
return State.OK
def check_dvs(client: Client) -> State:
"""VMware DVS state"""
# Verify state == 'poweredOn' in compHv
for dvs in client.get_class("compHv"):
if dvs.get("state", "") != "poweredOn":
log.warning("vSwitch offline", name=dvs["name"])
return State.FAIL
log.debug("All vSwitch(s) online")
return State.OK
def main():
# Starts up a client connection to publish commands to Betelbot server.
cfg = JsonConfig()
topics = getTopicFactory()
client = Client('', cfg.server.port, BetelbotClientConnection)
conn = client.connect()
thread = threading.Thread(target=threadedLoop)
thread.daemon = True
thread.start()
teleop = Teleop(conn, topics, cfg.teleop.location, cfg.teleop.waypoint)
teleop.printInstructions()
teleop.run()
term = NonBlockingTerm()
term.run(teleop.onInput)
def on_auth(self, req, u_name):
"""Authentication routine"""
url_to_redirect = self.app.url_for(req, '/main')
response = self.app.redirect(url_to_redirect)
session_token = derive_token()
self.sessions.add(session_token)
response.set_cookie('session', session_token)
client = Client(u_name, self.server_dir)
self.current_users[session_token] = client
return response
def main():
signal.signal(signal.SIGINT, signalHandler)
cfg = JsonConfig()
logger = logging.getLogger('')
logger.setLevel(cfg.general.logLevel)
client = Client('', cfg.server.port, BetelbotClientConnection)
conn = client.connect()
conn.batchLocate(onBatchLocateResponse,
[RobotMethod.POWER, RobotMethod.MODE, RobotMethod.STATUS])
application = web.Application([
(cfg.websocketServer.socketUri, VisualizerWebSocket, dict(conn=conn)),
])
application.listen(cfg.websocketServer.port)
IOLoop.instance().start()
def main():
signal.signal(signal.SIGINT, signalHandler)
cfg = JsonConfig()
logger = logging.getLogger("")
logger.setLevel(cfg.general.logLevel)
client = Client("", cfg.server.port, BetelbotClientConnection)
conn = client.connect()
driverServer = BetelbotDriverServer()
driverServer.listen(cfg.robot.driverPort)
driver = BetelbotDriver(cfg.robot.start, cfg.robot.dist, driverServer)
server = RobotServer(connection=RobotConnection, driver=driver, masterConn=conn)
server.listen(cfg.robot.port)
IOLoop.instance().start()
def main():
# Start up a Betelbot client and subscribe to all topics. When data is
# received, print to console.
#
# The main purpose of this script is for logging messages.
signal.signal(signal.SIGINT, signalHandler)
cfg = JsonConfig()
logger = logging.getLogger('')
logger.setLevel(cfg.general.logLevel)
client = Client('', cfg.server.port, BetelbotClientConnection)
conn = client.connect()
topics = getTopics()
for topic in topics:
conn.subscribe(topic, onTopicPublished)
IOLoop.instance().start()
def check_apic_interfaces(client: Client) -> State:
"""APIC interfaces state"""
# Verify operSt == 'up' for at least 2 ints in cnwPhysIf
apic_ints = defaultdict(set)
for record in client.get_class("cnwPhysIf"):
node_dn = get_node_dn(record["dn"])
if record.get("operSt", "") == "up":
apic_ints[node_dn].add(record["id"])
for dn, ints in apic_ints.items():
if len(ints) < 2:
log.warning("APIC {dn} has < 2 active interfaces")
return State.FAIL
return State.OK
def main():
signal.signal(signal.SIGINT, signalHandler)
cfg = JsonConfig()
openByte = cfg.map.open
grid = cv2.imread(cfg.mapData.grid, cv2.CV_LOAD_IMAGE_GRAYSCALE)
logger = logging.getLogger('')
logger.setLevel(cfg.general.logLevel)
pathfinder = Pathfinder(grid, openByte, euclideanDistance)
serverPort = cfg.pathfinder.port
client = Client('', cfg.server.port, BetelbotClientConnection)
conn = client.connect()
server = PathfinderServer(connection=PathfinderConnection,
masterConn=conn, pathfinder=pathfinder)
server.listen(serverPort)
IOLoop.instance().start()
def check_tcam_scale(client: Client) -> State:
"""per-leaf TCAM scale"""
# Verify polUsageCum <= polUsageCapCum for eqptcapacityPolUsage5min
over_limit = False
for record in client.get_class("eqptcapacityPolUsage5min"):
node_dn = get_node_dn(record["dn"])
count = get_path(int, record, "polUsageCum")
limit = get_path(int, record, "polUsageCapCum")
if count > 0 and count >= limit:
over_limit = True
log.warning(f"Over TCAM scale on {node_dn}",
count=count,
limit=limit)
if client.args["debug"]:
log.debug(f"TCAM scale on {node_dn}", count=count, limit=limit)
return State.FAIL if over_limit else State.OK
def check_backup(client: Client) -> State:
"""last backup status"""
# Verify executeTime is within last 24hrs for configJob
recent_backup = False
latest_backup = None
for backup in client.get_class("configJob"):
iso_backup_str = backup["executeTime"][:19]
this_backup_time = datetime.strptime(iso_backup_str,
"%Y-%m-%dT%H:%M:%S")
if latest_backup is None or this_backup_time > latest_backup:
latest_backup = this_backup_time
last_24hrs = datetime.now() - timedelta(hours=24)
if this_backup_time >= last_24hrs and backup["operSt"] == "success":
recent_backup = True
latest = "None" if latest_backup is None else latest_backup.isoformat()
if not recent_backup:
log.warning("Backup not performed within 24 hours", last_backup=latest)
return State.FAIL
elif client.args["debug"]:
log.debug("Last backup performed within 24 hours", last_backup=latest)
return State.OK
import unittest
import json
import uuid
from util import Client
client = Client('localhost', '8080')
class BaseTest(unittest.TestCase):
GAME_NAME = 'test-game'
PLAYER_USERNAME = '******'
@property
def client(self):
return client
def randomString(self):
return str(uuid.uuid4())
def setUp(self):
self.player_count = 0
self.delete_test_game()
self.delete_test_players()
def tearDown(self):
self.player_count = 0
self.delete_test_game()
self.delete_test_players()
def get_faults(client: Client) -> List[Dict[str, str]]:
"""Get current fault list"""
return client.get_class("faultInst")
def get_devices(client: Client) -> List[Dict[str, str]]:
"""Get current device list"""
return client.get_class("topSystem")
