def execute_command(command: str, sudo=False, host='localhost', user=None, password=None, port=None): """ Execute shell command in local or remote server :param sudo: True/False, execute as sudo :param host: host in which execute command :param user: ssh username :param password: ssh password :param port: ssh port :return: stdout and stderr in tuple, (None, None) if error """ regexp = '^localhost$|^127(?:\.[0-9]+){0,2}\.[0-9]+$|^(?:0*\:)*?:?0*1$' is_localhost = bool(re.search(regexp, host)) # Create fabric connection if is_localhost: conn = fabric.Connection(host) modified_command = 'sudo ' + command if sudo else command logger.info('Executing command " {} " in {} as sudo={}'.format(modified_command, host, sudo)) output = conn.local(modified_command) else: conn = fabric.Connection(host, user=user, port=port) if password and len(password) > 0: conn.connect_kwargs.look_for_keys = False conn.connect_kwargs.password = password logger.info('Executing command " {} " in {} as sudo={}'.format(command, host, sudo)) output = conn.sudo(command) if sudo else conn.run(command) return output.stdout, output.stderr
def execute_command_wrapper(command: str, sudo=False, host='localhost', user=None, password=None, port=None): regexp = '^localhost$|^127(?:\.[0-9]+){0,2}\.[0-9]+$|^(?:0*\:)*?:?0*1$' is_localhost = bool(re.search(regexp, host)) # Create fabric connection try: if is_localhost: conn = fabric.Connection(host) modified_command = 'sudo ' + command if sudo else command output = conn.local(modified_command) else: conn = fabric.Connection(host, user=user, port=port) if password and len(password) > 0: conn.connect_kwargs.look_for_keys = False conn.connect_kwargs.password = password conn.connect_kwargs.allow_agent = False output = conn.sudo(command) if sudo else conn.run(command) return output.stdout, output.stderr except Exception: logger.error(GenericErrorMessages.EXECUTED_COMMAND_ERROR, exc_info=True) return None, None
def connect(self) -> None: if not self.can_connect(): if not self.config: raise CouldNotConnectError("config missing!") raise CouldNotConnectError("config invalid!") current = dict( host=self.config.ip, user=self.config.user, port=self.config.port, connect_kwargs=dict(key_filename=str(self.keyfile)), connect_timeout=2, gateway=fabric.Connection(os.path.expandvars(self.config.gateway)) if "gateway" in self.config else None, ) if getattr(self, "_fabric_config", {}) != current: self._fabric_config = current self._connection = fabric.Connection(**self._fabric_config) self.connection.open() else: if not self.connection.is_connected: self.connection.open() assert self.connection, "backend must have a working underlying connection" self._connected = self.connection.is_connected if not self.connected: raise CouldNotConnectError(current)
def ssh_context(self): if self.ssh_host: return fabric.Connection(host=self.ssh_host, port=self.ssh_port, user=self.get_ssh_user()) else: # FIXME: Normalize local / SSH connections for different adaptors, this is doing an unneeded/invalid SSH connection return fabric.Connection(host="localhost")
def g5k_connection(cls, site, username): if 'grid5000' in socket.getfqdn( ): # already inside G5K, no need for a gateway connection = fabric.Connection(site, user=username) else: gateway = fabric.Connection('access.grid5000.fr', user=username) connection = fabric.Connection(site, user=username, gateway=gateway) return connection
def file_put(self, local_path, remote_path): final_path = os.path.join(self.path, remote_path) logger.debug("Writing file via SSH from %s to %s@%s:%s", local_path, self.get_user(), self.host, final_path) # Create dir dirname = os.path.dirname(final_path) with fabric.Connection(host=self.host, port=self.port, user=self.get_user()) as c: if self.sudo: c.sudo('mkdir -p "%s"' % dirname) else: c.run('mkdir -p "%s"' % dirname) with fabric.Connection(host=self.host, port=self.port, user=self.get_user()) as c: result = c.put(local_path, final_path)
def execute_command(command, sudo, host, user, port): regexp = '^localhost$|^127(?:\.[0-9]+){0,2}\.[0-9]+$|^(?:0*\:)*?:?0*1$' is_localhost = bool(re.search(regexp, host)) # Create fabric connection output = (None, None) if is_localhost: conn = fabric.Connection(host) modified_command = 'sudo ' + command if sudo else command output = conn.local(modified_command) else: conn = fabric.Connection(host, user=user, port=port) output = conn.sudo(command) if sudo else conn.run(command) return (output.stdout, output.stderr)
def delete_duplicates(*, source: Union[str, Path], target: Union[str, Path], server: Optional[Union[str, Path]], user: str = None, password: str = None, pattern: str = None, delete_target_duplicates: bool = False) -> None: """ Parameters ---------- source : Union[str, Path] target : Union[str, Path] server : Optional[Union[str, Path]] user: str password : str pattern: str delete_target_duplicates : bool Returns ------- None """ user = user or input("Username:"******"Password:"******"*.nc" connection = fabric.Connection(host=server, user=user, connect_kwargs=dict(password=password)) nc_files_source = Path(source).rglob(glob_pattern) nc_files_source = {f.stem for f in nc_files_source} nc_files_target = Path(target).rglob(glob_pattern) nc_file_duplicates = [] for f in nc_files_target: if f.name in nc_files_source: logging.info("Duplicate found: {}".format(f.name)) nc_file_duplicates.append(f) nc_file_duplicates.sort() logging.info("Found {} files totalling {}".format( len(nc_file_duplicates), report_file_size(nc_file_duplicates))) freed_space = 0 deleted_files = 0 if delete_target_duplicates: with connection as context: for dup in nc_file_duplicates: freed_space += Path(dup).stat().st_size logging.info("Deleting {}".format(dup.name)) context.remove(dup) deleted_files += 1 logging.info("Removed {} files totalling {}".format( deleted_files, report_file_size(freed_space))) return
def _dl_file(self, filename): fabric.Connection( self.dutusername + "@" + self.dutip, connect_kwargs={ "password": self.dutpassword }, ).get(filename)
def reboot_board(self, bypass_sleep=False): """ Reboot board over SSH, otherwise raise exception """ log.info("Rebooting board over SSH") # Try to reboot board with SSH if possible retries = 3 for t in range(retries): try: result = fabric.Connection( self.dutusername + "@" + self.dutip, connect_kwargs={ "password": self.dutpassword }, ).run("/sbin/reboot", hide=False) if result.ok: print("Rebooting board with SSH") if not bypass_sleep: time.sleep(30) break else: # Use PDU raise Exception("PDU reset not implemented yet") except Exception as ex: log.warning("Exception raised: " + str(ex)) time.sleep(3) if t >= (retries - 1): raise Exception("Exception occurred during SSH Reboot", str(ex))
def execute(cmd, command_ctx, connection_ctx): """ kwargs: fabric.Connection(host, user=None, port=None, config=None, gateway=None, forward_agent=None, connect_timeout=None, connect_kwargs=None, inline_ssh_env=None) """ with fabric.Connection(**connection_ctx) as c: res = c.run(cmd, **command_ctx) return res.return_code, res.stdout, res.stderr
def _connect(self): logger.debug("Opening ssh connection ... ") logger.debug("Trying '%s' key ... " % self.private_key ) private_key_path = expanduser(self.private_key) if ( (not exists( private_key_path)) and ('PRIVATE KEY' not in self.private_key) ): output = "'%s'key does not exist" % private_key_path raise ComException(output) logger.debug( "Connecting to '%s' as user '%s' port '%s' ..." % ( self.frontend, self.username, self.port ) ) if ':' in self.frontend: self.frontend, self.port = self.frontend.split( ':' ) try: self._conn = fabric.Connection( host=self.frontend, user=self.username, connect_kwargs={ "key_filename": private_key_path, }, connect_timeout=300 ) except Exception as err: logger.warning( "Error connecting '%s': %s" % (self.frontend, str(err)) )
def construct_connection( self, ssh_conn, ): """Construct an object inheriting from invoke.Context for remote execution. Currently this is achieved through the fabric.Connection class. Parameters ---------- conn_d : dict Returns ------- conn : Context subclass """ conn = fab.Connection( host=ssh_conn.host, user=ssh_conn.user, ) return conn
def can_connect(self) -> bool: if self.configured: # Will throw if the key is not available self.keyfile = self.config.key self._local_adb_version = self._get_adb_version() if "gateway" in self.config: try: self._gateway = fabric.Connection( os.path.expandvars(self.config.gateway), config=self._fabric_config) if self.gateway.run("pwd").exited != 0: get_root_logger().critical("Gateway connection failed") return False self._remote_adb_version = self._get_adb_version( self.gateway) if self._local_adb_version != self._remote_adb_version: get_root_logger().critical( ("The ADB version of the gateway server {} does " "not match the client version {}!").format( self._remote_adb_version, self._local_adb_version)) return False except Exception as e: get_root_logger().critical("Couldn't connect to gateway", e.args) return False return True else: return False
def deploy(destination, repo, checkout, env_args, env_file): """ \b Deploy the application by: - pulling the latest source and checking out a branch/commit - updating the remote .env file - building the Docker Compose services - applying the database migrations - collecting the static files together - starting the Docker containers """ c = fabric.Connection(host=destination) app_dir = f"/home/{c.user}/app" c.run(f"mkdir -p {app_dir}") with c.cd(app_dir): pull_latest_source(c, repo, checkout) create_or_update_dot_env(c, env_args, env_file) build_services(c) apply_migrations(c) collect_static(c) start_containers(c) info("Deployment complete")
def _CreateFabricContext(ssh_config): """Create a fabric context.""" # fabric has problems to understand complex ssh config. # Point to a user config fab_config = fabric.Config(system_ssh_path='~/.ssh/config') connect_kwargs = { 'config': fab_config } if ssh_config.ssh_key or ssh_config.password: connect_kwargs['connect_kwargs'] = {} if ssh_config.ssh_key: logger.debug( 'Use ssh key %s ssh %s@%s.', ssh_config.ssh_key, ssh_config.user, ssh_config.hostname) connect_kwargs['connect_kwargs']['key_filename'] = ssh_config.ssh_key if ssh_config.password: logger.debug('Use password to ssh %s@%s.', ssh_config.user, ssh_config.hostname) connect_kwargs['connect_kwargs']['password'] = ssh_config.password connect_kwargs['user'] = ssh_config.user try: wrapped_context = fabric.Connection( host=ssh_config.hostname, **connect_kwargs) wrapped_context.open() return wrapped_context except (paramiko.AuthenticationException, paramiko.SSHException) as e: logger.debug(e) raise AuthenticationError(e)
def migration(servers_login): print("launthing thread...") #print str(servers_login) for i in servers_login.keys(): if str(i) == 'Password': passw = servers_login[i] elif str(i) == 'Login_IP': host = servers_login[i] elif str(i) == 'User_Name': user = servers_login[i] elif str(i) == 'Key_Path': key_filename = servers_login[i] elif str(i) == 'Login_Port': port = servers_login[i] else: print("load source servers info, failed") print("Import the source servers information, Finished") print("start the multi thread migration service...\n") conn = fabric.Connection(host=host, user=user, port=port, connect_kwargs={ "key_filename": key_filename, "password": passw }) conn.run('mkdir -p /tmp/temp_CE') conn.put(local_script_path + '/aws_model', '/tmp/temp_CE/aws_model') conn.put(local_script_path + '/aws-instances.csv', '/tmp/temp_CE/aws-instances.csv') conn.put(local_script_path + '/vlookup.sh', '/tmp/temp_CE/vlookup.sh') conn.put(local_script_path + '/get-source-instance-type-2.py', '/tmp/temp_CE/get-source-instance-type.py') conn.put(local_script_path + '/get-CPU-MEM.sh', '/tmp/temp_CE/get-CPU-MEM.sh') conn.put(local_script_path + '/deletion_duplication.py', '/tmp/temp_CE/deletion_duplication.py') conn.put(local_script_path + '/CloudEndure.py', '/tmp/temp_CE/CloudEndure.py') conn.put(local_script_path + '/Cloudendure_Account_Info.csv', '/tmp/temp_CE/Cloudendure_Account_Info.csv') conn.put(local_script_path + '/CE_Account.py', '/tmp/temp_CE/CE_Account.py') #conn.get('/tmp/temp_CE/get-login-info.py', local_script_path+'/get_login_info.py') conn.run( "sudo python /tmp/temp_CE/get-source-instance-type.py $(. /tmp/temp_CE/get-CPU-MEM.sh)" ) conn.run("sudo python /tmp/temp_CE/deletion_duplication.py") conn.run( "sudo sh /tmp/temp_CE/vlookup.sh /tmp/temp_CE/aws_model /tmp/temp_CE/b /tmp/temp_CE/c" ) conn.run( "cat /tmp/temp_CE/c|sed -n 1p |cut -d \"'\" -f 8-8 > /tmp/temp_CE/d") conn.run( "sudo python /tmp/temp_CE/CloudEndure.py $(sudo python /tmp/temp_CE/CE_Account.py)" ) #conn.run("sudo python /tmp/temp_CE/CloudEndure.py -u CE_User_Name -p CE_Password -n ${HOSTNAME} -j CE_Project_Name") conn.close()
def _remote_exec_command(creds: SshCredentials, command: str, sudo: bool = False) -> RemoteExecResult: try: with fabric.Connection(creds.host, creds.login, creds.port, connect_kwargs={'password': creds.password}) as c: if sudo: res = c.sudo(command, warn=True, hide=True, password=creds.password) else: res = c.run(command, warn=True, hide=True) except NoValidConnectionsError: raise RemoteExecError(ERROR_NOT_CONNECTED, "can't connect to host") except SSHException as e: raise RemoteExecError(ERROR_SSH, "ssh exception", vars(e)) if res.exited: raise RemoteExecError(ERROR_EXEC, "can't exec command", { 'out': res.stdout, 'err': res.stderr }) return RemoteExecResult(stdout=res.stdout, stderr=res.stderr, exit_code=res.exited)
def nodes(self): try: return self.__nodes except AttributeError: if self.deploy: user = '******' else: user = self.user connections = [ fabric.Connection(host, user=user, gateway=self.frontend.nodes[0]) for host in self.hostnames ] self.__nodes = Nodes(connections, name='allnodes', working_dir='/tmp') self.orchestra = Nodes(connections[1:], name='orchestra', working_dir='/tmp') self.director = Nodes([connections[0]], name='director', working_dir='/tmp') self.__open_nodes_connection() return self.__nodes
def main(): addr = get_remote_address() # should be executed as background process ? in_background = '-bg' in sys.argv if in_background: del sys.argv[sys.argv.index('-bg')] # execute on server # establish connection to the server connection = fabric.Connection(addr, inline_ssh_env=True) # connect to server connection.client.load_system_host_keys() srun_options = load_srun_options(connection) env = get_environment_variables(srun_options) if 'CUDA_VISIBLE_DEVICES' in env: srun_options['CUDA_VISIBLE_DEVICES'] = env['CUDA_VISIBLE_DEVICES'] path = '/tmp/ladolphs/{}'.format(uuid.uuid4()) # new tmp folder on server # upload the files to the server upload_files_to_server(addr, path) # construct the command cmd = get_commands(path, srun_options, in_background) construct_venv(srun_options['VIRTUALENV'], connection) # execute the command connection.run(cmd, env=env) if in_background: print('[i] Started background tmux session {} on {}'.format( path.split('/')[-1], addr.split('@')[-1]))
def start_master( machine_ssh: str = typer.Argument( ..., help="machine ssh string: user@host:port"), machine_base_dir: str = typer.Argument(..., help="deployed base name"), submit_port: int = typer.Argument(..., help="submit port"), party_id: str = typer.Argument(..., help="party id"), cluster_manager_address: str = typer.Argument( ..., help="cluster manager address"), coordinator_address: str = typer.Argument(..., help="coordinator address"), ): with fabric.Connection(machine_ssh) as c: with c.cd(machine_base_dir): if c.run( f"FEDVISION_PYTHON_EXECUTABLE={os.path.join(machine_base_dir, 'venv/bin/python')} " f"{__BASE_NAME__}/sbin/master.sh start " f"{submit_port} {party_id} {cluster_manager_address} {coordinator_address}", warn=True, ).failed: typer.echo(f"failed: can't start master at port {submit_port}") return False else: typer.echo( f"{machine_ssh}:{machine_base_dir} started master: port={submit_port}" ) return True
def start_cluster_worker( machine_ssh: str = typer.Argument( ..., help="machine ssh string: user@host:port"), machine_base_dir: str = typer.Argument(..., help="deployed base name"), name: str = typer.Argument(..., help="worker name"), local_ip: str = typer.Argument(..., help="local ip"), port_start: int = typer.Argument(..., help="port start"), port_end: int = typer.Argument(..., help="port start"), max_tasks: int = typer.Argument(..., help="num of maximum parallel tasks"), cluster_manager_address=typer.Argument(..., help="cluster manager address"), data_base_dir: str = typer.Option(None, "--data-dir", help="data dir"), ): if data_base_dir is None or isinstance(data_base_dir, typer.params.OptionInfo): data_base_dir = os.path.join(machine_base_dir, __BASE_NAME__, "data") with fabric.Connection(machine_ssh) as c: with c.cd(machine_base_dir): if c.run( f"FEDVISION_PYTHON_EXECUTABLE={os.path.join(machine_base_dir, 'venv/bin/python')} " f"{__BASE_NAME__}/sbin/cluster_worker.sh start " f"{name} {local_ip} {port_start} {port_end} {max_tasks} {cluster_manager_address} {data_base_dir}", warn=True, ).failed: typer.echo(f"failed: can't start cluster worker named {name}") return False else: typer.echo( f"{machine_ssh}:{machine_base_dir} started cluster worker: name={name}" ) return True
def import_remote_trips(hostname: str, trip_dirs: List[str], out_dir: str, progress_bar): logging.info("import_remote_trips()") with fabric.Connection(hostname) as conn: progress_bar.progress(0) for i, remote_trip_dir in enumerate(trip_dirs): logging.info(f"Importing {remote_trip_dir}") result = conn.run(f"ls {remote_trip_dir}", hide=True) trip_files = result.stdout.strip().split("\n") local_trip_dir = os.path.join(out_dir, os.path.basename(remote_trip_dir)) os.makedirs(local_trip_dir, exist_ok=True) for trip_file in trip_files: logging.info(f"Copy {remote_trip_dir}/{trip_file}") conn.get( f"{remote_trip_dir}/{trip_file}", os.path.join(local_trip_dir, trip_file), ) # TODO: Improve me! picam_h264_path = os.path.join(local_trip_dir, "picam.h264") if os.path.isfile(picam_h264_path): mp4_path = f"{picam_h264_path[:-4]}mp4" ffmpeg_path = r"C:\Users\vobject\Tools\ffmpeg-4.2.1-win64-static\bin\ffmpeg.exe" # ffmpeg_path = r"C:\Users\user\Downloads\Python\ffmpeg-20200417-889ad93-win64-static\bin\ffmpeg.exe" cmd = f"{ffmpeg_path} -framerate 10 -i {picam_h264_path} -c copy {mp4_path} -y" logging.info(cmd) subprocess.run(cmd) progress_bar.progress(1. / len(trip_dirs) * (i + 1))
def init_connection(self, host, user=None, port=None, gateway=None, ssh_config_path=None, args=None): """ init_connection provides implementation of SSH plugin's init_connection method: self.targets[name].init_connection(host, user, port, gateway, ssh_config_path, args) """ try: if self.connection and self.connection.is_connected: log.debug("Closing connection to {}".format( self.connection.host)) self.connection.close() if ssh_config_path: ssh_config_path = expand_path(ssh_config_path) config = fabric.Config(runtime_ssh_path=ssh_config_path) self.connection = fabric.Connection(host, user=user, port=port, gateway=gateway, config=config, connect_kwargs=args) log.debug("Opening connection to {}...".format( self.connection.host)) self.connection.open() return True except Exception as exception: log.error("Remote connection failed: {}".format(exception)) raise CtfTestError("Error in init_connection") from exception
def connect(host, users=None): log.debug("Connecting to '{}'".format(host)) if "@" in host: parts = host.split("@") assert len(parts) == 2 host = parts[1] if not users: users = [parts[0]] if not users: users = [ "Administrator", "ubuntu", "ec2-user", "centos", "vagrant", "root" ] # Similar to ssh, try own username first, # some systems will lock us out if we have too many failed attempts. if whoami() not in users: users = [whoami()] + users for user in users: try: log.debug("Attempting ssh: {}@{}".format(user, host)) c = fabric.Connection(host=host, user=user) c.ssh_user = user c.ssh_host = host c.run("whoami", hide=True) return c except AuthenticationException: continue sys.exit("Could not ssh into '{}'".format(host))
def main(): if os.getcwd() == os.path.expanduser('~'): print('NO') exit(1) addr = sys.argv[1] del sys.argv[1] path = '/tmp/{}'.format(uuid.uuid4()) env = [] while '=' in sys.argv[1]: env.append(sys.argv[1].split('=')) del sys.argv[1] env = dict(env) print( sh.rsync('-a', '-v', '-z', '--exclude', '__pycache__', '--exclude', '*.swp', '--exclude', '.git', '{}/'.format(os.getcwd()), '{}:{}'.format(addr, path))) cmd = 'cd {} && {}'.format(path, ' '.join(sys.argv[1:])) connection = fabric.Connection(addr, inline_ssh_env=True) connection.client.load_system_host_keys() connection.run(cmd, env=env) print( sh.rsync('-a', '-v', '-z', '{}:{}/logs/'.format(addr, path), os.getcwd() + '/logs'))
def ssh_cmd_to_vm(cmd_to_run, vm_name): ''' Runs a command on a named VM. Returns success_boolean, output_text ''' if not vm_name in VM_INFO: die("Attempt to run on {}, which is not a valid VM".format(vm_name)) is_vm_running(vm_name) this_control_address = (rt_config["vm_info"][vm_name]).get("control_addr") if not this_control_address: die("There was no address for {}".format(vm_name)) fabconn = fabric.Connection(host=this_control_address, user="******", connect_kwargs={"password": ROOT_PASS}) try: fabconn.open() except Exception as this_e: die("Could not open an SSH connection to {} on {}: '{}'.".format( vm_name, this_control_address, this_e)) # Is this the right VM? ret_hostname = fabconn.run("hostname", hide=True) if ret_hostname.failed: die("Could not run hostname on {}".format(vm_name)) ret_text = ret_hostname.stdout if ret_text.rstrip() != vm_name: die("The host at {} is not {}: '{}'".format(this_control_address, vm_name, ret_text)) # Run the command ret_main_cmd = fabconn.run(cmd_to_run, hide=True, warn=True) if ret_main_cmd.failed: return False, "Error: {}".format(ret_main_cmd.stderr.strip()) else: return True, ret_main_cmd.stdout.strip() fabconn.close()
def connect(): return fabric.Connection(host=os.environ['HOST'], user=os.environ['USER'], connect_kwargs=dict( password=os.getenv('PASSWORD'), key_filename=os.getenv('SSH_KEY')), port=os.getenv('PORT', 22))
def deploy_cluster_resources(cluster: structures.cluster.Cluster) -> None: handle, tmpfile = tempfile.mkstemp(prefix="cluster_bootstrap") # Write the bootstrap cluster yaml with open(handle, 'w') as f: yaml = cluster.to_yaml() f.write(yaml) # Deploy the bootstrap yaml to all cluster nodes ssh_key = Path(cluster.auth.ssh_private_key).expanduser().absolute() hosts = [cluster.provider.head_ip] + cluster.provider.worker_ips for host in tuple(hosts): connection = fabric.Connection( host=host, user=cluster.auth.ssh_user, connect_kwargs={'key_filename': str(ssh_key)}) result: transfer.Result = connection.put( local=tmpfile, remote="cluster_bootstrap.yaml") result: transfer.Result = connection.put(local=str(ssh_key), remote="cluster_ssh_key.pem")
def _deploy_keystore(self, password: str): with fabric.Connection(f'pi@{root_node}', connect_kwargs={"password": password}) as conn: src = "./setup/keystore" dest = "/home/pi/iot-trust-task-alloc/resource_rich/root" patchwork.transfers.rsync(conn, src, dest, rsync_opts="-r")