def do_logical_devices(self, line): """List logical devices in Voltha""" stub = self.get_stub() res = stub.ListLogicalDevices(Empty()) omit_fields = { 'desc.mfr_desc', 'desc.hw_desc', 'desc.sw_desc', 'desc.dp_desc', 'desc.serial_number', 'switch_features.capabilities' } print_pb_list_as_table('Logical devices:', res.items, omit_fields, self.poutput)
def test_delete_success(self): from google.protobuf.empty_pb2 import Empty client = _Client() api = client.table_admin_client = self._make_table_admin_client() api.delete_backup.return_value = Empty() instance = _Instance(self.INSTANCE_NAME, client=client) backup = self._make_one(self.BACKUP_ID, instance, cluster_id=self.CLUSTER_ID) backup.delete() api.delete_backup.assert_called_once_with(self.BACKUP_NAME)
def test_delete_success(self): from google.protobuf.empty_pb2 import Empty client = _Client(self.PROJECT) api = client.instance_admin_api = _FauxInstanceAdminAPI( _delete_instance_response=Empty()) instance = self._make_one(self.INSTANCE_ID, client, self.CONFIG_NAME) instance.delete() name, metadata = api._deleted_instance self.assertEqual(name, self.INSTANCE_NAME) self.assertEqual(metadata, [("google-cloud-resource-prefix", instance.name)])
def get_claw_aio(self, pin: str) -> float: """ 获取手爪参数 :param pin: 'force':手爪力,'weight':手爪重量 :return: 根据参数,获取手爪力或者重量 示例: >>> claw_force = self.get_claw_aio("force") >>> claw_weight = self.get_claw_aio("weight") """ self._sync() pin = pin.lower() if pin == 'force': res = self.rcs.GetClawHoldOn(Empty()) return res.hold_on elif pin == 'weight': res = self.rcs.GetClawWeight(Empty()) return res.weight else: # pin == 'amplitude': res = self.rcs.GetClawAmplitude(Empty()) return res.amplitude
def test_SubmitOrder( trading, tradingdata, walletClientWalletKeypair # noqa: F811 ): (walletclient, _, _, pubKey) = walletClientWalletKeypair # noqa: F811 # Get a market req = vac.api.trading.MarketByIDRequest(market_id="076BB86A5AA41E3E") market = tradingdata.MarketByID(req).market # Prepare the SubmitOrder now = int(tradingdata.GetVegaTime(Empty()).timestamp) request = vac.api.trading.PrepareSubmitOrderRequest( submission=vac.vega.OrderSubmission( expires_at=now + 120000000000, market_id=market.id, party_id=pubKey, price=10, side=vac.vega.Side.SIDE_BUY, size=1, time_in_force=vac.vega.Order.TimeInForce.TIME_IN_FORCE_GTT, type=vac.vega.Order.Type.TYPE_LIMIT, reference=str(uuid.uuid4()), )) # Either: Prepare the SubmitOrder using the Vega node # blob = trading.PrepareSubmitOrder(request, contact_node=True).blob # Or: Prepare the SubmitOrder ourselves blob = trading.PrepareSubmitOrder(request, contact_node=False).blob # Sign the tx r = walletclient.signtx( base64.b64encode(blob).decode("ascii"), pubKey, False) check_response(r) signedTx = r.json()["signedTx"] # Submit the signed transaction # assert blob == base64.b64decode(signedTx["data"]) request = vac.api.trading.SubmitTransactionRequest( tx=vac.vega.SignedBundle( tx=base64.b64decode(signedTx["tx"]), sig=vac.vega.Signature( sig=base64.b64decode(signedTx["sig"]["sig"]), algo=signedTx["sig"]["algo"], version=signedTx["sig"]["version"], ), )) response = trading.SubmitTransaction(request) assert response.success
def set_config(self, camera_config, ctx): if camera_config.HasField("sampling"): if camera_config.sampling.HasField("frequency"): self.driver.set_sampling_rate( camera_config.sampling.frequency.value) if camera_config.sampling.HasField("delay"): self.driver.set_delay(camera_config.sampling.delay.value) if camera_config.HasField("image"): if camera_config.image.HasField("resolution"): self.driver.set_resolution(camera_config.image.resolution) if camera_config.image.HasField("format"): self.driver.set_image_format(camera_config.image.format) if camera_config.image.HasField("color_space"): self.driver.set_color_space( camera_config.image.color_space.value) if camera_config.image.HasField("region"): self.driver.set_region_of_interest(camera_config.image.region) if camera_config.HasField("camera"): if camera_config.camera.HasField("brightness"): self.driver.set_brightness(camera_config.camera.brightness) if camera_config.camera.HasField("exposure"): self.driver.set_exposure(camera_config.camera.exposure) if camera_config.camera.HasField("focus"): self.driver.set_focus(camera_config.camera.focus) if camera_config.camera.HasField("gain"): self.driver.set_gain(camera_config.camera.gain) if camera_config.camera.HasField("gamma"): self.driver.set_gamma(camera_config.camera.gamma) if camera_config.camera.HasField("hue"): self.driver.set_hue(camera_config.camera.hue) if camera_config.camera.HasField("iris"): self.driver.set_iris(camera_config.camera.iris) if camera_config.camera.HasField("saturation"): self.driver.set_saturation(camera_config.camera.saturation) if camera_config.camera.HasField("sharpness"): self.driver.set_sharpness(camera_config.camera.sharpness) if camera_config.camera.HasField("shutter"): self.driver.set_shutter(camera_config.camera.shutter) if camera_config.camera.HasField("white_balance_bu"): self.driver.set_white_balance_bu( camera_config.camera.white_balance_bu) if camera_config.camera.HasField("white_balance_rv"): self.driver.set_white_balance_rv( camera_config.camera.white_balance_rv) if camera_config.camera.HasField("zoom"): self.driver.set_zoom(camera_config.camera.zoom) return Empty()
def test_drop_success(self): from google.protobuf.empty_pb2 import Empty client = _Client() api = client.database_admin_api = _FauxDatabaseAdminAPI( _drop_database_response=Empty()) instance = _Instance(self.INSTANCE_NAME, client=client) pool = _Pool() database = self._makeOne(self.DATABASE_ID, instance, pool=pool) database.drop() name, options = api._dropped_database self.assertEqual(name, self.DATABASE_NAME) self.assertEqual(options.kwargs['metadata'], [('google-cloud-resource-prefix', database.name)])
def run(): channel = grpc.insecure_channel('localhost:50055') # Test fetch the schema stub = schema_pb2.SchemaServiceStub(channel) res = stub.GetSchema(Empty()) print '\nSchema:\n' for key in res.protos: print '%s %s file begins %s\n' % (30 * '~', key, (35 - len(key)) * '~') print res.protos[key] print '%s %s file ends %s' % (30 * '~', key, (37 - len(key)) * '~') for key in res.descriptors: print '%s -> descriptor of %d bytes' % (key, len(res.descriptors[key])) # Ping health state as an example stub = voltha_pb2.HealthServiceStub(channel) res = stub.GetHealthStatus(Empty()) print '\nHealth state:', res.state # Try another API stub = voltha_pb2.ExampleServiceStub(channel) res = stub.ListAddresses(Empty()) print '\nExample objects returned:\n', res.addresses
def __init__(self, stub: FmuServiceStub, model_description, integrator=None): self.stub = stub self.model_description = model_description if integrator is None: self.fmu_id = self.stub.CreateInstanceFromCS(Empty()).value else: self.fmu_id = self.stub.CreateInstanceFromME(integrator).value self.model_variables = dict() for v in self.model_description.model_variables: self.model_variables[v.value_reference] = v
def get_copy_of_latest_data( self) -> (PayoffTable, List[List[int]], List[List[int]]): request = Empty() response: P2SROStatusResponse = self._stub.GetCopyOfLatestData(request) payoff_table = PayoffTable.from_json_string( json_string=response.payoff_table_json) active_policies_per_player = [] fixed_policies_per_player = [] for active_list, fixed_list in zip(response.active_policies, response.fixed_policies): active_policies_per_player.append(active_list.policies) fixed_policies_per_player.append(fixed_list.policies) return payoff_table, active_policies_per_player, fixed_policies_per_player
def test_delete_success(self): from google.protobuf.empty_pb2 import Empty client = _Client() api = client.database_admin_api = self._make_database_admin_api() api.delete_backup.return_value = Empty() instance = _Instance(self.INSTANCE_NAME, client=client) backup = self._make_one(self.BACKUP_ID, instance) backup.delete() api.delete_backup.assert_called_once_with( name=self.BACKUP_NAME, metadata=[("google-cloud-resource-prefix", backup.name)], )
def remove_item( state: ShoppingCartState, item: RemoveLineItem, ctx: EventSourcedCommandContext ): cart = state.cart if item.product_id not in cart: ctx.fail( "Cannot remove item {} because it is not in the cart.".format( item.product_id ) ) else: item_removed_event = ItemRemoved() item_removed_event.productId = item.product_id ctx.emit(item_removed_event) return Empty()
def test_get_all_appointments_responder(clear_state, internal_api, generate_dummy_tracker, stub): # Data is pulled straight from the database, so we need to feed some tracker = generate_dummy_tracker() uuid = uuid4().hex internal_api.watcher.db_manager.store_responder_tracker( uuid, tracker.to_dict()) response = stub.get_all_appointments(Empty()) appointments = dict(response.appointments) assert len(appointments.get("watcher_appointments")) == 0 and len( appointments.get("responder_trackers")) == 1 assert dict( appointments.get("responder_trackers")[uuid]) == tracker.to_dict()
def UpdateLogicalDeviceFlowGroupTable(self, request, context): log.info('grpc-request', request=request) try: instance_id = self.dispatcher.instance_id_by_logical_device_id( request.id) except KeyError: context.set_details('Logical device \'{}\' not found'.format( request.id)) context.set_code(StatusCode.NOT_FOUND) return Empty() return self.dispatcher.dispatch(instance_id, VolthaLocalServiceStub, 'UpdateLogicalDeviceFlowGroupTable', request, context)
def list_logical_devices(self): """ Return the list of logical devices. :return: list of logical devices as exposed by VOLTHA :except: ConnectionException if VOLTHA is unreachable, otherwise VolthaException if any other RpcError """ try: devs = self._get_stub().ListLogicalDevices(Empty(), timeout=self._timeout) return devs.items except grpc.RpcError as e: self._manage_std_conn_error(e) raise VolthaException( "Failed to retrieve logical devices from VOLTHA (%s, %s)" % (e.code(), e.details()))
def setAppConfigVal(self, request, context): """Set an app config value.""" self._log_request(request, context) # get the app config setting for val_type in ("strVal", "intVal", "boolVal"): if request.HasField(val_type): key, val = request.key, getattr(request, val_type) _logger.debug("- Setting app config: %s = %s (%s)", key, str(val), type(val).__name__) if isinstance(val, str): val = val.replace( "{{TEMP_DIR}}", self._temp_dir.name ) \ .replace( "{{FIXTURES_DIR}}", _FIXTURES_DIR ) self._webapp.config[key] = val return Empty() raise RuntimeError("Can't find app config key.")
def AcknowledgeCbsdUpdate(self, request: AcknowledgeCbsdUpdateRequest, context) -> Empty: """ Mark CBSD in the Database as not updated Parameters: request: a AcknowledgeCbsdUpdateRequest gRPC Message context: gRPC context Returns: Empty: an empty gRPC message """ db_id = request.id logger.info(f"Acknowledging CBSD update {db_id}") updated = self._update_cbsd(db_id, {'should_deregister': False}) if not updated: context.set_code(grpc.StatusCode.NOT_FOUND) return Empty()
async def main(): async with purerpc.insecure_channel("localhost", 50051) as channel: stub = ChallengeStub(channel) challenge = await stub.create(ChallengeRequest(name='Mr. Easy')) print(challenge.id, challenge.name) async def challenge_requests(name): for i in range(2): yield ChallengeRequest(name=f'({i} {name}') async for challenge in stub.bulk_create( challenge_requests('Mr. Bulk Easy')): print(challenge.id, challenge.name) async for challenge in stub.list(Empty()): print(challenge.id, challenge.name)
def setVehOrdNotesDir(self, request, context): """Set the vehicle/ordnance notes directory.""" self._log_request(request, context) dtype = request.dirType # set the vehicle/ordnance notes directory if dtype == SetVehOrdNotesDirRequest.DirType.NONE: #pylint: disable=no-member dname = None elif dtype == SetVehOrdNotesDirRequest.DirType.REAL: #pylint: disable=no-member dname = _ORIG_CHAPTER_H_NOTES_DIR elif dtype == SetVehOrdNotesDirRequest.DirType.TEST: #pylint: disable=no-member dname = os.path.join(_FIXTURES_DIR, "vo-notes") else: raise RuntimeError( "Invalid vehicle/ordnance notes dir.type: {}".format(dtype)) _logger.debug("- Setting vehicle/ordnance notes: %s", dname) self._webapp.config["CHAPTER_H_NOTES_DIR"] = dname return Empty()
def test_get_all_appointments_responder(internal_api, stub, generate_dummy_tracker, monkeypatch): # Mock data being only present in the Watcher local_trackers = {uuid4().hex: generate_dummy_tracker().to_dict()} monkeypatch.setattr(internal_api.watcher, "get_all_watcher_appointments", lambda: {}) monkeypatch.setattr(internal_api.watcher, "get_all_responder_trackers", lambda: local_trackers) # Get the response and cast it to dict response = stub.get_all_appointments(Empty()) assert isinstance(response, GetAllAppointmentsResponse) appointments = json_format.MessageToDict(response.appointments) assert len(appointments.get("watcher_appointments")) == 0 for uuid, tracker in local_trackers.items(): assert dict(appointments.get("responder_trackers")[uuid]) == tracker
def test_get_tower_info(internal_api, stub, monkeypatch): monkeypatch.setattr(internal_api.watcher.gatekeeper, "registered_users", {"uid1": {}}) monkeypatch.setattr( internal_api.watcher, "appointments", { "uid1": { "locator": "locator1", "user_id": "user_id1" }, "uid2": { "locator": "locator2", "user_id": "user_id2" }, }, ) monkeypatch.setattr( internal_api.watcher.responder, "trackers", { "uid1": { "penalty_txid": "txid1", "locator": "locator1", "user_id": "user_id1" }, "uid2": { "penalty_txid": "txid2", "locator": "locator2", "user_id": "user_id2" }, "uid3": { "penalty_txid": "txid3", "locator": "locator2", "user_id": "user_id3" }, }, ) response = stub.get_tower_info(Empty()) assert isinstance(response, GetTowerInfoResponse) assert response.tower_id == Cryptographer.get_compressed_pk( internal_api.watcher.signing_key.public_key) assert response.n_registered_users == 1 assert response.n_watcher_appointments == 2 assert response.n_responder_trackers == 3
def StoreAvailableFrequencies(self, request: StoreAvailableFrequenciesRequest, context) -> Empty: """ Store available frequencies in the database Parameters: request: StoreAvailableFrequencies gRPC Message context: gRPC context Returns: Empty: an empty gRPC message """ db_id = request.id logger.info(f"Storing available frequencies for {db_id}") updated = self._update_cbsd(db_id, {"available_frequencies": list(request.available_frequencies)}) if not updated: context.set_code(grpc.StatusCode.NOT_FOUND) return Empty()
def test_get_users(internal_api, stub, monkeypatch): # Mock user data (doesn't matter it's not properly formatted for the sake of the test) mock_users = ["user1", "user2", "user3"] monkeypatch.setattr( internal_api.watcher, "get_registered_user_ids", lambda: { "user1": dict(), "user2": dict(), "user3": dict() }, ) # Check we receive the same list of users response = stub.get_users(Empty()) assert isinstance(response, GetUsersResponse) assert response.user_ids == mock_users
def _setup_joints(self): joint_stub = joint_pb2_grpc.JointServiceStub(self._grpc_channel) joint_ids = joint_stub.GetAllJointsId(Empty()) self._joint_uid_to_name = dict(zip(joint_ids.uids, joint_ids.names)) self._joint_name_to_uid = dict(zip(joint_ids.names, joint_ids.uids)) req = joint_pb2.JointsStateRequest( ids=[joint_pb2.JointId(uid=uid) for uid in joint_ids.uids], requested_fields=[joint_pb2.JointField.ALL], ) joints_state = joint_stub.GetJointsState(req) for joint_id, joint_state in zip(joints_state.ids, joints_state.states): joint = Joint(joint_state) self._joints.append(joint)
def do_logical_devices(self, line): """List logical devices in Voltha""" stub = self.get_stub() res = stub.ListLogicalDevices(Empty()) omit_fields = { 'desc.mfr_desc', 'desc.hw_desc', 'desc.sw_desc', 'desc.dp_desc', 'desc.serial_number', 'switch_features.capabilities' } presfns = { 'datapath_id': lambda x: "{0:0{1}x}".format(int(x), 16) } print_pb_list_as_table('Logical devices:', res.items, omit_fields, self.poutput, presfns=presfns)
def _get_xpon_object_grpc(self, stub, obj_type, device_id=None): if obj_type["type"] == "channel_groups": res = stub.GetAllChannelgroupConfig(Empty()) elif obj_type["type"] == "channel_partitions": res = stub.GetAllChannelpartitionConfig(Empty()) elif obj_type["type"] == "channel_pairs": res = stub.GetAllChannelpairConfig(Empty()) elif obj_type["type"] == "channel_terminations": res = stub.GetAllChannelterminationConfig( voltha_pb2.ID(id=device_id)) elif obj_type["type"] == "v_ont_anis": res = stub.GetAllVOntaniConfig(Empty()) elif obj_type["type"] == "ont_anis": res = stub.GetAllOntaniConfig(Empty()) elif obj_type["type"] == "v_enets": res = stub.GetAllVEnetConfig(Empty()) elif obj_type["type"] == "gemports": res = stub.GetAllGemportsConfigData(Empty()) elif obj_type["type"] == "tconts": res = stub.GetAllTcontsConfigData(Empty()) elif obj_type["type"] == "traffic_descriptor_profiles": res = stub.GetAllTrafficDescriptorProfileData(Empty()) return res
def create_response(self, response_data: ErrorResponseData, protocol: ProtocolType, context: Context): headers = {"x-request-id": context.request_id} if protocol == ProtocolType.MSGPACK: content_type = "application/x-msgpack" content = msgpack.dumps(response_data) headers = {} elif protocol == ProtocolType.JSON: content_type = "application/json" content = json.dumps(response_data) headers = {} elif protocol == ProtocolType.PROTOBUF: content_type = "application/protobuf" content = Empty().SerializeToString() headers.update({"ERROR_CODE": response_data["error"], "ERROR_MESSAGE": response_data["message"]}) else: raise ValueError(f"Unknown protocol: {protocol}") return Response(content, content_type=content_type, headers=headers)
def get_onus(self, olt_id): """ Query VOLTHA to get a list of ONUs attached to a particular OLT """ onus = [] stub = self.get_stub() devices = stub.ListDevices(Empty()) for device in devices.items: if device.parent_id != olt_id: continue if device.parent_port_no is None: continue onus.append({"id": olt_id, "onu_device_id": device.id, "intf_id": str(device.parent_port_no & 0x0F)}) return onus
def get_manager_stats(self, infinite_retry_on_error: bool = True): while True: try: request = Empty() response: ManagerStats = self._stub.GetManagerStats(request) break except grpc.RpcError as err: if infinite_retry_on_error: logger.warning( f"grpc.RPCError raised while getting manager stats:\n{err}\n" f"(retrying in {_INFINITE_RETRY_INTERVAL_SECONDS} seconds)" ) time.sleep(_INFINITE_RETRY_INTERVAL_SECONDS) else: raise stats_dict = json.loads(response.manager_stats_json) return stats_dict
def get_list_of_logical_devices_from_voltha(self): while True: log.info('Retrieve devices from voltha') try: stub = voltha_pb2.VolthaLocalServiceStub(self.channel) devices = stub.ListLogicalDevices(Empty()).items for device in devices: log.info("Devices {} -> {}".format(device.id, device.datapath_id)) returnValue(devices) except Exception as e: log.error('Failure to retrieve devices from ' 'voltha: {}'.format(repr(e))) log.info('reconnect', after_delay=self.voltha_retry_interval) yield asleep(self.voltha_retry_interval)