def main(self, src, dst):
with ClientToServerLink() as server:
info = server.validate_image_cp(src, dst)
if info == None:
return
if info['status'] == 'NEEDS_CONFIRM':
if confirm():
info['status'] = 'OK'
else:
return # give up
if info['status'] == 'FAILED':
return
session_info = server.create_image_shell_session(
info['image_name'], 'file transfer')
if session_info == None:
return # issue already reported
session_id, image_fullname, container_name, default_new_name = \
session_info
info.update(image_fullname = image_fullname,
container_name = container_name)
try:
run_transfer_with_image(**info)
if info['client_operand_index'] == 0:
# client was sending -> image has been modified
# save the image under the same name
server.image_shell_session_save(
session_id, default_new_name, True)
except (KeyboardInterrupt, EOFError):
print()
print('Aborted.')
def main(self, logline_regexp):
if not WalTLogShowOrWait.verify_regexps(self.streams, logline_regexp):
return
with ClientToServerLink() as server:
senders = server.parse_set_of_nodes(self.set_of_nodes)
if senders == None:
return
if self.time_margin != 0:
history_range = '-%ds:' % self.time_margin
range_analysis = WalTLogShowOrWait.analyse_history_range(server, history_range)
history_range = range_analysis[1]
else:
history_range = None
if self.mode == 'ANY':
# as soon as a logline matches, we stop
def stop_test(**record):
return True
else:
# we stop when all nodes have emitted a matching logline
missing_senders = set(senders)
def stop_test(**record):
missing_senders.discard(record['sender'])
if len(missing_senders) == 0:
return True # yes, we should stop
else:
return False # no, we are not done yet
WalTLogShowOrWait.start_streaming(self.format_string, history_range, True,
senders, self.streams, logline_regexp, stop_test, self.timeout)
def main(self, src, dst):
with ClientToServerLink() as server:
info = server.validate_node_cp(src, dst)
if info == None:
return
if info['status'] == 'NEEDS_CONFIRM':
if confirm():
info['status'] = 'OK'
else:
return # give up
if info['status'] == 'FAILED':
return
node_name = info['node_name']
WalTNode.wait_for_nodes(server, node_name)
if dst == 'booted-image':
path_info = dict(src_path=info['src_path'],
dst_dir=info['dst_dir'],
dst_name=info['dst_name'])
server.node_cp_to_booted_image(node_name, **path_info)
else:
try:
run_transfer_with_node(**info)
except (KeyboardInterrupt, EOFError):
print()
print('Aborted.')
def main(self, image_name):
with ClientToServerLink() as server:
session_info = server.create_image_shell_session(
image_name, 'shell session')
if session_info == None:
return # issue already reported
session_id, image_fullname, container_name, default_new_name = \
session_info
run_image_shell_prompt(image_fullname, container_name)
try:
while True:
new_name = input(\
'New image name [%s]: ' % default_new_name)
if new_name == '':
new_name = default_new_name
print('Selected: %s' % new_name)
res = server.image_shell_session_save(session_id,
new_name,
name_confirmed=False)
if res == 'NAME_NOT_OK':
continue
if res == 'NAME_NEEDS_CONFIRM':
if confirm(komsg=None):
server.image_shell_session_save(
session_id, new_name, name_confirmed=True)
else:
continue
break
except (KeyboardInterrupt, EOFError):
print('Aborted.')
def main(self, logline_regexp = None):
if self.realtime == False and self.history_range == 'none':
print('You must specify at least 1 of the options --realtime and --history.')
print("See 'walt help show log-realtime' and 'walt help show log-history' for more info.")
return
if not WalTLogShowOrWait.verify_regexps(self.streams, logline_regexp):
return
with ClientToServerLink() as server:
senders = server.parse_set_of_nodes(self.set_of_nodes)
if senders == None:
return
range_analysis = WalTLogShowOrWait.analyse_history_range(server, self.history_range)
if not range_analysis[0]:
print('''Invalid HISTORY_RANGE. See 'walt help show log-history' for more info.''')
return
history_range = range_analysis[1]
# Note : if a regular expression is specified, we do not bother computing the number
# of log records, because this computation would be too expensive, and the number of
# matching lines is probably low.
if history_range and logline_regexp is None and isatty():
num_logs = server.count_logs(history = history_range, senders = senders, streams = self.streams)
if num_logs > NUM_LOGS_CONFIRM_TRESHOLD:
print('This will display approximately %d log records from history.' % num_logs)
if not confirm():
return
WalTLogShowOrWait.start_streaming(self.format_string, history_range, self.realtime,
senders, self.streams, logline_regexp, None)
def main(self, device_set, *configuration):
with ClientToServerLink() as server:
device_set = server.develop_device_set(device_set)
if device_set is None:
return
if not WalTDevice.confirm_devices_not_owned(server, device_set):
return
server.set_device_config(device_set, configuration)
def main(self, node_name, node_port, local_port):
node_ip = None
with ClientToServerLink() as server_link:
node_ip = server_link.get_node_ip(node_name)
if not node_ip:
return
WalTNode.wait_for_nodes(server_link, node_name)
print('Listening on TCP port %d and redirecting connections to %s:%d.' % \
(local_port, node_name, node_port))
exposer = TCPExposer(local_port, node_ip, node_port)
exposer.run()
def main(self):
with ClientToServerLink() as server:
script_content = server.get_vpn_proxy_setup_script()
with open('proxy-setup.sh', 'w') as f:
f.write(script_content)
os.fchmod(f.fileno(), 0o755) # set it executable
print(
"A script 'proxy-setup.sh' has been generated in current directory."
)
print(
"Copy and run it on the host you want to use as a walt vpn proxy.")
def main(self, other_user):
if not self._force:
print("""\
This will make you own all images of user '%s'. It is intended
for maintenance only (i.e. if user '%s' is no longer working with
walt).
If this is really what you want, run:
walt advanced fix-image-owner --yes-i-know-do-it-please %s
""" % ((other_user, ) * 3))
else:
with ClientToServerLink() as server:
server.fix_image_owner(other_user)
def main(self, device_set, *configuration):
with ClientToServerLink() as server:
device_set = server.develop_device_set(device_set)
if device_set is None:
return
if len(configuration) > 0:
if not WalTDevice.confirm_devices_not_owned(server, device_set):
return
server.set_device_config(device_set, configuration)
else:
# no settings specified => list current settings
server.get_device_config(device_set)
def run():
try:
init_config()
with ClientToServerLink() as server:
check_auto_update(server, 'walt-client')
WalT.run()
except socket.error:
sys.exit('Network connection to WalT server failed!')
except LinkException:
sys.exit('Issue occured while communicating with WalT server!')
except KeyboardInterrupt:
print()
sys.exit('Aborted.')
def main(self, src, dst):
with ClientToServerLink() as server:
info = server.validate_node_cp(src, dst)
if info == None:
return
if not info['node_owned'] and not confirm():
return
node_name = info['node_name']
WalTNode.wait_for_nodes(server, node_name)
try:
run_transfer_with_node(**info)
except (KeyboardInterrupt, EOFError):
print()
print('Aborted.')
def boot_nodes(node_set, image_name_or_default):
with ClientToServerLink() as server:
if server.has_image(image_name_or_default, True):
# the list of nodes the keyword "my-nodes" refers to
# may be altered by the server.set_image() call, thus
# we have to get a real list of nodes before starting
# anything.
node_set = server.develop_node_set(node_set)
if node_set is None:
return
if not WalTDevice.confirm_devices_not_owned(server, node_set):
return
if not server.set_image(node_set, image_name_or_default):
return
server.reboot_nodes(node_set)
def main(self, node_name, duration=60):
try:
seconds = int(duration)
except:
sys.stderr.write(
'<duration> must be an integer (number of seconds).\n')
else:
with ClientToServerLink() as server:
WalTNode.wait_for_nodes(server, node_name)
if server.blink(node_name, True):
print('blinking for %ds... ' % seconds)
try:
time.sleep(seconds)
print('done.')
except KeyboardInterrupt:
print('Aborted.')
finally:
server.blink(node_name, False)
def main(self, checkpoint_name):
if self.date:
try:
self.date = pickle.dumps(datetime.datetime.strptime(\
self.date, DATE_FORMAT_STRING))
except:
print('Could not parse the date specified.')
print('Expected format is: %s' % DATE_FORMAT_STRING_HUMAN)
print('Example: %s' % DATE_FORMAT_STRING_EXAMPLE)
return
if not validate_checkpoint_name(checkpoint_name):
sys.stderr.write("""\
Invalid checkpoint name:
* Only alnum and dash(-) characters are allowed.
* dash(-) is not allowed as the 1st character.
""")
return
with ClientToServerLink() as server:
server.add_checkpoint(checkpoint_name, self.date)
def main(self, checkpoint_name):
with ClientToServerLink() as server:
if self.date:
if self.date.startswith('-'):
server_time = pickle.loads(server.get_pickled_time())
self.date = compute_relative_date(server_time, self.date)
else:
try:
self.date = pickle.dumps(datetime.datetime.strptime(\
self.date, DATE_FORMAT_STRING))
except:
print('Could not parse the date specified.')
print('Expected format is: %s' % DATE_FORMAT_STRING_HUMAN)
print('Example: %s' % DATE_FORMAT_STRING_EXAMPLE)
return
if not validate_checkpoint_name(checkpoint_name):
sys.stderr.write(MSG_INVALID_CHECKPOINT_NAME)
return
server.add_checkpoint(checkpoint_name, self.date)
def main(self):
with ClientToServerLink() as server:
while True:
server.set_busy_label(WAIT_VPN_BUSY_LABEL)
try:
device_mac = server.vpn_wait_grant_request()
except KeyboardInterrupt:
print()
break
print('New VPN access request from device ' + device_mac + '.')
grant_ok = yes_or_no(
'Should this device be granted VPN access?')
print('Transmitting to walt server...')
server.set_default_busy_label()
result, comment = server.vpn_respond_grant_request(
device_mac, grant_ok)
if result == 'OK':
print(comment)
else:
print('FAILED! ' + comment)
def run_cmd(node_set, several_nodes_allowed, cmdargs,
startup_msg = None, tty = False):
nodes_ip = None
with ClientToServerLink() as server:
if not WalTDevice.confirm_devices_not_owned(server, node_set):
return
nodes_ip = server.get_nodes_ip(node_set)
if len(nodes_ip) == 0:
return # issue already reported
elif len(nodes_ip) > 1 and not several_nodes_allowed:
sys.stderr.write(
'Error: this command must target 1 node only.\n')
return
WalTNode.wait_for_nodes(server, node_set)
server.prepare_ssh_access(node_set)
if nodes_ip:
for ip in nodes_ip:
if startup_msg:
print(startup_msg)
run_node_cmd(ip, cmdargs, tty)
def main(self, device_name):
with ClientToServerLink() as server:
# check if server knows this device
device_info = server.get_device_info(device_name)
if device_info == None:
return # issue already reported
device_info = deserialize_ordered_dict(device_info)
if device_info['type'] == 'node' and device_info['virtual']:
print(MSG_USE_WALT_NODE_REMOVE % dict(node=device_name))
return
if not self._force:
logs_cnt = server.count_logs(history=(None, None),
senders=set([device_name]))
if logs_cnt > 0:
print(MSG_FORGET_DEVICE_WITH_LOGS %
(device_name, logs_cnt, device_name))
return # give up for now
# ok, do it
server.forget(device_name)
print('done.')
def main(self, device_name):
with ClientToServerLink() as server:
device_info = server.get_device_info(device_name)
device_info = deserialize_ordered_dict(device_info)
device_type = device_info['type']
if not device_type:
return # issue already reported
if device_type not in ('unknown', 'switch'):
print(MSG_NOT_APPLICABLE %
dict(device_name=device_name, device_type=device_type))
return
if device_type == 'unknown':
print('WalT could not autodetect the type of this device.\n')
if yes_or_no('Is it a network switch?',
komsg='Nothing to do.'):
device_type = 'switch'
if device_type == 'switch':
conf = ask_switch_conf(device_info)
if conf == None:
return
conf = serialize_ordered_dict(conf)
server.apply_switch_conf(device_name, conf)
def test_config(conf, credentials_check):
# we try to establish a connection to the server,
# and optionaly to connect to the docker hub.
config.set_conf(conf)
try:
with ClientToServerLink() as server:
if credentials_check:
server.set_busy_label('Authenticating to the docker hub')
auth_conf = get_auth_conf(server)
if not server.docker_login(auth_conf):
print('Re-trying...')
del conf['username']
del conf['password']
return False
except socket.error:
print('Network connection to WalT server failed.')
print(
'The value of \'server\' you entered seems invalid (or the server is down?). Re-trying...'
)
del conf['server']
return False
return True
def main(self):
with ClientToServerLink() as server:
server.list_checkpoints()
def main(self, clonable_image_link):
with ClientToServerLink() as server_link:
server_link.set_busy_label('Validating / Cloning')
server_link.clone_image(clonable_image_link, self._force)
def main(self, device_name):
device_ip = None
with ClientToServerLink() as server:
device_ip = server.get_device_ip(device_name)
if device_ip:
run_device_ping(device_ip)
def main(self, checkpoint_name):
with ClientToServerLink() as server:
server.remove_checkpoint(checkpoint_name)
def main(self, image_name):
with ClientToServerLink() as server:
server.remove_image(image_name)
def main(self, image_name, new_image_name):
with ClientToServerLink() as server:
server.duplicate_image(image_name, new_image_name)
def main(self):
with ClientToServerLink() as server:
print(server.show_images(self._refresh))
def main(self, image_name):
with ClientToServerLink() as server_link:
server_link.set_busy_label('Validating / Publishing')
auth_conf = get_auth_conf(server_link)
server_link.publish_image(auth_conf, image_name)
def main(self, keyword=None):
with ClientToServerLink() as server_link:
server_link.set_busy_label('Searching')
tty_mode = os.isatty(sys.stdout.fileno())
server_link.search_images(keyword, tty_mode)