def __init__(self,
host,
port,
timeout,
user,
password,
creds=None,
options=None):
""":param user: Username for device login
:param password: Password for device login
:param host: The ip address for the device
:param port: The port for the device
:param timeout: how long before the rpc call timesout
:param creds: Input of the pem file
:param options: TLS server name
:type password: str
:type user: str
:type host: str
:type port: int
:type timeout:int
:type creds: str
:type options: str
"""
if creds != None:
self._target = '%s:%d' % (host, port)
self._creds = grpc.ssl_channel_credentials(creds)
self._options = options
channel = grpc.secure_channel(self._target, self._creds, ((
'grpc.ssl_target_name_override',
self._options,
), ))
self._channel = grpc.Channel(channel)
else:
self._host = host
self._port = port
self._channel = grpc.insecure_channel(
str(self._host) + ":" + str(self._port))
self._stub = mdt_grpc_dialin_pb2_grpc.gRPCConfigOperStub(self._channel)
self._timeout = float(timeout)
self._metadata = [('username', user), ('password', password)]
#
# Setup the GRPC channel with the server, and issue RPCs
#
if __name__ == '__main__':
server_ip, server_port = get_server_ip_port()
print("Using GRPC Server IP(%s) Port(%s)" % (server_ip, server_port))
# Create the channel for gRPC.
channel = grpc.insecure_channel(str(server_ip) + ":" + str(server_port))
unmarshal = True
# Ereate the gRPC stub.
stub = mdt_grpc_dialin_pb2_grpc.gRPCConfigOperStub(channel)
metadata = [('username', 'vagrant'), ('password', 'vagrant')]
Timeout = 3600 * 24 * 365 # Seconds
sub_args = mdt_grpc_dialin_pb2.CreateSubsArgs(ReqId=99,
encode=4,
subidstr='1')
stream = stub.CreateSubs(sub_args, timeout=Timeout, metadata=metadata)
for segment in stream:
if not unmarshal:
print(segment)
else:
# Go straight for telemetry data
telemetry_pb = telemetry_pb2.Telemetry()
def run(self):
server_ip = "192.168.123.12"
server_port = "57777"
xr_user = "******"
xr_passwd = "root"
print("Using GRPC Server IP(%s) Port(%s)" % (server_ip, server_port))
channel = grpc.insecure_channel(
str(server_ip) + ":" + str(server_port))
stub = mdt_grpc_dialin_pb2_grpc.gRPCConfigOperStub(channel)
metadata = [('username', xr_user), ('password', xr_passwd)]
Timeout = 3600 * 24 * 365
sub_args = mdt_grpc_dialin_pb2.CreateSubsArgs(ReqId=99,
encode=2,
subidstr='IPV6')
stream = stub.CreateSubs(sub_args, timeout=Timeout, metadata=metadata)
print("##########1")
for segment in stream:
telemetry_pb = telemetry_pb2.Telemetry()
telemetry_pb.ParseFromString(segment.data)
telemetry_gpb_table = telemetry_pb2.TelemetryGPBTable()
telemetry_gpb_table.CopyFrom(telemetry_pb.data_gpb)
gpb_rows = []
print("##########2")
while (len(telemetry_gpb_table.row)):
gpb_row_dict = {}
gpb_row_dict["keys"] = {}
gpb_row_dict["content"] = {}
telemetry_gpb_row = telemetry_pb2.TelemetryRowGPB()
telemetry_gpb_row.CopyFrom(telemetry_gpb_table.row.pop())
gpb_row_dict["timestamp"] = telemetry_gpb_row.timestamp
ipv6_nd_neighbor_entry_keys = ipv6_nd_neighbor_entry_KEYS()
ipv6_nd_neighbor_entry_keys.ParseFromString(
telemetry_gpb_row.keys)
ipv6_nd_neighbor_entry_content = ipv6_nd_neighbor_entry()
ipv6_nd_neighbor_entry_content.ParseFromString(
telemetry_gpb_row.content)
print("1: {}".format(ipv6_nd_neighbor_entry_content))
print("2: {}".format(ipv6_nd_neighbor_entry_keys))
content_dump = MessageToJson(ipv6_nd_neighbor_entry_content)
keys_dump = MessageToJson(ipv6_nd_neighbor_entry_keys)
print("3: {}".format(content_dump))
print("4: {}".format(keys_dump))
gpb_row_dict["content"].update(yaml.safe_load(content_dump))
gpb_row_dict["keys"].update(yaml.safe_load(keys_dump))
gpb_rows.append(gpb_row_dict)
self.sensor_service.dispatch(
trigger='telemetry_collector.event2', payload=gpb_rows)