Exemplo n.º 1
0
    def get_client(self):
        """
        get_client returns a grpc client of the specified service in the cloud.
        it will return a recycled client until the client fails or the number
        of recycling reaches the max_client_use.
        """
        if self._client is None or \
                self._num_client_use > self._max_client_reuse:
            chan = ServiceRegistry.get_rpc_channel(
                self._service_name,
                ServiceRegistry.CLOUD,
            )
            self._client = self._service_stub(chan)
            self._num_client_use = 0

        self._num_client_use += 1
        return self._client
Exemplo n.º 2
0
    def get_magma_services_summary(self):
        """ Get health for all the running services """
        services_health_summary = []

        # DBus objects: https://www.freedesktop.org/wiki/Software/systemd/dbus/
        chan = ServiceRegistry.get_rpc_channel('magmad', ServiceRegistry.LOCAL)
        client = MagmadStub(chan)

        configs = client.GetConfigs(common_pb2.Void())

        service_names = [str(name) for name in configs.configs_by_key]
        services_errors = self.get_error_summary(service_names=service_names)

        for service_name in service_names:
            unit = Unit(
                'magma@{}.service'.format(service_name),
                _autoload=True,
            )
            active_state = ActiveState.dbus2state[unit.Unit.ActiveState]
            sub_state = str(unit.Unit.SubState, 'utf-8')
            if active_state == ActiveState.ACTIVE:
                pid = unit.Service.MainPID
                process = subprocess.Popen(
                    'ps -o etime= -p {}'.format(pid).split(),
                    stdout=subprocess.PIPE,
                )

                time_running, error = process.communicate()
                if error:
                    raise ValueError(
                        'Cannot get time running for the service '
                        '{} `ps -o etime= -p {}`'
                        .format(service_name, pid),
                    )
            else:
                time_running = b'00'

            services_health_summary.append(
                ServiceHealth(
                    service_name=service_name,
                    active_state=active_state, sub_state=sub_state,
                    time_running=str(time_running, 'utf-8').strip(),
                    errors=services_errors[service_name],
                ),
            )
        return services_health_summary
Exemplo n.º 3
0
    def _checkin(self, service_statusmeta):
        """
        if previous checkin is successful, create a new channel
        (to make sure the channel does't become stale). Otherwise,
        keep the existing channel.
        """
        if self._checkin_client is None:
            chan = ServiceRegistry.get_rpc_channel(
                    'checkind', ServiceRegistry.CLOUD)
            self._checkin_client = CheckindStub(chan)

        mconfig = self._service.mconfig
        cpu = psutil.cpu_times()
        mem = psutil.virtual_memory()
        try:
            gw_ip = get_ip_from_if('tun0')  # look for tun0 interface
        except ValueError:
            gw_ip = 'N/A'

        request = CheckinRequest(
            gateway_id=snowflake.snowflake(),
            magma_pkg_version=self._service.version,
            system_status=SystemStatus(
                cpu_user=int(cpu.user * 1000),  # convert second to millisecond
                cpu_system=int(cpu.system * 1000),
                cpu_idle=int(cpu.idle * 1000),
                mem_total=mem.total,
                mem_available=mem.available,
                mem_used=mem.used,
                mem_free=mem.free,
                uptime_secs=int(time.time() - self._boot_time),
            ),
            vpn_ip=gw_ip,
            kernel_version=self._kernel_version,
            kernel_versions_installed=self._kernel_versions_installed,
        )

        for statusmeta in service_statusmeta.values():
            request.status.meta.update(statusmeta)

        future = self._checkin_client.Checkin.future(
            request, mconfig.checkin_timeout,
        )
        future.add_done_callback(
            lambda f: self._loop.call_soon_threadsafe(self._checkin_done, f),
        )
Exemplo n.º 4
0
def set_mobilityd_gw_info(ip: IPAddress, mac: str, vlan: str):
    """
    Make RPC call to 'SetGatewayInfo' method of local mobilityD service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except ValueError:
        logging.error('Cant get RPC channel to %s', SERVICE_NAME)
        return

    client = MobilityServiceStub(chan)
    try:
        gwinfo = GWInfo(ip=ip, mac=mac, vlan=vlan)
        client.SetGatewayInfo(gwinfo)
    except grpc.RpcError as err:
        logging.error("SetGatewayInfo error[%s] %s", err.code(), err.details())
Exemplo n.º 5
0
def get_service303_client(service_name: str, location: str) \
        -> Optional[Service303Stub]:
    """
    get_service303_client returns a grpc client attached to the given service
    name and location.
    Example Use: client = get_service303_client("state", ServiceRegistry.LOCAL)
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(
            service_name,
            location,
        )
        return Service303Stub(chan)
    except ValueError:
        # Service can't be contacted
        logging.error('Failed to get RPC channel to %s', service_name)
        return None
Exemplo n.º 6
0
def get_all_enb_connected() -> Optional[List[int]]:
    """
    Make RPC call to 'GetEnbConnected' method of s1ap service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(S1AP_SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except ValueError:
        logger.error('Cant get RPC channel to %s', S1AP_SERVICE_NAME)
        return
    client = S1apServiceStub(chan)
    try:
        res = client.GetEnbConnected(Void(), DEFAULT_GRPC_TIMEOUT)
        return res.enb_ids
    except grpc.RpcError as err:
        logger.warning("GetEnbConnected error: [%s] %s", err.code(),
                       err.details())
    return []
Exemplo n.º 7
0
def get_mobilityd_gw_info() -> List[GWInfo]:
    """
    Make RPC call to 'GetGatewayInfo' method of local mobilityD service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except ValueError:
        logging.error('Cant get RPC channel to %s', SERVICE_NAME)
        return GWInfo()

    client = MobilityServiceStub(chan)
    try:
        return client.ListGatewayInfo(Void()).gw_list
    except grpc.RpcError as err:
        logging.error("ListGatewayInfo error[%s] %s", err.code(),
                      err.details())
        return []
Exemplo n.º 8
0
    async def _get_subscribers(self) -> List[IPAddress]:
        """
        Sends gRPC call to mobilityd to get all subscribers table.

        Returns: List of [Subscriber ID => IP address, APN] entries
        """
        try:
            mobilityd_chan = ServiceRegistry.get_rpc_channel(
                'mobilityd', ServiceRegistry.LOCAL)
            mobilityd_stub = MobilityServiceStub(mobilityd_chan)
            response = await grpc_async_wrapper(
                mobilityd_stub.GetSubscriberIPTable.future(
                    Void(), TIMEOUT_SECS), self._loop)
            return response.entries
        except grpc.RpcError as err:
            logging.error("GetSubscribers Error for %s! %s", err.code(),
                          err.details())
            return []
Exemplo n.º 9
0
def get_allocated_ips():
    chan = ServiceRegistry.get_rpc_channel('mobilityd', ServiceRegistry.LOCAL)
    client = MobilityServiceStub(chan)
    res = []

    list_blocks_resp = client.ListAddedIPv4Blocks(Void())
    for block_msg in list_blocks_resp.ip_block_list:

        list_ips_resp = client.ListAllocatedIPs(block_msg)
        for ip_msg in list_ips_resp.ip_list:
            if ip_msg.version == IPAddress.IPV4:
                ip = ipaddress.IPv4Address(ip_msg.address)
            elif ip_msg.address == IPAddress.IPV6:
                ip = ipaddress.IPv6Address(ip_msg.address)
            else:
                continue
            res.append(ip)
    return res
Exemplo n.º 10
0
def main():
    """ main() for subscriberdb """
    service = MagmaService('brokerd', mconfigs_pb2.BrokerD())

    # Add all servicers to the server
    chan = ServiceRegistry.get_rpc_channel('subscriberdb',
                                           ServiceRegistry.LOCAL)
    s6a_proxy_stub = S6aProxyStub(chan)
    brokerd_servicer = BrokerdRpcServicer(s6a_proxy_stub)
    brokerd_servicer.add_to_server(service.rpc_server)

    logging.info('brokerd is running!')

    # Run the service loop
    service.run()

    # Cleanup the service
    service.close()
Exemplo n.º 11
0
 def sync(self):
     """
     Synchronizes sample queue to cloud and reschedules sync loop
     """
     if self._samples:
         chan = ServiceRegistry.get_rpc_channel('metricsd',
                                                ServiceRegistry.CLOUD)
         client = MetricsControllerStub(chan)
         samples = self._retry_queue + self._samples
         metrics_container = MetricsContainer(
             gatewayId=snowflake.snowflake(), family=samples)
         future = client.Collect.future(metrics_container,
                                        self.grpc_timeout)
         future.add_done_callback(
             lambda future: self._loop.call_soon_threadsafe(
                 self.sync_done, samples, future))
         self._retry_queue.clear()
         self._samples.clear()
     self._loop.call_later(self.sync_interval, self.sync)
Exemplo n.º 12
0
    def _package_and_send_metrics(self, metrics: [metrics_pb2.MetricFamily],
                                  target: ScrapeTarget) -> None:
        """
        Send parsed and protobuf-converted metrics to cloud.
        """
        metrics_container = MetricsContainer(
            gatewayId=snowflake.snowflake(),
            family=metrics,
        )

        chan = ServiceRegistry.get_rpc_channel('metricsd',
                                               ServiceRegistry.CLOUD,
                                               grpc_options=self._grpc_options)

        client = MetricsControllerStub(chan)
        future = client.Collect.future(metrics_container, self.grpc_timeout)
        future.add_done_callback(
            lambda future: self._loop.call_soon_threadsafe(
                self.scrape_done, future, target))
Exemplo n.º 13
0
    def gateway_health_status(self):
        config = load_service_mconfig_as_json('mme')

        # eNB status for #eNBs connected
        chan = ServiceRegistry.get_rpc_channel('enodebd',
                                               ServiceRegistry.LOCAL)
        client = EnodebdStub(chan)
        status = client.GetStatus(Void())

        mme_log_path = '/var/log/mme.log'
        health_summary = AGWHealthSummary(
            relay_enabled=config['relayEnabled'],
            nb_enbs_connected=status.meta['n_enodeb_connected'],
            allocated_ips=self.get_allocated_ips(),
            subscriber_table=self.get_subscriber_table(),
            registration_success_rate=self.get_registration_success_rate(
                mme_log_path),
        )
        return health_summary
Exemplo n.º 14
0
    def detach_deleted_subscribers(self, old_sub_ids, new_sub_ids):
        """
        Compares current subscriber ids and new subscriber ids list
        just streamed from the cloud to figure out the deleted subscribers.
        Then send grpc DeleteSubscriber request to mme to detach all the
        deleted subscribers.
        :param old_sub_ids: a list of old subscriber ids in the store.
        :param new_sub_ids: a list of new active subscriber ids
                just streamed from the cloud
        :return: n/a
        """
        # THIS IS A HACK UNTIL WE FIX THIS ON CLOUD
        # We accept IMSIs with or without 'IMSI' prepended on cloud, but we
        # always store IMSIs on local subscriberdb with IMSI prepended. If the
        # cloud streams down subscriber IDs without 'IMSI' prepended,
        # subscriberdb will try to delete all of the subscribers from MME every
        # time it streams from cloud because the set membership will fail
        # when comparing '12345' to 'IMSI12345'.
        new_sub_ids = set(
            map(
                lambda s: 'IMSI' + s if not s.startswith('IMSI') else s,
                new_sub_ids,
            ), )
        deleted_sub_ids = [
            sub_id for sub_id in old_sub_ids if sub_id not in set(new_sub_ids)
        ]
        if len(deleted_sub_ids) == 0:
            return
        # send detach request to mme for all deleted subscribers.
        chan = ServiceRegistry.get_rpc_channel('s6a_service',
                                               ServiceRegistry.LOCAL)
        client = S6aServiceStub(chan)
        req = DeleteSubscriberRequest()

        # mme expects a list of IMSIs without "IMSI" prefix
        imsis_to_delete_without_prefix = [sub[4:] for sub in deleted_sub_ids]

        req.imsi_list.extend(imsis_to_delete_without_prefix)
        future = client.DeleteSubscriber.future(req)
        future.add_done_callback(
            lambda future: self._loop.call_soon_threadsafe(
                self.detach_deleted_subscribers_done, future))
Exemplo n.º 15
0
 def run(self):
     """
     This is executed when the thread is started. It gets a connection to
     the cloud dispatcher, and calls its bidirectional streaming rpc
     EstablishSyncRPCStream(). process_streams should never return, and
     if it did, exception will be logged, and new connection to dispatcher
     will be attempted after RETRY_DELAY_SECS seconds.
     """
     while True:
         try:
             start_time = time.time()
             chan = ServiceRegistry.get_rpc_channel(
                 'dispatcher',
                 ServiceRegistry.CLOUD,
             )
             client = SyncRPCServiceStub(chan)
             self._set_connect_time()
             self.process_streams(client)
         except grpc.RpcError as err:
             if is_grpc_error_retryable(err):
                 logging.warning(
                     "[SyncRPC] Transient gRPC error, retrying: %s",
                     err.details(),
                 )
                 self._retry_connect_sleep()
                 continue
             else:
                 logging.error(
                     "[SyncRPC] gRPC error: %s, reconnecting to cloud.",
                     err.details(),
                     extra=EXCLUDE_FROM_ERROR_MONITORING,
                 )
                 self._cleanup_and_reconnect()
         except Exception as exp:  # pylint: disable=broad-except
             conn_time = time.time() - start_time
             logging.error(
                 "[SyncRPC] Error after %ds: %s",
                 conn_time,
                 exp,
                 extra=EXCLUDE_FROM_ERROR_MONITORING,
             )
             self._cleanup_and_reconnect()
Exemplo n.º 16
0
async def test_checkin(proxy_cloud_connections=True):
    """Send checkin using either proxy or direct to cloud connection"""
    chan = ServiceRegistry.get_rpc_channel(
        'state',
        ServiceRegistry.CLOUD,
        proxy_cloud_connections=proxy_cloud_connections,
    )
    client = StateServiceStub(chan)

    # Construct a simple state to send for test
    value = json.dumps({"datetime": datetime.datetime.now()}, default=str)
    states = [
        State(type="string_map",
              deviceID=snowflake.snowflake(),
              value=value.encode('utf-8')),
    ]
    request = ReportStatesRequest(states=states)

    timeout = 1000
    await grpc_async_wrapper(client.ReportStates.future(request, timeout))
Exemplo n.º 17
0
 def collect(self, service_name):
     """
     Calls into Service303 to get service metrics samples and
     reschedule collection.
     """
     chan = ServiceRegistry.get_rpc_channel(
         service_name,
         ServiceRegistry.LOCAL,
     )
     client = Service303Stub(chan)
     future = client.GetMetrics.future(Void(), self.grpc_timeout)
     future.add_done_callback(
         lambda future:
         self._loop.call_soon_threadsafe(
             self.collect_done, service_name, future,
         ),
     )
     self._loop.call_later(
         self.collect_interval, self.collect,
         service_name,
     )
Exemplo n.º 18
0
def get_all_records(retries: int = 3, sleep_time: float = 0.1) -> [dict]:
    """
    Make RPC call to 'GetAllDirectoryRecords' method of local directoryD service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(DIRECTORYD_SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except ValueError:
        logging.error('Cant get RPC channel to %s', DIRECTORYD_SERVICE_NAME)
        return
    client = GatewayDirectoryServiceStub(chan)
    for _ in range(0, retries):
        try:
            res = client.GetAllDirectoryRecords(Void(), DEFAULT_GRPC_TIMEOUT)
            if res.records is not None:
                return res.records
            hub.sleep(sleep_time)
        except grpc.RpcError as err:
            logging.error("GetAllDirectoryRecords error! [%s] %s", err.code(),
                          err.details())
    return []
Exemplo n.º 19
0
def log_event(event: Event) -> None:
    """
    Make RPC call to 'LogEvent' method of local eventD service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(EVENTD_SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except ValueError:
        logging.error("Cant get RPC channel to %s", EVENTD_SERVICE_NAME)
        return
    client = EventServiceStub(chan)
    try:
        # Location will be filled in by directory service
        client.LogEvent(event, DEFAULT_GRPC_TIMEOUT)
    except grpc.RpcError as err:
        logging.error(
            "LogEvent error for event: %s, [%s] %s",
            MessageToDict(event),
            err.code(),
            err.details(),
        )
Exemplo n.º 20
0
def main():
    """ main() for ctraced """
    service = MagmaService('ctraced', CtraceD())

    # Optionally pipe errors to Sentry
    sentry_init()

    orc8r_chan = ServiceRegistry.get_rpc_channel('ctraced',
                                                 ServiceRegistry.CLOUD)
    ctraced_stub = CallTraceControllerStub(orc8r_chan)

    trace_manager = TraceManager(service.config, ctraced_stub)

    ctraced_servicer = CtraceDRpcServicer(trace_manager)
    ctraced_servicer.add_to_server(service.rpc_server)

    # Run the service loop
    service.run()

    # Cleanup the service
    service.close()
Exemplo n.º 21
0
def _load_subs(num_subs: int) -> List[DirectoryRecord]:
    """Load directory records"""
    client = GatewayDirectoryServiceStub(
        ServiceRegistry.get_rpc_channel(
            DIRECTORYD_SERVICE_NAME,
            ServiceRegistry.LOCAL,
        ), )
    sids = []
    for i in range(num_subs):
        mac_addr = (str(i) * 2 + ":") * 5 + (str(i) * 2)
        ipv4_addr = str(i) * 3 + "." + str(i) * 3 + "." + str(
            i) * 3 + "." + str(i) * 3
        fields = {"mac-addr": mac_addr, "ipv4_addr": ipv4_addr}
        sid = UpdateRecordRequest(
            fields=fields,
            id=str(i).zfill(15),
            location=str(i).zfill(15),
        )
        client.UpdateRecord(sid)
        sids.append(sid)
    return sids
Exemplo n.º 22
0
    def test_service_run(self, mock_get_proxy_config):
        """
        Test if the service starts and stops gracefully.
        """

        self.assertEqual(self._service.state, ServiceInfo.STARTING)

        mock_get_proxy_config.return_value = {
            'cloud_address': '127.0.0.1',
            'proxy_cloud_connections': True,
        }

        # Start the service and pause the loop
        self._service.loop.stop()
        self._service.run()
        asyncio.set_event_loop(self._service.loop)
        self._service.log_counter._periodic_task.cancel()
        self.assertEqual(self._service.state, ServiceInfo.ALIVE)

        # Create a rpc stub and query the Service303 interface
        ServiceRegistry.add_service('test', '0.0.0.0', self._service.port)
        channel = ServiceRegistry.get_rpc_channel(
            'test',
            ServiceRegistry.LOCAL,
        )
        self._stub = Service303Stub(channel)

        info = ServiceInfo(
            name='test',
            version='0.0.0',
            state=ServiceInfo.ALIVE,
            health=ServiceInfo.APP_HEALTHY,
            start_time_secs=12345,
        )
        self.assertEqual(self._stub.GetServiceInfo(Void()), info)

        # Stop the service
        self._stub.StopService(Void())
        self._service.loop.run_forever()
        self.assertEqual(self._service.state, ServiceInfo.STOPPED)
Exemplo n.º 23
0
 async def _get_service_info(self):
     """
     Make RPC calls to 'GetServiceInfo' functions of other services, to
     get current status.
     """
     for service in list(self._service_info):
         # Check whether service provides service303 interface
         if service in self._config['non_service303_services']:
             continue
         try:
             chan = ServiceRegistry.get_rpc_channel(
                 service,
                 ServiceRegistry.LOCAL,
             )
         except ValueError:
             # Service can't be contacted
             logging.error('Cant get RPC channel to %s', service)
             continue
         client = Service303Stub(chan)
         try:
             future = client.GetServiceInfo.future(
                 Void(),
                 self.GET_STATUS_TIMEOUT,
             )
             info = await grpc_async_wrapper(future, self._loop)
             self._service_info[service].update(
                 info.start_time_secs,
                 info.status,
             )
             self._service_info[service].continuous_timeouts = 0
         except grpc.RpcError as err:
             logging.error(
                 "GetServiceInfo Error for %s! [%s] %s",
                 service,
                 err.code(),
                 err.details(),
                 extra=EXCLUDE_FROM_ERROR_MONITORING
                 if indicates_connection_error(err) else None,
             )
             self._service_info[service].continuous_timeouts += 1
Exemplo n.º 24
0
def activate_he_urls_for_ue(
    ip: IPAddress,
    rule_id: str,
    urls: List[str],
    imsi: str,
    msisdn: str,
) -> bool:
    """
    Make RPC call to 'Envoy Controller' to add target URLs to envoy datapath.
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(
            SERVICE_NAME,
            ServiceRegistry.LOCAL,
        )
    except grpc.RpcError:
        logging.error('Cant get RPC channel to %s', SERVICE_NAME)
        return False

    client = EnvoyControllerStub(chan)
    try:
        headers = [Header(name=IMSI_HDR, value=imsi)]
        if msisdn:
            headers.append(Header(name=MSISDN_HDR, value=msisdn))
        he_info = AddUEHeaderEnrichmentRequest(
            ue_ip=ip,
            rule_id=rule_id,
            websites=urls,
            headers=headers,
        )
        ret = client.AddUEHeaderEnrichment(he_info, timeout=TIMEOUT_SEC)
        return ret.result == AddUEHeaderEnrichmentResult.SUCCESS
    except grpc.RpcError as err:
        logging.error(
            "Activate HE proxy error[%s] %s",
            err.code(),
            err.details(),
        )

    return False
Exemplo n.º 25
0
    def sync(self, service_name):
        """
        Synchronizes sample queue for specific service to cloud and reschedules
        sync loop
        """
        if service_name in self._samples_for_service and \
           self._samples_for_service[service_name]:
            chan = ServiceRegistry.get_rpc_channel(
                'metricsd',
                ServiceRegistry.CLOUD,
                grpc_options=self._grpc_options,
            )
            client = MetricsControllerStub(chan)
            if self.post_processing_fn:
                # If services wants to, let it run a postprocessing function
                # If we throw an exception here, we'll have no idea whether
                # something was postprocessed or not, so I guess try and make it
                # idempotent?  #m sevchicken
                self.post_processing_fn(
                    self._samples_for_service[service_name],
                )

            samples = self._samples_for_service[service_name]
            sample_chunks = self._chunk_samples(samples)
            for idx, chunk in enumerate(sample_chunks):
                metrics_container = MetricsContainer(
                    gatewayId=snowflake.snowflake(),
                    family=chunk,
                )
                future = client.Collect.future(
                    metrics_container,
                    self.grpc_timeout,
                )
                future.add_done_callback(
                    self._make_sync_done_func(
                        service_name, idx,
                    ),
                )
            self._samples_for_service[service_name].clear()
        self._loop.call_later(self.sync_interval, self.sync, service_name)
Exemplo n.º 26
0
    async def get_ping_targets(self, service_loop) -> PingedTargets:
        """
        Sends gRPC call to mobilityd to get all subscribers table.

        Returns: List of [Subscriber ID => IP address, APN] entries
        """

        try:
            mobilityd_chan = ServiceRegistry.get_rpc_channel(
                'mobilityd', ServiceRegistry.LOCAL)
            mobilityd_stub = MobilityServiceStub(mobilityd_chan)
            response = await grpc_async_wrapper(
                mobilityd_stub.GetSubscriberIPTable.future(Void(), 10),
                service_loop)
            for sub in response.entries:
                ip = _get_addr_from_subscribers(sub.ip)
                self.ping_addresses.append(ip)
                self.ping_targets[sub.sid.id] = ip
        except grpc.RpcError as err:
            logging.error("GetSubscribers Error for %s! %s", err.code(),
                          err.details())
        return PingedTargets(self.ping_targets, self.ping_addresses)
Exemplo n.º 27
0
def update_record(imsi: str, ip_addr: str) -> None:
    """
    Make RPC call to 'UpdateRecord' method of local directoryD service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(DIRECTORYD_SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except ValueError:
        logging.error('Cant get RPC channel to %s', DIRECTORYD_SERVICE_NAME)
        return
    client = GatewayDirectoryServiceStub(chan)
    if not imsi.startswith("IMSI"):
        imsi = "IMSI" + imsi
    try:
        # Location will be filled in by directory service
        req = UpdateRecordRequest(id=imsi, location="hwid")
        req.fields[IPV4_ADDR_KEY] = ip_addr
        client.UpdateRecord(req, DEFAULT_GRPC_TIMEOUT)
    except grpc.RpcError as err:
        logging.error(
            "UpdateRecordRequest error for id: %s, ipv4_addr: %s! [%s] %s",
            imsi, ip_addr, err.code(), err.details())
Exemplo n.º 28
0
 def run(self):
     """
     This is executed when the thread is started. It gets a connection to
     the cloud dispatcher, and calls its bidirectional streaming rpc
     EstablishSyncRPCStream(). process_streams should never return, and
     if it did, exception will be logged, and new connection to dispatcher
     will be attempted after RETRY_DELAY_SECS seconds.
     """
     while True:
         try:
             start_time = time.time()
             chan = ServiceRegistry.get_rpc_channel('dispatcher',
                                                    ServiceRegistry.CLOUD)
             client = SyncRPCServiceStub(chan)
             self._set_connect_time()
             self.process_streams(client)
         except Exception as exp:  # pylint: disable=broad-except
             conn_time = time.time() - start_time
             logging.error("[SyncRPC] Error after %ds: %s", conn_time, exp)
         # If the connection is terminated, wait for a period of time
         # before connecting back to the cloud.
         self._retry_connect_sleep()
Exemplo n.º 29
0
def set_he_urls_for_ue(ip: str, urls: List[str], imsi: str, msisdn: str):
    """
    Make RPC call to 'SetGatewayInfo' method of local mobilityD service
    """

    try:
        chan = ServiceRegistry.get_rpc_channel(SERVICE_NAME,
                                               ServiceRegistry.LOCAL)
    except grpc.RpcError:
        logging.error('Cant get RPC channel to %s', SERVICE_NAME)
        return

    client = EnvoyControllerStub(chan)
    try:
        h1 = {IMSI_HDR: imsi}
        h2 = {MSISDN_HDR: msisdn}

        he_info = AddUEHeaderEnrichmentRequest(ue_ip=ip,
                                               websites=urls,
                                               headers=[h1, h2])
        client.AddUEHeaderEnrichment(he_info)
    except grpc.RpcError as err:
        logging.error("SetGatewayInfo error[%s] %s", err.code(), err.details())
Exemplo n.º 30
0
def get_cbsd_state(request: CBSDRequest) -> CBSDStateResult:
    """
    Make RPC call to 'GetCBSDState' method of dp service
    """
    try:
        chan = ServiceRegistry.get_rpc_channel(
            DP_SERVICE_NAME,
            ServiceRegistry.CLOUD,
        )
    except ValueError:
        logger.error('Cant get RPC channel to %s', DP_SERVICE_NAME)
        return CBSDStateResult(radio_enabled=False)
    client = DPServiceStub(chan)
    try:
        res = client.GetCBSDState(request, DEFAULT_GRPC_TIMEOUT)
    except grpc.RpcError as err:
        logger.warning(
            "GetCBSDState error: [%s] %s",
            err.code(),
            err.details(),
        )
        return CBSDStateResult(radio_enabled=False)
    return res