def main():
parser = utils.build_parser("List offers")
args = parser.parse_args()
subnet = args.subnet_tag
sys.stderr.write(
f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n"
)
enable_default_logger()
try:
asyncio.get_event_loop().run_until_complete(
asyncio.wait_for(
list_offers(
Configuration(),
subnet_tag=subnet,
),
timeout=4,
))
except TimeoutError:
pass
def main():
import pathlib
import sys
parent_directory = pathlib.Path(__file__).resolve().parent.parent
sys.stderr.write(f"Adding {parent_directory} to sys.path.\n")
sys.path.append(str(parent_directory))
import utils
parser = utils.build_parser("List offers")
args = parser.parse_args()
subnet = args.subnet_tag
sys.stderr.write(f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n")
enable_default_logger()
try:
asyncio.get_event_loop().run_until_complete(
asyncio.wait_for(list_offers(Configuration(), subnet_tag=subnet,), timeout=4,)
)
except TimeoutError:
pass
if 'pc' in loaded[ref_out_layer]:
ref_pc = loaded[ref_out_layer]['pc']
performance_metrics(pc=pc, ref_pc=ref_pc)
blob_counters(out_blob=out_blob, ref_out_blob=ref_out_blob)
global_accuracy = update_global_accuracy_matrics(global_accuracy=global_accuracy, current_accuracy=a_m)
print_all_over_the_net_metrics(global_accuracy=global_accuracy)
def main(args):
log.info('Inference Engine:\n API version ............ {}'.format(ie.__version__), extra={'no_lvl': True})
set_verbosity(args.verbosity)
mode = find_out_cct_mode(args)
if mode == 1:
log.info('Cross check with one IR was enabled')
one_ir_mode(args)
elif mode == 2:
log.info('Cross check with two IRs was enabled')
two_ir_mode(args)
elif mode == 3:
log.info('Dump mode was enabled')
dump_mode(args)
elif mode == 4:
log.info('Load mode was enabled')
load_mode(args)
log.info("Execution successful")
if __name__ == '__main__':
set_logger(log.DEBUG)
main(validate_args(build_parser().parse_args()))
timeout=timedelta(minutes=25),
subnet_tag=args.subnet_tag,
event_emitter=log_summary(log_event_repr),
) as engine:
inputs = range(2)
async for task in engine.map(
worker, [Task(data=graphInput) for graphInput in inputs]):
print(f"{utils.TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.output}"
f"{utils.TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = utils.build_parser("script")
parser.add_argument("--number-of-providers",
dest="number_of_providers",
type=int,
default=2)
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
sys.stderr.write(
f"Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n"
)
loop = asyncio.get_event_loop()
task = loop.create_task(main(args))
try:
# Generate a new set of images on the Golem network
max_workers=3,
budget=10.0,
timeout=init_overhead + timedelta(minutes=len(frames) * 2),
subnet_tag=subnet_tag,
event_emitter=log_summary(log_event_repr),
) as engine:
async for task in engine.map(worker,
[Task(data=frame) for frame in frames]):
print(f"{utils.TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.output}"
f"{utils.TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = utils.build_parser("Render blender scene")
parser.set_defaults(log_file="blender-yapapi.log")
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
loop = asyncio.get_event_loop()
subnet = args.subnet_tag
sys.stderr.write(
f"yapapi version: {utils.TEXT_COLOR_YELLOW}{yapapi.__version__}{utils.TEXT_COLOR_DEFAULT}\n"
)
sys.stderr.write(
f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n"
)
task = loop.create_task(main(subnet_tag=args.subnet_tag))
try:
asyncio.get_event_loop().run_until_complete(task)
async for task in engine.map(worker,
[Task(data=date) for date in days]):
print(
f'\033[36;1mTask computed: {task}, result: {task.output}\033[0m'
)
gif_name = './covid.gif'
generate_gif(gif_name)
print(f'{utils.TEXT_COLOR_GREEN}'
f'gif generated: {gif_name}'
f'{utils.TEXT_COLOR_DEFAULT}')
if __name__ == '__main__':
parser = utils.build_parser('covid')
parser.add_argument('--workers', type=int, default=2)
parser.add_argument('--parameter', type=str, default='new_deaths')
parser.add_argument('--start', type=str, default='2020-10-01')
parser.add_argument('--end', type=str, default='2020-10-20')
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
sys.stderr.write(
f'Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n'
)
Path('outputs').mkdir(parents=True, exist_ok=True)
)
async for task in completed_tasks:
num_tasks += 1
print(
f"{TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.result}, time: {task.running_time}"
f"{TEXT_COLOR_DEFAULT}")
print(
f"{TEXT_COLOR_CYAN}"
f"{num_tasks} tasks computed, total time: {datetime.now() - start_time}"
f"{TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = build_parser("Send a drone task")
now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
parser.set_defaults(log_file=f"drone-yapapi-{now}.log")
args = parser.parse_args()
# This is only required when running on Windows with Python prior to 3.8:
windows_event_loop_fix()
enable_default_logger(
log_file=args.log_file,
debug_activity_api=True,
debug_market_api=True,
debug_payment_api=True,
)
loop = asyncio.get_event_loop()
TEXT_COLOR_RED,
TEXT_COLOR_YELLOW,
print_env_info,
run_golem_example,
)
HASHCAT_ATTACK_MODE = 3 # stands for mask attack, hashcat -a option
KEYSPACE_OUTPUT_PATH = Path("/golem/output/keyspace")
# Ideally, this value should depend on the chunk size
MASK_ATTACK_TIMEOUT: timedelta = timedelta(minutes=30)
KEYSPACE_TIMEOUT: timedelta = timedelta(minutes=10)
# Enough timeout for two attempts
KEYSPACE_TIMEOUT_ALL_TASKS: timedelta = KEYSPACE_TIMEOUT * 2.1
arg_parser = build_parser("Run a hashcat attack (mask mode) on Golem network.")
arg_parser.set_defaults(
log_file=f"hashcat-yapapi-{datetime.now().strftime('%Y-%m-%d_%H.%M.%S')}.log"
)
arg_parser.epilog = (
"Example invocation: ./yacat.py --mask '?a?a?a' --hash '$P$5ZDzPE45CLLhEx/72qt3NehVzwN2Ry/'"
)
arg_parser.add_argument("--hash", type=str, help="Target hash to be cracked", required=True)
arg_parser.add_argument(
"--mask",
type=str,
help="Hashcat mask to be used for the attack. Example: a value of '?a?a?a' will "
"try all 3-character combinations, where each character is mixalpha-numeric "
"(lower and upper-case letters + digits) or a special character",
required=True,
)
num_tasks += 1
print(
f"{TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.result}, time: {task.running_time}"
f"{TEXT_COLOR_DEFAULT}"
)
print(
f"{TEXT_COLOR_CYAN}"
f"{num_tasks} tasks computed, total time: {datetime.now() - start_time}"
f"{TEXT_COLOR_DEFAULT}"
)
if __name__ == "__main__":
parser = build_parser("Render a Blender scene")
parser.set_defaults(log_file="blender-yapapi.log")
args = parser.parse_args()
# This is only required when running on Windows with Python prior to 3.8:
windows_event_loop_fix()
enable_default_logger(
log_file=args.log_file,
debug_activity_api=True,
debug_market_api=True,
debug_payment_api=True,
)
loop = asyncio.get_event_loop()
task = loop.create_task(
else:
distance = (count - numSteps / 2) / (numSteps / 2)
secondFrequency = interpolate(16, 10, distance)
smoothness = interpolate(3, 10, distance)
inputs.append((filename, step, secondFrequency, smoothness))
async for task in engine.map(worker, [Task(data=graphInput) for graphInput in inputs]):
print(
f"{utils.TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.output}"
f"{utils.TEXT_COLOR_DEFAULT}"
)
if __name__ == "__main__":
parser = utils.build_parser("golemGraph")
parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=4)
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
sys.stderr.write(
f"Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n"
)
loop = asyncio.get_event_loop()
task = loop.create_task(main(args))
try:
# Generate a new set of images on the Golem network
loop.run_until_complete(task)
# Combine them locally
renderAnimation()
max_workers=8,
budget=100.0,
timeout=timedelta(minutes=3) + timedelta(minutes=10),
subnet_tag=subnet_tag,
event_emitter=log_summary(log_event_repr),
) as engine:
async for task in engine.map(worker,
[Task(data=feed) for feed in feeds]):
print(f"{utils.TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.output}"
f"{utils.TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = utils.build_parser("Simulate a strong gravitational lensing")
parser.set_defaults()
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
loop = asyncio.get_event_loop()
subnet = args.subnet_tag
sys.stderr.write(
f"yapapi version: {utils.TEXT_COLOR_YELLOW}{yapapi.__version__}{utils.TEXT_COLOR_DEFAULT}\n"
)
sys.stderr.write(
f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n"
)
task = loop.create_task(main(subnet_tag=args.subnet_tag))
try:
asyncio.get_event_loop().run_until_complete(task)
await proxy.stop()
print(f"{TEXT_COLOR_CYAN}HTTP server stopped{TEXT_COLOR_DEFAULT}")
cluster.stop()
cnt = 0
while cnt < 3 and any(s.is_available for s in instances):
print(instances)
await asyncio.sleep(5)
cnt += 1
await network.remove()
if __name__ == "__main__":
parser = build_parser("An extremely simple http proxy")
parser.add_argument(
"--num-instances",
type=int,
default=2,
help="The number of instances of the http service to spawn",
)
parser.add_argument(
"--port",
type=int,
default=8080,
help="The local port to listen on",
)
parser.add_argument(
"--running-time",
default=600,
payment_driver=payment_driver,
payment_network=payment_network,
) as golem:
print_env_info(golem)
print(
f"{TEXT_COLOR_YELLOW}Scanning {pluralize(scan_size, 'node')}, "
f"using {pluralize(max_workers, 'concurrent worker')}.{TEXT_COLOR_DEFAULT}"
)
tasks: List[Task] = [Task(i) for i in range(scan_size)]
async for task in golem.execute_tasks(worker, tasks, payload, max_workers=max_workers):
print(f"{TEXT_COLOR_MAGENTA}{task.result}{TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = build_parser("Scan providers")
parser.add_argument("--scan-size", help="Number of nodes to scan", type=int, default=5)
parser.add_argument(
"--max-workers", help="Number of scans at the same time", type=int, default=3
)
now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
parser.set_defaults(log_file=f"scan-yapapi-{now}.log")
args = parser.parse_args()
run_golem_example(
main(
scan_size=args.scan_size,
max_workers=args.max_workers,
subnet_tag=args.subnet_tag,
payment_driver=args.payment_driver,
payment_network=args.payment_network,
print(f"{TEXT_COLOR_CYAN}HTTP server stopped{TEXT_COLOR_DEFAULT}")
web_cluster.stop()
db_cluster.stop()
cnt = 0
while cnt < 3 and any(
s.is_available
for s in web_cluster.instances + db_cluster.instances):
print(web_cluster.instances + db_cluster.instances)
await asyncio.sleep(5)
cnt += 1
if __name__ == "__main__":
parser = build_parser("Golem simple Web app example")
parser.add_argument(
"--port",
type=int,
default=8080,
help="The local port to listen on",
)
now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
parser.set_defaults(log_file=f"webapp-yapapi-{now}.log")
args = parser.parse_args()
run_golem_example(
main(
subnet_tag=args.subnet_tag,
payment_driver=args.payment_driver,
payment_network=args.payment_network,
print(f"{TEXT_COLOR_YELLOW}Stopping {cluster}...{TEXT_COLOR_DEFAULT}")
cluster.stop()
# wait for instances to stop
cnt = 0
while cnt < 10 and any(s.is_available for s in cluster.instances):
print_instances()
await asyncio.sleep(5)
print_instances()
if __name__ == "__main__":
parser = build_parser(
"A very simple / POC example of a service running on Golem, utilizing the VM runtime"
)
parser.add_argument(
"--running-time",
default=120,
type=int,
help=(
"How long should the instance run before the cluster is stopped "
"(in seconds, default: %(default)s)"
),
)
parser.add_argument(
"--num-instances",
type=int,
default=1,
help="The number of instances of the service to spawn",
f"{utils.TEXT_COLOR_DEFAULT}")
password = read_password(ranges)
if password is None:
print(
f"{utils.TEXT_COLOR_RED}No password found{utils.TEXT_COLOR_DEFAULT}"
)
else:
print(f"{utils.TEXT_COLOR_GREEN}"
f"Password found: {password}"
f"{utils.TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = utils.build_parser("yacat")
parser.add_argument("--number-of-providers",
dest="number_of_providers",
type=int,
default=3)
parser.add_argument("mask")
parser.add_argument("hash")
args = parser.parse_args()
# This is only required when running on Windows with Python prior to 3.8:
windows_event_loop_fix()
enable_default_logger(log_file=args.log_file)
password = read_password(task.data)
if password:
break
if password is None:
print(f"{utils.TEXT_COLOR_RED}No password found{utils.TEXT_COLOR_DEFAULT}")
else:
print(
f"{utils.TEXT_COLOR_GREEN}"
f"Password found: {password}"
f"{utils.TEXT_COLOR_DEFAULT}"
)
if __name__ == "__main__":
parser = utils.build_parser("john")
parser.add_argument("--number-of-providers", dest="number_of_providers", type=int, default=3)
parser.add_argument("hash")
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
sys.stderr.write(
f"Using subnet: {utils.TEXT_COLOR_YELLOW}{args.subnet_tag}{utils.TEXT_COLOR_DEFAULT}\n"
)
Path('logs').mkdir(parents=True, exist_ok=True)
Path('logs').mkdir(parents=True, exist_ok=True)
print('Document created successfully')
print('You can access your document here:', url)
pid_path = config[MAIN_SECTION][utils.Section.PID_PATH]
sleep_time = int(config[MAIN_SECTION][utils.Section.SLEEP_TIME])
with daemon.DaemonContext(
working_directory='./',
umask=0o002,
files_preserve=[handler.stream],
stderr=handler.stream,
pidfile=pidfile.PIDLockFile(pid_path),
):
logger.info('Starting daemon')
while True:
logger.info('Running gdoc process.')
_run()
time.sleep(sleep_time)
if __name__ == '__main__':
args = utils.build_parser()
if args.mode == 'start':
start_daemon_process()
elif args.mode == 'stop':
stop()
elif args.mode == 'restart':
stop()
start_daemon_process()
else:
raise ValueError('Invalid mode.')
max_workers=10,
budget=20.0,
timeout=init_overhead,
subnet_tag=subnet_tag,
event_emitter=log_summary(log_event_repr),
) as engine:
async for task in engine.map(
worker, [Task(data=preset) for preset in preset_list]):
print(f"{utils.TEXT_COLOR_CYAN}"
f"Task computed: {task}, result: {task.output}"
f"{utils.TEXT_COLOR_DEFAULT}")
if __name__ == "__main__":
parser = utils.build_parser("Video Transcoder")
parser.add_argument(
"--presets",
default="Fast 480p30",
help=
"HandBrakeCLI transcode preset; can pass multiple separated by comma; default: %(default)s"
)
parser.add_argument("--job",
default="0",
help="An optional job ID; default: %(default)s")
parser.add_argument("input_file")
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
loop = asyncio.get_event_loop()
subnet = args.subnet_tag
for i in range(node_count):
output_file = f"out_{str(i+1)}.txt"
with open(output_file) as f:
lines = f.readlines()
echoer_message = f"Ripper {i+1} did not find the password"
for line in lines:
if "?" in line:
echoer_message = f"{utils.TEXT_COLOR_GREEN}Worker {i+1} found the password: {line[2:].strip()}{utils.TEXT_COLOR_DEFAULT}"
break
print(echoer_message)
if __name__ == "__main__":
parser = utils.build_parser("John the Ripper")
parser.add_argument("node_count")
parser.add_argument("timeout_seconds")
parser.add_argument("password")
parser.set_defaults(log_file="john.log",
node_count="4",
timeout_seconds="5",
password="******")
args = parser.parse_args()
enable_default_logger(log_file=args.log_file)
loop = asyncio.get_event_loop()
subnet = args.subnet_tag
sys.stderr.write(
f"yapapi version: {utils.TEXT_COLOR_YELLOW}{yapapi.__version__}{utils.TEXT_COLOR_DEFAULT}\n"
)
password = read_password(ranges)
if password is None:
print(f"{TEXT_COLOR_RED}No password found{TEXT_COLOR_DEFAULT}")
else:
print(
f"{TEXT_COLOR_GREEN}Password found: {password}{TEXT_COLOR_DEFAULT}"
)
print(
f"{TEXT_COLOR_CYAN}Total time: {datetime.now() - start_time}{TEXT_COLOR_DEFAULT}"
)
if __name__ == "__main__":
parser = build_parser("yacat")
parser.add_argument("--number-of-providers",
dest="number_of_providers",
type=int,
default=3)
parser.add_argument("mask")
parser.add_argument("hash")
args = parser.parse_args()
# This is only required when running on Windows with Python prior to 3.8:
windows_event_loop_fix()
enable_default_logger(log_file=args.log_file)
try:
await asyncio.sleep(5)
except (KeyboardInterrupt, asyncio.CancelledError):
break
cluster.stop()
cnt = 0
while cnt < 3 and any(s.is_available for s in instances):
print(instances)
await asyncio.sleep(5)
cnt += 1
if __name__ == "__main__":
parser = build_parser("Golem VPN SSH example")
parser.add_argument(
"--num-instances",
type=int,
default=2,
help="Number of instances to spawn",
)
now = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
parser.set_defaults(log_file=f"ssh-yapapi-{now}.log")
args = parser.parse_args()
run_golem_example(
main(
subnet_tag=args.subnet_tag,
payment_driver=args.payment_driver,
payment_network=args.payment_network,
if was_running and all([
s.state == ServiceState.terminated
for s in cluster.instances
]):
print_instances()
print("All services were successfully terminated")
break
if len(cluster.instances) > 0:
print_instances()
was_running = True
if __name__ == "__main__":
parser = build_parser("Custom Usage Counter Example")
parser.add_argument(
"--running-time",
default=30,
type=int,
help=
"How long should the the service run (in seconds, default: %(default)s)",
)
args = parser.parse_args()
enable_default_logger(
log_file=args.log_file,
debug_activity_api=True,
debug_market_api=True,
debug_payment_api=True,
)
asyncio.run(
