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)