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")