def __init__(self, conduit, file_path):
self.muxer = MX2()
self.network = conduit.get_interface(False, 0.0, 0.5, 0.0)
self.network.bring_up()
self.muxer.register_network(self.network)
self.instance = self.muxer.create_instance("GiveFile")
self.transport = STP(self.muxer, self.instance)
self.path = file_path
self.peers = set()
self.instance.incoming_greeting.subscribe(self.rx_greeting)
self.network.incoming_advertisment.subscribe(self.rx_advertisement)
self.transport.incoming_stream.subscribe(self.incoming)
self.network.advertise(self.instance.reference)
def __init__(self, network: Network):
print("init")
self.network = network
self.muxer = MX2()
self.muxer.register_network(network)
self.discoverer = AIP(self.muxer)
self.discoverer.add_network(self.network)
self.discoverer.ready.subscribe(self.aip_ready)
self.instance = self.muxer.create_instance("AipExample")
self.info = ApplicationInformation.from_instance(self.instance)
self.transport = STP(self.muxer, self.instance)
self.start = time.time()
self.instance.incoming_greeting.subscribe(self.on_greet)
self.transport.incoming_stream.subscribe(self.on_stream)
def __init__(self, namespace: str, use_repeaters=True, networks=[]):
super().__init__(namespace)
self.__networks = networks
self.__reachable_peers: Set[InstanceReference] = set()
self.__resource_subjects: Dict[bytes, ReplaySubject] = {}
self.__peer_subjects: Dict[InstanceReference, ReplaySubject] = {}
self.__has_aip_group_peers = ReplaySubject()
if (len(networks) == 0):
port = 5156
while True:
try:
network = IPv4("0.0.0.0", port)
self.__networks.append(network)
break
except Exception as e:
if (port >= 9000):
raise e
port += 1
self.__muxer = MX2()
for network in self.__networks:
network.bring_up()
self.__muxer.register_network(network)
self.__discoverer = AIP(self.__muxer)
self.__instance = self.__muxer.create_instance(self.namespace)
self.__transport = STP(self.__muxer, self.__instance)
self.__path_finder = RPP(self.__muxer, self.__discoverer)
self.__path_finder.add_instance(self.__instance.reference)
self.__instance.incoming_greeting.subscribe(self.__received_greeting)
self.__transport.incoming_stream.subscribe(self.__new_stream)
for network in self.__networks:
self.__discoverer.add_network(network)
self.__info = ApplicationInformation.from_instance(self.__instance)
# Add the application to the discoverer
self.__discoverer.add_application(self.__info).subscribe(
self.__new_aip_app_peer)
def __init__(self, muxer: MX2, discoverer: AIP, is_repeater: bool = False):
self.__muxer = muxer
self.__discoverer = discoverer
self.is_repeater = is_repeater
self.instance_info: Dict[InstanceReference, PeerInfo] = {}
self.instance_network: Dict[InstanceReference, Network] = {}
self.__announced_instances: Set[InstanceReference] = set()
# Create instance
self.__instance = self.__muxer.create_instance(RPP_NAMESPACE)
# Create transport
self.__transport = STP(self.__muxer, self.__instance)
# Create application information
self.__info = ApplicationInformation.from_instance(self.__instance)
# Subscribe to muxer and discoverer events
# self.__discoverer.ready.subscribe(self.__aip_ready)
self.__instance.incoming_greeting.subscribe(self.__received_greeting)
self.__transport.incoming_stream.subscribe(self.__new_stream)
self.__ready = False
self.ready = Subject()
# Are we a repeater?
if(self.is_repeater):
# Yes, tag ourself with that resource
self.__info.resources.add(REPEATER_RESOURCE)
# Add the application to the discoverer
self.__discoverer.add_application(self.__info).subscribe(self.__new_aip_app_peer)
# Keep a set of reachable RPP repeater peers
self.__repeaters: Set[InstanceReference] = set()
self._ready = False
self.ready = Subject()
def __init__(self,
muxer: MX2,
*,
capabilities=set(
(CAPABILITY_ADDRESS_INFO, CAPABILITY_FIND_PEERS,
CAPABILITY_QUERY_ANSWER)),
join_all=False):
self.__application_information: List[ApplicationInformation] = []
self.__capabilities = capabilities
self.__join_all_groups = join_all
self.__muxer = muxer
self.__instance = muxer.create_instance("AIP")
self.__transport = STP(self.__muxer, self.__instance)
self.__discovered_peers: Set[InstanceReference] = set()
self.__peer_connection_methods: Dict[InstanceReference,
Set[PeerInfo]] = {}
self.__instance_capabilities: Dict[InstanceReference, Set[int]] = {}
self.__default_group = QueryGroup(20)
self.__query_groups: Dict[bytes, QueryGroup] = {}
self.__reachable_peers: Set[InstanceReference] = set()
self.__instance.incoming_greeting.subscribe(self.__rx_greeting)
self.__transport.incoming_stream.subscribe(self.__rx_stream)
self.__queries = TTLCache(64, 120)
self.__query_response_count = TTLCache(65536, 120)
self.__handled_query_ids: Set[bytes] = set()
self.__peer_info: Set[PeerInfo] = set()
self.__new_peer_info = rx.subject.Subject()
self.__new_group_peer: Dict[bytes, rx.subject.Subject] = {}
self.__ready = False
self.__on_peer_greet: Dict[InstanceReference, rx.subject.Subject] = {}
self.ready = rx.subject.Subject()