def enrico(action, policy_encrypting_key, dry_run, http_port): """ Start and manage an "Enrico" character control HTTP server """ click.secho(ENRICO_BANNER.format(policy_encrypting_key)) if action == 'run': # Forest policy_encrypting_key = UmbralPublicKey.from_bytes(bytes.fromhex(policy_encrypting_key)) ENRICO = Enrico(policy_encrypting_key=policy_encrypting_key) # Enrico Control enrico_control = ENRICO.make_wsgi_app() click.secho("Starting Enrico Character Control...") click.secho(f"Enrico Verifying Key {bytes(ENRICO.stamp).hex()}", fg="green", bold=True) # Run if dry_run: return hx_deployer = HendrixDeploy(action="start", options={"wsgi": enrico_control, "http_port": http_port}) hx_deployer.run() # <--- Blocking Call to Reactor else: raise click.BadArgumentUsage
def start(self, host: str, port: int, web_services: bool = True, distribution: bool = True, crash_on_error: bool = False): self.crash_on_error = crash_on_error if self.start_time is not NOT_RUNNING: raise RuntimeError("Felix is already running.") self.start_time = maya.now() payload = { "wsgi": self.rest_app, "http_port": port, "resources": get_static_resources() } deployer = HendrixDeploy(action="start", options=payload) if distribution is True: self.start_distribution() if web_services is True: deployer.run() # <-- Blocking call (Reactor)
def start(self, http_port: int, dry_run: bool = False): self.log.info("Starting HTTP Character Control...") if dry_run: return # TODO: Make non-blocking web control startup hx_deployer = HendrixDeploy(action="start", options={"wsgi": self._web_app, "http_port": http_port}) hx_deployer.run() # <--- Blocking Call to Reactor
def start(self, eager: bool = False): """Start the crawler if not already running""" if not self.is_running: self.log.info('Starting Crawler...') if self._influx_client is None: self._influx_client = InfluxDBClient( host=self._db_host, port=self._db_port, database=self.INFLUX_DB_NAME) self._initialize_influx() if self._crawler_client is None: from monitor.db import CrawlerStorageClient self._crawler_client = CrawlerStorageClient() # TODO: Maybe? # from monitor.db import CrawlerInfluxClient # self.crawler_influx_client = CrawlerInfluxClient() # start tasks node_learner_deferred = self._node_details_task.start( interval=random.randint( int(self._refresh_rate * (1 - self.REFRESH_RATE_WINDOW)), self._refresh_rate), now=eager) time.sleep(random.randint(2, 10)) # random stagger start of task collection_deferred = self._stats_collection_task.start( interval=random.randint( self._refresh_rate, int(self._refresh_rate * (1 + self.REFRESH_RATE_WINDOW))), now=eager) # get known last event block self.__events_from_block = self._get_last_known_blocknumber() time.sleep(random.randint(2, 10)) # random stagger start of task events_deferred = self._events_collection_task.start( interval=self._refresh_rate, now=eager) # hookup error callbacks node_learner_deferred.addErrback(self._handle_errors) collection_deferred.addErrback(self._handle_errors) events_deferred.addErrback(self._handle_errors) # Start up self.start_learning_loop(now=False) self.make_flask_server() hx_deployer = HendrixDeploy(action="start", options={ "wsgi": self._flask, "http_port": self._crawler_http_port }) hx_deployer.run() # <--- Blocking Call to Reactor
def start(self, http_port: int, dry_run: bool = False): self.log.info("Starting HTTP Character Control...") if dry_run: return # TODO #845: Make non-blocking web control startup hx_deployer = HendrixDeploy(action="start", options={ "wsgi": self._transport, "http_port": http_port, "resources": get_static_resources() }) hx_deployer.run() # <--- Blocking Call to Reactor
def start(self, ws_port: int, http_port: int, dry_run: bool = False): # # Websocket Service # def send_states(subscriber): message = ["states", self.known_nodes.abridged_states_dict()] subscriber.sendMessage(json.dumps(message).encode()) def send_nodes(subscriber): message = ["nodes", self.known_nodes.abridged_nodes_dict()] subscriber.sendMessage(json.dumps(message).encode()) websocket_service = hey_joe.WebSocketService("127.0.0.1", ws_port) websocket_service.register_followup("states", send_states) websocket_service.register_followup("nodes", send_nodes) # # WSGI Service # self.rest_app = Flask("fleet-monitor", template_folder=TEMPLATES_DIR) rest_app = self.rest_app @rest_app.route("/") def status(): try: return render_template('monitor.html') except Exception as e: self.log.debug(str(e)) # # Server # deployer = HendrixDeploy(action="start", options={ "wsgi": rest_app, "http_port": http_port }) deployer.add_non_tls_websocket_service(websocket_service) click.secho(f"Running Moe on 127.0.0.1:{http_port}") if not dry_run: deployer.run()
def start(self, host: str, port: int, web_services: bool = True, distribution: bool = True, crash_on_error: bool = False): self.crash_on_error = crash_on_error if self.start_time is not NOT_RUNNING: raise RuntimeError("Felix is already running.") self.start_time = maya.now() payload = {"wsgi": self.rest_app, "http_port": port} deployer = HendrixDeploy(action="start", options=payload) click.secho(f"Running {self.__class__.__name__} on {host}:{port}") if distribution is True: self.start_distribution() if web_services is True: deployer.run() # <-- Blocking call (Reactor)
from hendrix.deploy.base import HendrixDeploy from hendrix.experience import hey_joe deployer = HendrixDeploy(options={ 'wsgi': 'example_app.wsgi.application', 'http_port': 7575 }) websocket_service = hey_joe.WebSocketService("127.0.0.1", 9000) deployer.add_non_tls_websocket_service(websocket_service) deployer.run()
tp = reactor.suggestThreadPoolSize(1000) # begin chdir armor up = os.path.dirname(os.path.abspath(__file__)) testdir = os.path.dirname(up) hendrix_app_dir = os.path.dirname(testdir) hendrix_package_dir = os.path.dirname(hendrix_app_dir) sys.path.insert(0, hendrix_package_dir) # end chdir armor from hendrix.deploy.base import HendrixDeploy import threading def delay(request): delay_time = float(request.matchdict['seconds']) print "Thread %s sleeping for %s seconds" % (threading.current_thread(), delay_time) time.sleep(delay_time) return Response('') if __name__ == '__main__': config = Configurator() config.add_route('delay', '/{seconds}') config.add_view(delay, route_name='delay') app = config.make_wsgi_app() tp = ThreadPool(name="Big and Slow.", maxthreads=1000) deployer = HendrixDeploy(options={'wsgi': app, 'http_port': 8010}, threadpool=tp) deployer.run()
def moe(teacher_uri, min_stake, network, ws_port, dry_run, http_port, learn_on_launch): """ "Moe" NuCypher node monitor CLI. """ click.secho(MOE_BANNER) # # Teacher # teacher_nodes = list() if teacher_uri: teacher_node = Ursula.from_seed_and_stake_info(seed_uri=teacher_uri, federated_only=True, minimum_stake=min_stake) teacher_nodes.append(teacher_node) # Deserialize network domain name if override passed if network: domain_constant = getattr(constants, network.upper()) domains = {domain_constant} else: domains = None monitor = Moe( domains=domains, network_middleware=RestMiddleware(), known_nodes=teacher_nodes, federated_only=True, ) monitor.start_learning_loop(now=learn_on_launch) # # Websocket Service # def send_states(subscriber): message = ["states", monitor.known_nodes.abridged_states_dict()] subscriber.sendMessage(json.dumps(message).encode()) def send_nodes(subscriber): message = ["nodes", monitor.known_nodes.abridged_nodes_dict()] subscriber.sendMessage(json.dumps(message).encode()) websocket_service = hey_joe.WebSocketService("127.0.0.1", ws_port) websocket_service.register_followup("states", send_states) websocket_service.register_followup("nodes", send_nodes) # # Flask App # rest_app = Flask("fleet-monitor", root_path=os.path.dirname(__file__)) @rest_app.route("/") def status(): template_path = os.path.join('monitor.html') return render_template(template_path) # # Server # deployer = HendrixDeploy(action="start", options={ "wsgi": rest_app, "http_port": http_port }) deployer.add_non_tls_websocket_service(websocket_service) click.secho(f"Running Moe on 127.0.0.1:{http_port}") if not dry_run: deployer.run()
def alice(click_config, action, quiet, teacher_uri, min_stake, http_port, discovery_port, federated_only, network, config_root, config_file, provider_uri, registry_filepath, dev, force, dry_run, bob_encrypting_key, bob_verifying_key, label, m, n): """ Start and manage an "Alice" character. """ if not quiet: click.secho(ALICE_BANNER) if action == 'init': """Create a brand-new persistent Alice""" if dev and not quiet: click.secho("WARNING: Using temporary storage area", fg='yellow') if not config_root: # Flag config_root = click_config.config_file # Envvar alice_config = AliceConfiguration.generate( password=click_config.get_password(confirm=True), config_root=config_root, rest_host="localhost", domains={network} if network else None, federated_only=federated_only, no_registry=True, # Yes we have no registry, registry_filepath=registry_filepath, provider_uri=provider_uri, ) if not quiet: click.secho("Generated keyring {}".format( alice_config.keyring_dir), fg='green') click.secho("Saved configuration file {}".format( alice_config.config_file_location), fg='green') # Give the use a suggestion as to what to do next... how_to_run_message = "\nTo run an Alice node from the default configuration filepath run: \n\n'{}'\n" suggested_command = 'nucypher alice run' if config_root is not None: config_file_location = os.path.join( config_root, config_file or AliceConfiguration.CONFIG_FILENAME) suggested_command += ' --config-file {}'.format( config_file_location) click.secho(how_to_run_message.format(suggested_command), fg='green') return # FIN else: click.secho("OK") elif action == "destroy": """Delete all configuration files from the disk""" if dev: message = "'nucypher ursula destroy' cannot be used in --dev mode" raise click.BadOptionUsage(option_name='--dev', message=message) destroy_system_configuration(config_class=AliceConfiguration, config_file=config_file, network=network, config_root=config_root, force=force) if not quiet: click.secho("Destroyed {}".format(config_root)) return # # Get Alice Configuration # if dev: alice_config = AliceConfiguration( dev_mode=True, domains={network}, provider_uri=provider_uri, federated_only=True, ) else: alice_config = AliceConfiguration.from_configuration_file( filepath=config_file, domains={network or GLOBAL_DOMAIN}, rest_port=discovery_port, provider_uri=provider_uri) # Teacher teacher_nodes = list() if teacher_uri: teacher_node = Ursula.from_teacher_uri( teacher_uri=teacher_uri, min_stake=min_stake, federated_only=alice_config.federated_only) teacher_nodes.append(teacher_node) if not dev: # Keyring try: click.secho("Decrypting keyring...", fg='blue') alice_config.keyring.unlock(password=click_config.get_password()) except CryptoError: raise alice_config.keyring.AuthenticationFailed finally: click_config.alice_config = alice_config # Produce ALICE = alice_config(known_nodes=teacher_nodes) if action == "run": # Alice Control alice_control = ALICE.make_wsgi_app() click.secho("Starting Alice Character Control...") click.secho(f"Alice Verifying Key {bytes(ALICE.stamp).hex()}", fg="green", bold=True) # Run if dry_run: return hx_deployer = HendrixDeploy(action="start", options={ "wsgi": alice_control, "http_port": http_port }) hx_deployer.run() # <--- Blocking Call to Reactor elif action == "view": """Paint an existing configuration to the console""" paint_configuration( config_filepath=config_file or alice_config.config_file_location) return elif action == "create-policy": if not all((bob_verifying_key, bob_encrypting_key, label)): raise click.BadArgumentUsage( message= "--bob-verifying-key, --bob-encrypting-key, and --label are " "required options to create a new policy.") request_data = { 'bob_encrypting_key': bob_encrypting_key, 'bob_signing_key': bob_verifying_key, 'label': b64encode(bytes(label, encoding='utf-8')).decode(), 'm': m, 'n': n, } response = requests.put(f'http://localhost:{http_port}/create_policy', data=json.dumps(request_data)) click.secho(response.json()) return elif action == "derive-policy": response = requests.post( f'http://localhost:{http_port}/derive_policy_pubkey/{label}') response_data = response.json() policy_encrypting_key = response_data['result'][ 'policy_encrypting_pubkey'] click.secho( f"Created new Policy with label {label} | {policy_encrypting_key}", fg='green') elif action == "grant": request_data = { 'bob_encrypting_key': bob_encrypting_key, 'bob_signing_key': bob_verifying_key, 'label': b64encode(bytes(label, encoding='utf-8')).decode(), 'm': m, 'n': n, 'expiration_time': (maya.now() + datetime.timedelta(days=3)).iso8601(), # TODO } response = requests.put(f'http://localhost:{http_port}/grant', data=json.dumps(request_data)) click.secho(response) return elif action == "revoke": raise NotImplementedError # TODO else: raise click.BadArgumentUsage(f"No such argument {action}")
def bob(click_config, action, quiet, teacher_uri, min_stake, http_port, discovery_port, federated_only, network, config_root, config_file, provider_uri, registry_filepath, dev, force, dry_run, label, policy_encrypting_key, alice_encrypting_key): """ Start and manage a "Bob" character. """ if not quiet: click.secho(BOB_BANNER) if action == 'init': """Create a brand-new persistent Bob""" if dev and not quiet: click.secho("WARNING: Using temporary storage area", fg='yellow') if not config_root: # Flag config_root = click_config.config_file # Envvar bob_config = BobConfiguration.generate( password=click_config.get_password(confirm=True), config_root=config_root, rest_host="localhost", domains={network} if network else None, federated_only=federated_only, no_registry=True, # Yes we have no registry, registry_filepath=registry_filepath, provider_uri=provider_uri, ) if not quiet: click.secho("Generated keyring {}".format(bob_config.keyring_dir), fg='green') click.secho("Saved configuration file {}".format( bob_config.config_file_location), fg='green') # Give the use a suggestion as to what to do next... how_to_run_message = "\nTo run an Bob node from the default configuration filepath run: \n\n'{}'\n" suggested_command = 'nucypher bob run' if config_root is not None: config_file_location = os.path.join( config_root, config_file or BobConfiguration.CONFIG_FILENAME) suggested_command += ' --config-file {}'.format( config_file_location) click.secho(how_to_run_message.format(suggested_command), fg='green') return # FIN else: click.secho("OK") elif action == "destroy": """Delete all configuration files from the disk""" if dev: message = "'nucypher ursula destroy' cannot be used in --dev mode" raise click.BadOptionUsage(option_name='--dev', message=message) destroy_system_configuration(config_class=BobConfiguration, config_file=config_file, network=network, config_root=config_root, force=force) if not quiet: click.secho("Destroyed {}".format(config_root)) return # # Get Bob Configuration # if dev: bob_config = BobConfiguration( dev_mode=True, domains={network}, provider_uri=provider_uri, federated_only=True, ) else: bob_config = BobConfiguration.from_configuration_file( filepath=config_file, domains={network or GLOBAL_DOMAIN}, rest_port=discovery_port, provider_uri=provider_uri) # Teacher teacher_nodes = list() if teacher_uri: teacher_node = Ursula.from_teacher_uri( teacher_uri=teacher_uri, min_stake=min_stake, federated_only=bob_config.federated_only) teacher_nodes.append(teacher_node) # Produce BOB = bob_config(known_nodes=teacher_nodes) if action == "run": if not dev: # Keyring try: click.secho("Decrypting keyring...", fg='blue') bob_config.keyring.unlock(password=click_config.get_password()) except CryptoError: raise bob_config.keyring.AuthenticationFailed finally: click_config.bob_config = bob_config # Bob Control bob_control = BOB.make_wsgi_app() click.secho("Starting Bob Character Control...") click.secho(f"Bob Verifying Key {bytes(BOB.stamp).hex()}", fg="green", bold=True) click.secho( f"Bob Encrypting Key {bytes(BOB.public_keys(DecryptingPower)).hex()}", fg="blue", bold=True) # Run if dry_run: return hx_deployer = HendrixDeploy(action="start", options={ "wsgi": bob_control, "http_port": http_port }) hx_deployer.run() # <--- Blocking Call to Reactor elif action == "view": """Paint an existing configuration to the console""" paint_configuration( config_filepath=config_file or bob_config.config_file_location) return elif action == "retrieve": bob_request_data = { 'label': b64encode(label).decode(), 'policy_encrypting_pubkey': policy_encrypting_key, 'alice_signing_pubkey': alice_encrypting_key, # 'message_kit': b64encode(bob_message_kit.to_bytes()).decode(), # TODO } response = requests.post('/retrieve', data=json.dumps(bob_request_data)) click.secho(response) return else: raise click.BadArgumentUsage(f"No such argument {action}")