def receive(self, command=None, prompts=None, answer=None): ''' Handles receiving of output from command ''' recv = BytesIO() handled = False self._matched_prompt = None while True: data = self._ssh_shell.recv(256) # when a channel stream is closed, received data will be empty if not data: break recv.write(data) offset = recv.tell() - 256 if recv.tell() > 256 else 0 recv.seek(offset) window = self._strip(recv.read()) if prompts and not handled: handled = self._handle_prompt(window, prompts, answer) if self._find_prompt(window): self._last_response = recv.getvalue() resp = self._strip(self._last_response) return self._sanitize(resp, command)
def create_package(self): data = BytesIO() with zipfile.ZipFile(data, 'w', zipfile.ZIP_DEFLATED) as zip_file: for root, _dummy, filenames in os.walk(self.src): for filename in filenames: src_path = os.path.join(root, filename) dst_path = os.path.relpath(src_path, self.src) if self.include: if not any(fnmatch.fnmatch(src_path, pattern) for pattern in self.include): continue if self.exclude: if any(fnmatch.fnmatch(src_path, pattern) for pattern in self.exclude): continue dst_path = self.rename.get(dst_path, dst_path) zip_info = zipfile.ZipInfo( dst_path, (1980, 1, 1, 0, 0, 0), # deterministic timestamp for idempotency ) zip_info.compress_type = zipfile.ZIP_DEFLATED zip_info.external_attr = 0o777 << 16 # give full access to included file with open(src_path, 'rb') as src_file: zip_file.writestr(zip_info, src_file.read()) return data.getvalue()
def receive(self, command=None, prompts=None, answer=None, newline=True): ''' Handles receiving of output from command ''' recv = BytesIO() handled = False self._matched_prompt = None while True: data = self._ssh_shell.recv(256) # when a channel stream is closed, received data will be empty if not data: break recv.write(data) offset = recv.tell() - 256 if recv.tell() > 256 else 0 recv.seek(offset) window = self._strip(recv.read()) if prompts and not handled: handled = self._handle_prompt(window, prompts, answer, newline) elif prompts and handled: # check again even when handled, a sub-prompt could be # repeating (like in the case of a wrong enable password, etc) self._handle_prompt(window, prompts, answer, newline) if self._find_prompt(window): self._last_response = recv.getvalue() resp = self._strip(self._last_response) return self._sanitize(resp, command)
def receive(self, cmd=None): recv = BytesIO() handled = False while True: data = self.shell.recv(200) recv.write(data) recv.seek(recv.tell() - len(data)) window = self.strip(recv.read().decode('utf8')) if cmd: if 'prompt' in cmd and not handled: handled = self.handle_prompt(window, cmd) try: if self.find_prompt(window): resp = self.strip(recv.getvalue().decode('utf8')) if cmd: resp = self.sanitize(cmd, resp) return resp except ShellError: exc = get_exception() exc.command = cmd['command'] raise
def create_package(self, code): data = BytesIO() zip_info = zipfile.ZipInfo( 'lambda_function.py', (1980, 1, 1, 0, 0, 0), ) zip_info.compress_type = zipfile.ZIP_DEFLATED zip_info.external_attr = 0o777 << 16 # give full access to included file with zipfile.ZipFile(data, 'w', zipfile.ZIP_DEFLATED) as f: f.writestr(zip_info, code) return data.getvalue()
def receive(self, command=None, prompts=None, answer=None, newline=True, prompt_retry_check=False, check_all=False): ''' Handles receiving of output from command ''' recv = BytesIO() handled = False self._matched_prompt = None self._matched_cmd_prompt = None matched_prompt_window = window_count = 0 while True: data = self._ssh_shell.recv(256) # when a channel stream is closed, received data will be empty if not data: break recv.write(data) offset = recv.tell() - 256 if recv.tell() > 256 else 0 recv.seek(offset) window = self._strip(recv.read()) window_count += 1 if prompts and not handled: handled = self._handle_prompt(window, prompts, answer, newline, False, check_all) matched_prompt_window = window_count elif prompts and handled and prompt_retry_check and matched_prompt_window + 1 == window_count: # check again even when handled, if same prompt repeats in next window # (like in the case of a wrong enable password, etc) indicates # value of answer is wrong, report this as error. if self._handle_prompt(window, prompts, answer, newline, prompt_retry_check, check_all): raise AnsibleConnectionFailure( "For matched prompt '%s', answer is not valid" % self._matched_cmd_prompt) if self._find_prompt(window): self._last_response = recv.getvalue() resp = self._strip(self._last_response) return self._sanitize(resp, command)
def connection_response(name, path, status=200): file = os.path.join(path, name) with open(file, 'rb') as f: response_data = BytesIO(f.read()) response_mock = Mock() response_mock.getcode.return_value = status return response_mock, response_data
def _send_response(status_code, response): response_mock = mock.Mock() response_mock.getcode.return_value = status_code response_text = response response_data = BytesIO( response_text.encode() if response_text else "".encode()) return response_mock, response_data
def _connection_response(response, status=200): response_mock = mock.Mock() response_mock.getcode.return_value = status response_text = json.dumps( response) if type(response) is dict else response response_data = BytesIO( response_text.encode() if response_text else ''.encode()) return response_mock, response_data
def _download_extract_zip(self, url): from ansible.module_utils.urls import open_url from ansible.module_utils.six import BytesIO from zipfile import ZipFile if not os.path.isdir(self.directory): os.makedirs(self.directory) resp = open_url(url) zip_archive = ZipFile(BytesIO(resp.read())) zip_archive.extractall(path=self.terraform_dir)
def send(self, path, data, **kwargs): ''' Sends the command to the device over api ''' url_kwargs = dict( timeout=self.get_option('timeout'), validate_certs=self.get_option('validate_certs'), headers={}, ) url_kwargs.update(kwargs) if self._auth: # Avoid modifying passed-in headers headers = dict(kwargs.get('headers', {})) headers.update(self._auth) url_kwargs['headers'] = headers else: url_kwargs['url_username'] = self.get_option('remote_user') url_kwargs['url_password'] = self.get_option('password') try: response = open_url(self._url + path, data=data, **url_kwargs) except HTTPError as exc: is_handled = self.handle_httperror(exc) if is_handled is True: return self.send(path, data, **kwargs) elif is_handled is False: raise AnsibleConnectionFailure( 'Could not connect to {0}: {1}'.format( self._url + path, exc.reason)) else: raise except URLError as exc: raise AnsibleConnectionFailure( 'Could not connect to {0}: {1}'.format(self._url + path, exc.reason)) response_buffer = BytesIO() response_buffer.write(response.read()) # Try to assign a new auth token if one is given self._auth = self.update_auth(response, response_buffer) or self._auth return response, response_buffer
def connection_response(response, status=200, headers=None): response_mock = Mock() response_mock.getcode.return_value = status if headers is None: headers = BASE_HEADERS response_mock.getheaders.return_value = headers.items() response_text = json.dumps( response) if type(response) is dict else response response_data = BytesIO( response_text.encode() if response_text else ''.encode()) return response_mock, response_data
def download_response(file, status=200): response_mock = MagicMock() bytes_file = bytes(file, encoding='utf8') response_mock_buffer = BytesIO(bytes_file) response_mock.status = status content_range = '0-{0}/{1}'.format(str(len(bytes_file)), str(len(bytes_file))) response_mock.headers = { 'Content-Range': content_range, 'Content-Type': 'application/octet-stream' } return response_mock, response_mock_buffer
def receive(self, command=None, prompts=None, answer=None): """Handles receiving of output from command""" recv = BytesIO() handled = False self._matched_prompt = None while True: data = self._shell.recv(256) recv.write(data) offset = recv.tell() - 256 if recv.tell() > 256 else 0 recv.seek(offset) window = self._strip(recv.read()) if prompts and not handled: handled = self._handle_prompt(window, prompts, answer) if self._find_prompt(window): self._last_response = recv.getvalue() resp = self._strip(self._last_response) return self._sanitize(resp, command)
def receive(self, command=None, prompts=None, answer=None, newline=True, prompt_retry_check=False): ''' Handles receiving of output from command ''' recv = BytesIO() handled = False self._matched_prompt = None self._matched_cmd_prompt = None matched_prompt_window = window_count = 0 while True: data = self._ssh_shell.recv(256) # when a channel stream is closed, received data will be empty if not data: break recv.write(data) offset = recv.tell() - 256 if recv.tell() > 256 else 0 recv.seek(offset) window = self._strip(recv.read()) window_count += 1 if prompts and not handled: handled = self._handle_prompt(window, prompts, answer, newline) matched_prompt_window = window_count elif prompts and handled and prompt_retry_check and matched_prompt_window + 1 == window_count: # check again even when handled, if same prompt repeats in next window # (like in the case of a wrong enable password, etc) indicates # value of answer is wrong, report this as error. if self._handle_prompt(window, prompts, answer, newline, prompt_retry_check): raise AnsibleConnectionFailure("For matched prompt '%s', answer is not valid" % self._matched_cmd_prompt) if self._find_prompt(window): self._last_response = recv.getvalue() resp = self._strip(self._last_response) return self._sanitize(resp, command)
def receive(self, command=None, prompts=None, answer=None, newline=True, prompt_retry_check=False, check_all=False): ''' Handles receiving of output from command ''' self._matched_prompt = None self._matched_cmd_prompt = None recv = BytesIO() handled = False command_prompt_matched = False matched_prompt_window = window_count = 0 command_timeout = self.get_option('persistent_command_timeout') self._validate_timeout_value(command_timeout, "persistent_command_timeout") buffer_read_timeout = self.get_option('persistent_buffer_read_timeout') self._validate_timeout_value(buffer_read_timeout, "persistent_buffer_read_timeout") while True: if command_prompt_matched: try: signal.signal(signal.SIGALRM, self._handle_buffer_read_timeout) signal.setitimer(signal.ITIMER_REAL, buffer_read_timeout) data = self._ssh_shell.recv(256) signal.alarm(0) # if data is still received on channel it indicates the prompt string # is wrongly matched in between response chunks, continue to read # remaining response. command_prompt_matched = False # restart command_timeout timer signal.signal(signal.SIGALRM, self._handle_command_timeout) signal.alarm(command_timeout) except AnsibleCmdRespRecv: return self._command_response else: data = self._ssh_shell.recv(256) # when a channel stream is closed, received data will be empty if not data: break recv.write(data) offset = recv.tell() - 256 if recv.tell() > 256 else 0 recv.seek(offset) window = self._strip(recv.read()) window_count += 1 if prompts and not handled: handled = self._handle_prompt(window, prompts, answer, newline, False, check_all) matched_prompt_window = window_count elif prompts and handled and prompt_retry_check and matched_prompt_window + 1 == window_count: # check again even when handled, if same prompt repeats in next window # (like in the case of a wrong enable password, etc) indicates # value of answer is wrong, report this as error. if self._handle_prompt(window, prompts, answer, newline, prompt_retry_check, check_all): raise AnsibleConnectionFailure( "For matched prompt '%s', answer is not valid" % self._matched_cmd_prompt) if self._find_prompt(window): self._last_response = recv.getvalue() resp = self._strip(self._last_response) self._command_response = self._sanitize(resp, command) if buffer_read_timeout == 0.0: return self._command_response else: command_prompt_matched = True