def main(prog_name=os.path.basename(sys.argv[0]), args=None,
with_loggers=True):
if args is None:
args = sys.argv[1:]
parser = create_parser(prog_name)
args = parser.parse_args(args)
arg_config = create_identity_config(args)
identity_config = load_identity_config(arg_config)
processor = TransactionProcessor(url=identity_config.connect)
if with_loggers is True:
if args.verbose is None:
verbose_level = 0
else:
verbose_level = args.verbose
setup_loggers(verbose_level=verbose_level, processor=processor)
handler = IdentityTransactionHandler()
processor.add_handler(handler)
try:
processor.start()
except KeyboardInterrupt:
pass
finally:
processor.stop()
def main(args=None):
if args is None:
args = sys.argv[1:]
opts = parse_args(args)
processor = None
try:
processor = TransactionProcessor(url=opts.endpoint)
log_config = get_log_config(filename="intkey_log_config.toml")
if log_config is not None:
log_configuration(log_config=log_config)
else:
log_dir = get_log_dir()
# use the transaction processor zmq identity for filename
log_configuration(
log_dir=log_dir,
name="intkey-" + str(processor.zmq_id)[2:-1])
init_console_logging(verbose_level=opts.verbose)
# The prefix should eventually be looked up from the
# validator's namespace registry.
handler = IntkeyTransactionHandler()
processor.add_handler(handler)
processor.start()
except KeyboardInterrupt:
pass
except Exception as e: # pylint: disable=broad-except
print("Error: {}".format(e), file=sys.stderr)
finally:
if processor is not None:
processor.stop()
def main(prog_name=os.path.basename(sys.argv[0]), args=None,
with_loggers=True):
if args is None:
args = sys.argv[1:]
parser = create_parser(prog_name)
args = parser.parse_args(args)
if with_loggers is True:
if args.verbose is None:
verbose_level = 0
else:
verbose_level = args.verbose
setup_loggers(verbose_level=verbose_level)
processor = TransactionProcessor(url=args.endpoint)
handler = SettingsTransactionHandler()
processor.add_handler(handler)
try:
processor.start()
except KeyboardInterrupt:
pass
finally:
processor.stop()
def main(args=None):
if args is None:
args = sys.argv[1:]
opts = parse_args(args)
init_console_logging(verbose_level=opts.verbose)
processor = TransactionProcessor(url=opts.endpoint)
handler = ValidatorRegistryTransactionHandler()
processor.add_handler(handler)
try:
processor.start()
except KeyboardInterrupt:
pass
finally:
processor.stop()
def main(args=sys.argv[1:]):
opts = parse_args(args)
init_console_logging(verbose_level=opts.verbose)
processor = TransactionProcessor(url=opts.endpoint)
# The prefix should eventually be looked up from the
# validator's namespace registry.
xo_prefix = hashlib.sha512('xo'.encode("utf-8")).hexdigest()[0:6]
handler = XoTransactionHandler(namespace_prefix=xo_prefix)
processor.add_handler(handler)
try:
processor.start()
except KeyboardInterrupt:
pass
finally:
processor.stop()
def main(args=None):
if args is None:
args = sys.argv[1:]
opts = parse_args(args)
processor = None
try:
processor = TransactionProcessor(url=opts.connect)
log_config = get_log_config(filename="battleship_log_config.toml")
# If no toml, try loading yaml
if log_config is None:
log_config = get_log_config(filename="battleship_log_config.yaml")
if log_config is not None:
log_configuration(log_config=log_config)
else:
log_dir = get_log_dir()
# use the transaction processor zmq identity for filename
log_configuration(
log_dir=log_dir,
name="battleship-" + str(processor.zmq_id)[2:-1])
init_console_logging(verbose_level=opts.verbose)
# The prefix should eventually be looked up from the
# validator's namespace registry.
battle_ship_prefix = \
hashlib.sha512('battleship'.encode("utf-8")).hexdigest()[0:6]
handler = \
BattleshipTransactionHandler(namespace_prefix=battle_ship_prefix)
processor.add_handler(handler)
processor.start()
except KeyboardInterrupt:
pass
except Exception as e: # pylint: disable=broad-except
print("Error: {}".format(e))
finally:
if processor is not None:
processor.stop()
def main(args=None):
if args is None:
args = sys.argv[1:]
opts = parse_args(args)
processor = None
try:
processor = TransactionProcessor(url=opts.connect)
init_console_logging(verbose_level=opts.verbose)
handler = TunachainTransactionHandler()
processor.add_handler(handler)
processor.start()
except KeyboardInterrupt:
pass
except Exception as err: # pylint: disable=broad-except
print("Error: {}".format(err))
finally:
if processor is not None:
processor.stop()
def main(args=None):
if args is None:
args = sys.argv[1:]
opts = parse_args(args)
processor = None
try:
arg_config = create_xo_config(opts)
xo_config = load_xo_config(arg_config)
processor = TransactionProcessor(url=xo_config.connect)
log_config = get_log_config(filename="xo_log_config.toml")
# If no toml, try loading yaml
if log_config is None:
log_config = get_log_config(filename="xo_log_config.yaml")
if log_config is not None:
log_configuration(log_config=log_config)
else:
log_dir = get_log_dir()
# use the transaction processor zmq identity for filename
log_configuration(
log_dir=log_dir,
name="xo-" + str(processor.zmq_id)[2:-1])
init_console_logging(verbose_level=opts.verbose)
handler = XoTransactionHandler()
processor.add_handler(handler)
processor.start()
except KeyboardInterrupt:
pass
except Exception as e: # pylint: disable=broad-except
print("Error: {}".format(e))
finally:
if processor is not None:
processor.stop()
class DistributedManager(DistributedManagerInterface):
def __init__(self, conf: DistributedManagerConfig):
super().__init__(conf)
self.conf = conf
# Set up transaction processor
self.transaction_processor = TransactionProcessor(
url=conf.VALIDATOR_URL)
self.handler = CCellularHandler(conf)
self.handler.set_apply_callback(self.report_update)
self.transaction_processor.add_handler(self.handler)
self.client = CCellularClient(conf)
# Set loggers
self.handler.logger = self.log
self.client.logger = self.log
self.trigger_callback_func = None
# Blocking function that runs the transaction processor
def run_main(self):
print("Running dAuth Transaction Processor, Ctr-c to stop")
self.transaction_processor.start() # blocking
print("\nStopping")
self.transaction_processor.stop() # make sure to close out connection
# called on startup from central manager
def _start(self):
self.log("Connecting to validator at " + str(self.conf.VALIDATOR_URL))
# send a thread to the transaction batcher
self.client.start_batcher(self.is_running)
# Get the entry from system state
def get_entry(self, key):
self.log("Getting entry for key: " + str(key))
return self.client.get(key)
# Update the entry in the system state
def update_entry(self, entry: DatabaseEntry):
self.log("Updating entry: " + str(entry.to_dict()))
self.client.set_entry(entry)
# Returns all key values from the system state
def get_all_keys(self):
self.log("Retrieving all keys")
return self.client.get_all()
# Sets a callback function called when new data is available
# for a given key (the key is passed as an arg to the callback)
def set_report_callback(self, callback_func):
self.log("Report callback set")
self.trigger_callback_func = callback_func
# Called when new data is available for a key, and will pass
# the key back through the callback function if it is set
def report_update(self, key):
self.log("New update reported: " + str(key))
if self.trigger_callback_func:
self.trigger_callback_func(key)
# Returns the number of all keys available
def count(self):
return len(self.get_all_keys())
def is_running(self):
return self._running
from sawtooth_sdk.processor.core import TransactionProcessor
from hw_transhand import HwTransHand
import argparse
#add a processor handler
parser = argparse.ArgumentParser()
parser.add_argument("url")
args = parser.parse_args()
processor = TransactionProcessor(url=args.url)
handler = HwTransHand()
processor.add_handler(handler)
processor.start()
def deployProcessor(Class,url): processor = TransactionProcessor(url) handler = Class() processor.add_handler(handler) processor.start()
def processor_main():
print("VERBOSE : Processor Began")
tp = TransactionProcessor(url='tcp://validator:4004')
handler = tf_Digital_ID()
tp.add_handler(handler)
tp.start()
TP_HANDLERS = [AccountHandler(), PubKeyHandler(), AtomicSwapHandler()]
if __name__ == '__main__':
config = load_toml_with_defaults(
'/config/remme-client-config.toml')['remme']['client']
parser = argparse.ArgumentParser(description='Transaction processor.')
parser.add_argument('-v', '--verbosity', type=int, default=2)
parser.add_argument('--account', action='store_true')
parser.add_argument('--atomic-swap', action='store_true')
parser.add_argument('--pubkey', action='store_true')
args = parser.parse_args()
setup_logging('remme', args.verbosity)
processor = TransactionProcessor(
url=f'tcp://{ config["validator_ip"] }:{ config["validator_port"] }')
if args.account:
processor.add_handler(AccountHandler())
if args.atomic_swap:
processor.add_handler(AtomicSwapHandler())
if args.pubkey:
processor.add_handler(PubKeyHandler())
try:
processor.start()
except KeyboardInterrupt:
pass
finally:
processor.stop()
import logging
_logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG) # TODO: The logger must be configured with sawthooth tools. Validator container has the correct configuration
if __name__ == '__main__':
_logger.info('Initializing transactions families')
tools = Tools(sys.argv[1:]) # TODO: This class implements methods to load configuration variables. Must be reemplaced with sawthooth tools
try:
validator_url = tools.config['validator_url'] if 'validator_url' in tools.config.keys() else os.environ['HOSTNAME']
families_directories = tools.config['addons_path']
if isinstance(tools.config['addons_path'], str):
families_directories = [tools.config['addons_path']]
for path in families_directories:
_logger.info('Searching families in {}. Linking with validator_url {}'.format(path, validator_url))
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
plugins_directory_path = os.path.join(SCRIPT_DIR, path)
families = tools.import_plugins(plugins_directory_path, path.replace(os.path.sep, '.'), TransactionHandlerBase)
processor = TransactionProcessor(url=validator_url) # TODO: Sawthooth have configuration files, utilize it
for family in families:
_logger.info('Loading Transaction procesor for family {}'.format(family.family_name))
processor.add_handler(family)
processor.start()
except KeyboardInterrupt:
pass
except SystemExit as err:
raise err
except BaseException as err:
traceback.print_exc(file=sys.stderr)
sys.exit(1)
