示例#1
0
 async def main(self, fname):
     self.preconnection = taps.Preconnection().from_yangfile(fname)
     taps.print_time("Loaded YANG file: %s." % fname, color)
     self.preconnection.on_connection_received(
         self.handle_connection_received)
     self.preconnection.on_listen_error(self.handle_listen_error)
     self.preconnection.on_stopped(self.handle_stopped)
     await self.preconnection.listen()
    async def main(self, args):

        # Create endpoint objects
        ep = taps.RemoteEndpoint()
        if args.remote_address:
            ep.with_address(args.remote_address)
        elif args.remote_host:
            ep.with_hostname(args.remote_host)
        if args.remote_port:
            ep.with_port(args.remote_port)
        lp = None
        sp = None
        if args.interface or args.local_address or args.local_port:
            lp = taps.LocalEndpoint()
            if args.interface:
                lp.with_interface(args.interface)
            if args.local_address:
                lp.with_port(args.local_address)
            if args.local_port:
                lp.with_port(args.local_port)

        logger.info("Created endpoint objects.")

        if args.secure or args.trust_ca or args.local_identity:
            # Use TLS
            sp = taps.SecurityParameters()
            if args.trust_ca:
                sp.add_trust_ca(args.trust_ca)
            if args.local_identity:
                sp.add_identity(args.local_identity)
            logger.info("Created SecurityParameters.")

        # Create transportProperties Object and set properties
        # Does nothing yet
        tp = taps.TransportProperties()
        # tp.prohibit("reliability")
        tp.ignore("congestion-control")
        tp.ignore("preserve-order")
        # tp.add("Reliable_Data_Transfer", taps.preferenceLevel.REQUIRE)

        # Create the preconnection object with the two prev created EPs
        self.preconnection = taps.Preconnection(remote_endpoint=ep,
                                                local_endpoint=lp,
                                                transport_properties=tp,
                                                security_parameters=sp)
        # Set callbacks
        self.preconnection.on_initiate_error(self.handle_initiate_error)
        self.preconnection.on_ready(self.handle_ready)
        # Set the framer
        framer = TestFramer()
        self.preconnection.add_framer(framer)
        logger.info("Created preconnection object and set cbs.")
        # Initiate the connection
        self.connection = await self.preconnection.initiate()
        # msgref = await self.connection.send_message("Hello\n")
        logger.info("Called initiate, connection object created.")
示例#3
0
    async def main(self, args):
        fname = args.file[0]
        self.preconnection = taps.Preconnection().from_yangfile(fname)
        taps.print_time("Loaded YANG file: %s." % fname, color)

        self.preconnection.on_initiate_error(self.handle_initiate_error)
        self.preconnection.on_ready(self.handle_ready)
        taps.print_time("Created preconnection object and set cbs.", color)

        # Initiate the connection
        self.connection = await self.preconnection.initiate()
        taps.print_time("Called initiate, connection object created.", color)
示例#4
0
    async def main(self):
        ep = taps.RemoteEndpoint()
        ep.with_hostname("localhost")
        ep.with_port(6666)
        tp = taps.TransportProperties()

        tp.prohibit("reliability")
        tp.ignore("congestion-control")
        tp.ignore("preserve-order")

        self.preconnection = taps.Preconnection(remote_endpoint=ep,
                                                transport_properties=tp)
        self.preconnection.on_ready(self.handle_ready)
        self.connection = await self.preconnection.initiate()
    async def main(self):
        lp = taps.LocalEndpoint()
        lp.with_hostname("localhost")
        lp.with_port(6666)
        tp = taps.TransportProperties()

        tp.prohibit("reliability")
        tp.ignore("congestion-control")
        tp.ignore("preserve-order")

        self.preconnection = taps.Preconnection(local_endpoint=lp,
                                                transport_properties=tp)
        self.preconnection.on_connection_received(
                                    self.handle_connection_received)
        await self.preconnection.listen()
示例#6
0
    async def start(self, connection):

        # Set the parameters required for Manifest hashing
        self.source = ipaddress.ip_address(
            connection.remote_endpoint.address[0])
        self.group = ipaddress.ip_address(connection.local_endpoint.address[0])
        self.group_port = connection.local_endpoint.port

        # Create new transport properties, since we want a TCP (TLS) conenction, the defaults are fine
        tp = taps.TransportProperties()
        # Create a new preconnection, set the ready callback and initiate it
        self.preconnection = taps.Preconnection(
            remote_endpoint=self.remote_endpoint,
            local_endpoint=self.local_endpoint,
            transport_properties=tp)
        self.preconnection.on_ready(self.handle_ready)
        self.connection = await self.preconnection.initiate()
    async def main(self, args):
        # Create endpoint object
        lp = taps.LocalEndpoint()
        if args.interface:
            lp.with_interface(args.interface)
        if args.local_address:
            lp.with_address(args.local_address)
        if args.local_host:
            lp.with_hostname(args.local_host)
        # If nothing to listen on has been specified, listen on localhost
        if not args.interface and not args.local_address\
           and not args.local_host:
            lp.with_hostname("localhost")
        if args.local_port:
            lp.with_port(args.local_port)

        taps.print_time("Created endpoint objects.", color)

        sp = None
        if args.secure or args.trust_ca or args.local_identity:
            # Use TLS
            sp = taps.SecurityParameters()
            if args.trust_ca:
                sp.addTrustCA(args.trust_ca)
            if args.local_identity:
                sp.addIdentity(args.local_identity)
            taps.print_time("Created SecurityParameters.", color)

        tp = taps.TransportProperties()
        tp.ignore("congestion-control")
        tp.ignore("preserve-order")
        if self.reliable == "False":
            tp.prohibit("reliability")
        if self.reliable == "Both":
            tp.ignore("reliability")

        self.preconnection = taps.Preconnection(local_endpoint=lp,
                                                transport_properties=tp,
                                                security_parameters=sp)
        self.preconnection.on_connection_received(
            self.handle_connection_received)
        self.preconnection.on_listen_error(self.handle_listen_error)
        self.preconnection.on_stopped(self.handle_stopped)
        # self.preconnection.frame_with(taps.TlvFramer())
        await self.preconnection.listen()
示例#8
0
    async def main(self):
        # Create (local) multicast group endpoint
        mcg = taps.LocalEndpoint()
        mcg.with_address(args.group_address)
        mcg.with_port(args.group_port)

        # Create (remote) source endpoint
        ssm = taps.RemoteEndpoint()
        ssm.with_address(args.ssm_address)
        ssm.with_port(args.ssm_port)

        # Create endpoint for the remote for AMBI
        rambi = taps.RemoteEndpoint()
        rambi.with_address(args.remote_ambi_address)
        rambi.with_port(args.remote_ambi_port)

        # Create endpoint for the local for AMBI
        if args.local_ambi_address is not None:
            lambi = taps.LocalEndpoint()
            lambi.with_address(args.local_ambi_address)
            lambi.with_port(args.local_ambi_port)
        else:
            lambi = None

        # Set the transportpropterties necessary to get a multicast stream
        tp = taps.TransportProperties()
        tp.add("direction", "unidirection-receive")
        tp.prohibit("reliability")
        tp.ignore("congestion-control")
        tp.ignore("preserve-order")

        # Configure the preconnection
        self.preconnection = taps.Preconnection(remote_endpoint=ssm,
                                                local_endpoint=mcg,
                                                transport_properties=tp)

        # Set the new connection callback
        self.preconnection.on_connection_received(
            self.handle_connection_received)
        # Create a new AMBI framer object and set it on the preconnection.
        ambi = AmbiFramer(remote_endpoint=rambi, local_endpoint=lambi)
        self.preconnection.add_framer(ambi)
        # Initiate the preconnection so it can start to received multicast packets
        self.listener = await self.preconnection.listen()