Request sync module info.

    :param blink: Blink instance.
    :param network: Sync module network id.
968182
def request_syncmodule(blink, network):
    
    url = "{}/network/{}/syncmodules".format(blink.urls.base_url, network)
    return http_get(blink, url)
898962
def request_network_status(blink, network):
    
    url = "{}/network/{}".format(blink.urls.base_url, network)
    return http_get(blink, url)
948587
def _get_network(project_id, network_name, service):
    '''
    
    '''
    return service.networks().get(project=project_id,
                                  network=network_name).execute()
405906
def updateCurrentNetworkInNdex(self, body, verbose=None):
        

        surl=self.___url
        sv=surl.split('/')[-1]
        surl=surl.rstrip(sv+'/')
        response=api(url=surl+'/cyndex2/'+sv+'/networks/current', method="PUT", body=body, verbose=verbose)
        return response
534762
def _register_socket(s):
        '''
        
        '''
        queue_to_app = Queue()
        with _lock:
            ApplicationLayer._to_app[s._sockid()] = queue_to_app
        return ApplicationLayer._from_app, queue_to_app
119841
def check_network_id(network_id, web3: Web3):
    
    while True:
        current_id = int(web3.version.network)
        if network_id != current_id:
            raise RuntimeError(
                f'Raiden was running on network with id {network_id} and it detected '
                f'that the underlying ethereum client network id changed to {current_id}.'
                f' Changing the underlying blockchain while the Raiden node is running '
                f'is not supported.',
            )
        gevent.sleep(CHECK_NETWORK_ID_INTERVAL)
397353
def request_system_disarm(blink, network):
    
    url = "{}/network/{}/disarm".format(blink.urls.base_url, network)
    return http_post(blink, url)
603662
def sync_auth_info(options = {})

      opts = {
        "RunSynchAutoInfo" => 'True',
        "EmailEPP" => 'True'
      }
      opts["EmailEPP"] = 'True' if options[:email]

      Client.request({"Command" => "SynchAuthInfo", "SLD" => sld, "TLD" => tld}.merge(opts))
      return self
    end
94093
def get_ping(self, nonce: Nonce) -> bytes:
        
        message = Ping(
            nonce=nonce,
            current_protocol_version=constants.PROTOCOL_VERSION,
        )
        self.raiden.sign(message)
        return message.encode()
423707
def blink(self, status):
        """"""
        self._display_control = ByteUtil.apply_flag(self._display_control, Command.BLINKING_ON, status)
        self.command(self._display_control)
1178043
def sync_header_chain(cls, path, bitcoind_server, last_block_id ):
        
        current_block_id = SPVClient.height( path )
        if current_block_id is None:
            assert USE_TESTNET
            current_block_id = -1

        assert (current_block_id >= 0 and USE_MAINNET) or USE_TESTNET

        if current_block_id < last_block_id:
          
            if USE_MAINNET:
                log.debug("Synchronize %s to %s" % (current_block_id, last_block_id))
            else:
                log.debug("Synchronize testnet %s to %s" % (current_block_id + 1, last_block_id ))

            # need to sync
            if current_block_id >= 0:
                prev_block_header = SPVClient.read_header( path, current_block_id )
                prev_block_hash = prev_block_header['hash']

            else:
                # can only happen when in testnet
                prev_block_hash = GENESIS_BLOCK_HASH_TESTNET

            # connect 
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

            # timeout (10 min)
            sock.settimeout(600)

            bitcoind_port = 8333
            if ":" in bitcoind_server:
                p = bitcoind_server.split(":")
                bitcoind_server = p[0]
                bitcoind_port = int(p[1])

            log.debug("connect to %s:%s" % (bitcoind_server, bitcoind_port))
            sock.connect( (bitcoind_server, bitcoind_port) )

            client = BlockHeaderClient( sock, path, prev_block_hash, last_block_id )

            # get headers
            client.run()

            # verify headers
            if SPVClient.height(path) < last_block_id:
                raise Exception("Did not receive all headers up to %s (only got %s)" % (last_block_id, SPVClient.height(path)))

            # defensive: make sure it's *exactly* that many blocks 

            rc = SPVClient.verify_header_chain( path )
            if not rc:
                raise Exception("Failed to verify headers (stored in '%s')" % path)

        log.debug("synced headers from %s to %s in %s" % (current_block_id, last_block_id, path))
        return True
170212
async def NetworkInfo(self, bindings, unit):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Uniter',
                   request='NetworkInfo',
                   version=5,
                   params=_params)
        _params['bindings'] = bindings
        _params['unit'] = unit
        reply = await self.rpc(msg)
        return reply
105737
def _network_show(self, name, network_lst):
        '''
        
        '''
        for net in network_lst:
            if net.label == name:
                return net.__dict__
        return {}
1156766
def refresh(self):
        
        if not self._client:
            return
        current_networks = self._client.networks()
        self.clear()
        self.update((net['Name'], net['Id'])
                    for net in current_networks)
807150
def sync_networks(self):
        
        nets = self.neutronclient.list_networks()
        for net in nets.get("networks"):
            LOG.info("Syncing network %s", net["id"])
            self.network_create_func(net)
        subnets = self.neutronclient.list_subnets()
        for subnet in subnets.get("subnets"):
            LOG.info("Syncing subnet %s", subnet["id"])
            self.create_subnet(subnet)
940692
def request_cameras(blink, network):
    
    url = "{}/network/{}/cameras".format(blink.urls.base_url, network)
    return http_get(blink, url)
675341
def sync(self):
        
        LOGGER.debug("OSType.sync")
        params = None
        if self.id is not None:
            params = {'id': self.id}
        elif self.name is not None:
            params = {'name': self.name}

        if params is not None:
            args = {'http_operation': 'GET', 'operation_path': 'get', 'parameters': params}
            response = OSTypeService.requester.call(args)
            if response.rc != 0:
                LOGGER.warning(
                    'OSType.sync - Problem while syncing OS type (name:' + self.name + ', id: ' + str(self.id) +
                    '). Reason: ' + str(response.response_content) + '-' + str(response.error_message) +
                    " (" + str(response.rc) + ")"
                )
            else:
                json_obj = response.response_content
                self.id = json_obj['osTypeID']
                self.name = json_obj['osTypeName']
                self.architecture = json_obj['osTypeArchitecture']
                if json_obj['osTypeCompanyID'] == -1:
                    self.company_id = None
                else:
                    self.company_id = json_obj['osTypeCompanyID']
                self.osi_ids = json_obj['osTypeOSInstancesID']