def main( ctx, channel_manager_address, ssl_key, ssl_cert, gas_price, state_file, private_key, private_key_password_file, paywall_info, rpc_provider, ): private_key = utils.get_private_key(private_key, private_key_password_file) if private_key is None: sys.exit(1) receiver_address = privkey_to_addr(private_key) constants.paywall_html_dir = paywall_info while True: try: web3 = Web3( HTTPProvider(rpc_provider, request_kwargs={'timeout': 60})) NETWORK_CFG.set_defaults(int(web3.version.network)) channel_manager_address = to_checksum_address( channel_manager_address or NETWORK_CFG.CHANNEL_MANAGER_ADDRESS) if gas_price is not None: NETWORK_CFG.gas_price = gas_price if not state_file: state_file_name = "%s_%s.db" % (channel_manager_address[:10], receiver_address[:10]) app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) state_file = os.path.join(app_dir, state_file_name) app = make_paywalled_proxy( private_key, state_file, contract_address=channel_manager_address, web3=web3) except StateFileLocked as ex: log.warning('Another uRaiden process is already running (%s)!' % str(ex)) except InsecureStateFile as ex: msg = ( 'The permission bits of the state file (%s) are set incorrectly (others can ' 'read or write) or you are not the owner. For reasons of security, ' 'startup is aborted.' % state_file) log.fatal(msg) raise except NetworkIdMismatch as ex: log.fatal(str(ex)) raise except requests.exceptions.ConnectionError as ex: log.warning("Ethereum node refused connection: %s" % str(ex)) else: break sleep(constants.SLEEP_RELOAD) ctx.obj = app
def start_proxy(receiver_privkey: str) -> PaywalledProxy: state_file_name = 'ticker_proxy.db' app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) app = make_paywalled_proxy(receiver_privkey, os.path.join(app_dir, state_file_name)) app.run() return app
def main( ctx, channel_manager_address, ssl_key, ssl_cert, gas_price, state_file, private_key, private_key_password_file, paywall_info, rpc_provider, ): private_key = utils.get_private_key(private_key, private_key_password_file) if private_key is None: sys.exit(1) receiver_address = privkey_to_addr(private_key) constants.paywall_html_dir = paywall_info while True: try: web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60})) NETWORK_CFG.set_defaults(int(web3.version.network)) channel_manager_address = to_checksum_address( channel_manager_address or NETWORK_CFG.CHANNEL_MANAGER_ADDRESS ) if gas_price is not None: NETWORK_CFG.gas_price = gas_price if not state_file: state_file_name = "%s_%s.db" % ( channel_manager_address[:10], receiver_address[:10] ) app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) state_file = os.path.join(app_dir, state_file_name) app = make_paywalled_proxy(private_key, state_file, contract_address=channel_manager_address, web3=web3) except StateFileLocked as ex: log.warning('Another uRaiden process is already running (%s)!' % str(ex)) except InsecureStateFile as ex: msg = ('The permission bits of the state file (%s) are set incorrectly (others can ' 'read or write) or you are not the owner. For reasons of security, ' 'startup is aborted.' % state_file) log.fatal(msg) raise except NetworkIdMismatch as ex: log.fatal(str(ex)) raise except requests.exceptions.ConnectionError as ex: log.warning("Ethereum node refused connection: %s" % str(ex)) else: break sleep(constants.SLEEP_RELOAD) ctx.obj = app
def main( ctx, channel_manager_address, ssl_key, ssl_cert, state_file, private_key, paywall_info, rpc_provider, ): if private_key is None: log.fatal("No private key provided") sys.exit(1) if utils.check_permission_safety(private_key) is False: log.fatal("Private key file %s must be readable only by its owner." % (private_key)) sys.exit(1) with open(private_key) as keyfile: private_key = keyfile.readline()[:-1] if not is_hex(private_key) or len(decode_hex(private_key)) != 32: log.fatal("Private key must be specified as 32 hex encoded bytes") sys.exit(1) receiver_address = privkey_to_addr(private_key) channel_manager_address = channel_manager_address or config.CHANNEL_MANAGER_ADDRESS if not state_file: state_file_name = "%s_%s.json" % (channel_manager_address[:10], receiver_address[:10]) app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) state_file = os.path.join(app_dir, state_file_name) config.paywall_html_dir = paywall_info web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60})) try: app = make_paywalled_proxy(private_key, state_file, web3=web3) except StateFileLocked as ex: log.fatal('Another uRaiden process is already running (%s)!' % str(ex)) sys.exit(1) except InsecureStateFile as ex: msg = ( 'The permission bits of the state file (%s) are set incorrectly (others can ' 'read or write) or you are not the owner. For reasons of security, ' 'startup is aborted.' % state_file) log.fatal(msg) sys.exit(1) except NetworkIdMismatch as ex: log.fatal(str(ex)) sys.exit(1) except requests.exceptions.ConnectionError as ex: log.fatal("Ethereum node refused connection: %s" % str(ex)) sys.exit(1) ctx.obj = app
def start_proxy(receiver_privkey: str) -> PaywalledProxy: state_file_name = '{}_{}.json'.format(CHANNEL_MANAGER_ADDRESS, privkey_to_addr(receiver_privkey)) app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) app = make_paywalled_proxy(receiver_privkey, os.path.join(app_dir, state_file_name)) app.run() return app
def main( ctx, channel_manager_address, ssl_key, ssl_cert, state_file, private_key, private_key_password_file, paywall_info, rpc_provider, ): private_key = utils.get_private_key(private_key, private_key_password_file) if private_key is None: sys.exit(1) receiver_address = privkey_to_addr(private_key) channel_manager_address = channel_manager_address or config.CHANNEL_MANAGER_ADDRESS if not state_file: state_file_name = "%s_%s.db" % (channel_manager_address[:10], receiver_address[:10]) app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) state_file = os.path.join(app_dir, state_file_name) config.paywall_html_dir = paywall_info web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60})) try: app = make_paywalled_proxy(private_key, state_file, contract_address=channel_manager_address, web3=web3) except StateFileLocked as ex: log.fatal('Another uRaiden process is already running (%s)!' % str(ex)) sys.exit(1) except InsecureStateFile as ex: msg = ( 'The permission bits of the state file (%s) are set incorrectly (others can ' 'read or write) or you are not the owner. For reasons of security, ' 'startup is aborted.' % state_file) log.fatal(msg) sys.exit(1) except NetworkIdMismatch as ex: log.fatal(str(ex)) sys.exit(1) except requests.exceptions.ConnectionError as ex: log.fatal("Ethereum node refused connection: %s" % str(ex)) sys.exit(1) ctx.obj = app
def start_proxy(receiver_privkey: str) -> PaywalledProxy: state_file_name = '{}_{}.json'.format(CHANNEL_MANAGER_ADDRESS, privkey_to_addr(receiver_privkey)) app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) app = make_paywalled_proxy(receiver_privkey, os.path.join(app_dir, state_file_name)) app.add_content( PaywalledProxyUrl("[A-Z]{6}", 1 * TKN_DECIMALS, 'http://api.bitfinex.com/v1/pubticker/', [r'[A-Z]{6}'])) app.run() return app
def run(join_thread: bool = True): dirname = os.path.dirname(state_file_path) if dirname: os.makedirs(dirname, exist_ok=True) app = make_paywalled_proxy(private_key, state_file_path) # log.info(app) app.add_paywalled_resource( cls=Pic4Cash, url=FIX_PRICE_URL + "/<string:param>", price=5 ) # Start the app. proxy is a WSGI greenlet, so you must join it properly. app.run(debug=True) if join_thread: app.join() else: return app
# create a custom web3 provider - parity/geth runs in another container/on another host while True: try: web3 = Web3( HTTPProvider(config.WEB3_PROVIDER, request_kwargs={'timeout': 60})) network_id = web3.version.network except ConnectionError: log.critical( "Ethereum node isn't responding. Restarting after %d seconds." % (config.SLEEP_RELOAD)) gevent.sleep(config.SLEEP_RELOAD) else: break # create flask app app = Flask(__name__, static_url_path=JSPREFIX_URL, static_folder=JSLIB_DIR) # create microraiden app microraiden_app = make_paywalled_proxy(config.PRIVATE_KEY, config.STATE_FILE, web3=web3, flask_app=app) # add some content microraiden_app.add_content( PaywalledProxyUrl(".*", 1 * TKN_DECIMALS, "http://en.wikipedia.org/", [r"wiki/.*"])) # only after blockchain is fully synced the app is ready to serve requests microraiden_app.channel_manager.wait_sync()
) from microraiden.make_helpers import make_paywalled_proxy from microraiden.config import TKN_DECIMALS if __name__ == '__main__': private_key = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' state_file_name = 'echo_server.json' app_dir = click.get_app_dir('microraiden') if not os.path.exists(app_dir): os.makedirs(app_dir) state_file_name = os.path.join(app_dir, state_file_name) # set up a paywalled proxy # arguments are: # - private key to use for receiving funds # - file for storing state information (balance proofs) app = make_paywalled_proxy(private_key, state_file_name) # Add resource defined by regex and with a fixed price of 1 token # We setup the resource to return whatever is supplied as a second argument # in the URL. app.add_content(PaywalledContent( "echofix\/[a-zA-Z0-9]+", 1 * TKN_DECIMALS, lambda request: (request.split("/")[1], 200))) # Resource with a price determined by the second parameter app.add_content(PaywalledContent( "echodyn\/[0-9]+", lambda request: int(request.split("/")[1]) * TKN_DECIMALS, lambda request: (int(request.split("/")[1]), 200))) app.add_content(PaywalledProxyUrl( "p\/[0-9]+", 1 * TKN_DECIMALS,