Exemple #1
0
 def exec_command(self,
                  cmd,
                  tmp_path,
                  sudo_user=None,
                  sudoable=False,
                  executable=None,
                  in_data=None,
                  su=None,
                  su_user=None):
     cmd = cmd.encode('utf-8')
     cmd_parts = shlex.split(cmd, posix=False)
     if '-EncodedCommand' in cmd_parts:
         encoded_cmd = cmd_parts[cmd_parts.index('-EncodedCommand') + 1]
         decoded_cmd = base64.b64decode(encoded_cmd)
         vvv("EXEC %s" % decoded_cmd, host=self.host)
     else:
         vvv("EXEC %s" % cmd, host=self.host)
     # For script/raw support.
     if cmd_parts and cmd_parts[0].lower().endswith('.ps1'):
         script = powershell._build_file_cmd(cmd_parts)
         cmd_parts = powershell._encode_script(script, as_list=True)
     try:
         result = self._winrm_exec(cmd_parts[0],
                                   cmd_parts[1:],
                                   from_exec=True)
     except Exception, e:
         traceback.print_exc()
         raise errors.AnsibleError("failed to exec cmd %s" % cmd)
Exemple #2
0
    def exec_command(self,
                     cmd,
                     tmp_path,
                     become_user=None,
                     sudoable=False,
                     executable=None,
                     in_data=None):

        if sudoable and self.runner.become and self.runner.become_method not in self.become_methods_supported:
            raise errors.AnsibleError(
                "Internal Error: this module does not support running commands via %s"
                % self.runner.become_method)

        cmd = cmd.encode('utf-8')
        cmd_parts = shlex.split(cmd, posix=False)
        if '-EncodedCommand' in cmd_parts:
            encoded_cmd = cmd_parts[cmd_parts.index('-EncodedCommand') + 1]
            decoded_cmd = base64.b64decode(encoded_cmd)
            vvv("EXEC %s" % decoded_cmd, host=self.host)
        else:
            vvv("EXEC %s" % cmd, host=self.host)
        # For script/raw support.
        if cmd_parts and cmd_parts[0].lower().endswith('.ps1'):
            script = powershell._build_file_cmd(cmd_parts, quote_args=False)
            cmd_parts = powershell._encode_script(script, as_list=True)
        try:
            result = self._winrm_exec(cmd_parts[0],
                                      cmd_parts[1:],
                                      from_exec=True)
        except Exception, e:
            traceback.print_exc()
            raise errors.AnsibleError("failed to exec cmd %s" % cmd)
Exemple #3
0
 def put_file(self, in_path, out_path):
     vvv("PUT %s TO %s" % (in_path, out_path), host=self.host)
     if not os.path.exists(in_path):
         raise errors.AnsibleFileNotFound(
             "file or module does not exist: %s" % in_path)
     with open(in_path) as in_file:
         in_size = os.path.getsize(in_path)
         script_template = '''
             $s = [System.IO.File]::OpenWrite("%s");
             [void]$s.Seek(%d, [System.IO.SeekOrigin]::Begin);
             $b = [System.Convert]::FromBase64String("%s");
             [void]$s.Write($b, 0, $b.length);
             [void]$s.SetLength(%d);
             [void]$s.Close();
         '''
         # Determine max size of data we can pass per command.
         script = script_template % (powershell._escape(out_path), in_size,
                                     '', in_size)
         cmd = powershell._encode_script(script)
         # Encode script with no data, subtract its length from 8190 (max
         # windows command length), divide by 2.67 (UTF16LE base64 command
         # encoding), then by 1.35 again (data base64 encoding).
         buffer_size = int(((8190 - len(cmd)) / 2.67) / 1.35)
         for offset in xrange(0, in_size, buffer_size):
             try:
                 out_data = in_file.read(buffer_size)
                 if offset == 0:
                     if out_data.lower().startswith(
                             '#!powershell'
                     ) and not out_path.lower().endswith('.ps1'):
                         out_path = out_path + '.ps1'
                 b64_data = base64.b64encode(out_data)
                 script = script_template % (powershell._escape(out_path),
                                             offset, b64_data, in_size)
                 vvvv("WINRM PUT %s to %s (offset=%d size=%d)" %
                      (in_path, out_path, offset, len(out_data)),
                      host=self.host)
                 cmd_parts = powershell._encode_script(script, as_list=True)
                 result = self._winrm_exec(cmd_parts[0], cmd_parts[1:])
                 if result.status_code != 0:
                     raise IOError(result.std_err.encode('utf-8'))
             except Exception:
                 traceback.print_exc()
                 raise errors.AnsibleError("failed to transfer file to %s" %
                                           out_path)
 def put_file(self, in_path, out_path):
     vvv("PUT %s TO %s" % (in_path, out_path), host=self.host)
     if not os.path.exists(in_path):
         raise errors.AnsibleFileNotFound("file or module does not exist: %s" % in_path)
     with open(in_path) as in_file:
         in_size = os.path.getsize(in_path)
         script_template = '''
             $s = [System.IO.File]::OpenWrite("%s");
             [void]$s.Seek(%d, [System.IO.SeekOrigin]::Begin);
             $b = [System.Convert]::FromBase64String("%s");
             [void]$s.Write($b, 0, $b.length);
             [void]$s.SetLength(%d);
             [void]$s.Close();
         '''
         # Determine max size of data we can pass per command.
         script = script_template % (powershell._escape(out_path), in_size, '', in_size)
         cmd = powershell._encode_script(script)
         # Encode script with no data, subtract its length from 8190 (max
         # windows command length), divide by 2.67 (UTF16LE base64 command
         # encoding), then by 1.35 again (data base64 encoding).
         buffer_size = int(((8190 - len(cmd)) / 2.67) / 1.35)
         for offset in xrange(0, in_size, buffer_size):
             try:
                 out_data = in_file.read(buffer_size)
                 if offset == 0:
                     if out_data.lower().startswith('#!powershell') and not out_path.lower().endswith('.ps1'):
                         out_path = out_path + '.ps1'
                 b64_data = base64.b64encode(out_data)
                 script = script_template % (powershell._escape(out_path), offset, b64_data, in_size)
                 vvvv("WINRM PUT %s to %s (offset=%d size=%d)" % (in_path, out_path, offset, len(out_data)), host=self.host)
                 cmd_parts = powershell._encode_script(script, as_list=True)
                 result = self._winrm_exec(cmd_parts[0], cmd_parts[1:])
                 if result.status_code != 0:
                     raise IOError(result.std_err.encode('utf-8'))
             except Exception:
                 traceback.print_exc()
                 raise errors.AnsibleError("failed to transfer file to %s" % out_path)
 def exec_command(self, cmd, tmp_path, sudo_user=None, sudoable=False, executable=None, in_data=None, su=None, su_user=None):
     cmd = cmd.encode('utf-8')
     cmd_parts = shlex.split(cmd, posix=False)
     if '-EncodedCommand' in cmd_parts:
         encoded_cmd = cmd_parts[cmd_parts.index('-EncodedCommand') + 1]
         decoded_cmd = base64.b64decode(encoded_cmd)
         vvv("EXEC %s" % decoded_cmd, host=self.host)
     else:
         vvv("EXEC %s" % cmd, host=self.host)
     # For script/raw support.
     if cmd_parts and cmd_parts[0].lower().endswith('.ps1'):
         script = powershell._build_file_cmd(cmd_parts)
         cmd_parts = powershell._encode_script(script, as_list=True)
     try:
         result = self._winrm_exec(cmd_parts[0], cmd_parts[1:], from_exec=True)
     except Exception, e:
         traceback.print_exc()
         raise errors.AnsibleError("failed to exec cmd %s" % cmd)
Exemple #6
0
    def exec_command(self, cmd, tmp_path, become_user=None, sudoable=False, executable=None, in_data=None):

        if sudoable and self.runner.become and self.runner.become_method not in self.become_methods_supported:
            raise errors.AnsibleError("Internal Error: this module does not support running commands via %s" % self.runner.become_method)

        cmd = cmd.encode('utf-8')
        cmd_parts = shlex.split(cmd, posix=False)
        if '-EncodedCommand' in cmd_parts:
            encoded_cmd = cmd_parts[cmd_parts.index('-EncodedCommand') + 1]
            decoded_cmd = base64.b64decode(encoded_cmd)
            vvv("EXEC %s" % decoded_cmd, host=self.host)
        else:
            vvv("EXEC %s" % cmd, host=self.host)
        # For script/raw support.
        if cmd_parts and cmd_parts[0].lower().endswith('.ps1'):
            script = powershell._build_file_cmd(cmd_parts, quote_args=False)
            cmd_parts = powershell._encode_script(script, as_list=True)
        try:
            result = self._winrm_exec(cmd_parts[0], cmd_parts[1:], from_exec=True)
        except Exception, e:
            traceback.print_exc()
            raise errors.AnsibleError("failed to exec cmd %s" % cmd)
 def fetch_file(self, in_path, out_path):
     out_path = out_path.replace('\\', '/')
     vvv("FETCH %s TO %s" % (in_path, out_path), host=self.host)
     buffer_size = 2**20 # 1MB chunks
     if not os.path.exists(os.path.dirname(out_path)):
         os.makedirs(os.path.dirname(out_path))
     out_file = None
     try:
         offset = 0
         while True:
             try:
                 script = '''
                     If (Test-Path -PathType Leaf "%(path)s")
                     {
                         $stream = [System.IO.File]::OpenRead("%(path)s");
                         $stream.Seek(%(offset)d, [System.IO.SeekOrigin]::Begin) | Out-Null;
                         $buffer = New-Object Byte[] %(buffer_size)d;
                         $bytesRead = $stream.Read($buffer, 0, %(buffer_size)d);
                         $bytes = $buffer[0..($bytesRead-1)];
                         [System.Convert]::ToBase64String($bytes);
                         $stream.Close() | Out-Null;
                     }
                     ElseIf (Test-Path -PathType Container "%(path)s")
                     {
                         Write-Host "[DIR]";
                     }
                     Else
                     {
                         Write-Error "%(path)s does not exist";
                         Exit 1;
                     }
                 ''' % dict(buffer_size=buffer_size, path=powershell._escape(in_path), offset=offset)
                 vvvv("WINRM FETCH %s to %s (offset=%d)" % (in_path, out_path, offset), host=self.host)
                 cmd_parts = powershell._encode_script(script, as_list=True)
                 result = self._winrm_exec(cmd_parts[0], cmd_parts[1:])
                 if result.status_code != 0:
                     raise IOError(result.std_err.encode('utf-8'))
                 if result.std_out.strip() == '[DIR]':
                     data = None
                 else:
                     data = base64.b64decode(result.std_out.strip())
                 if data is None:
                     if not os.path.exists(out_path):
                         os.makedirs(out_path)
                     break
                 else:
                     if not out_file:
                         # If out_path is a directory and we're expecting a file, bail out now.
                         if os.path.isdir(out_path):
                             break
                         out_file = open(out_path, 'wb')
                     out_file.write(data)
                     if len(data) < buffer_size:
                         break
                     offset += len(data)
             except Exception:
                 traceback.print_exc()
                 raise errors.AnsibleError("failed to transfer file to %s" % out_path)
     finally:
         if out_file:
             out_file.close()
Exemple #8
0
 def fetch_file(self, in_path, out_path):
     out_path = out_path.replace('\\', '/')
     vvv("FETCH %s TO %s" % (in_path, out_path), host=self.host)
     buffer_size = 2**19 # 0.5MB chunks
     if not os.path.exists(os.path.dirname(out_path)):
         os.makedirs(os.path.dirname(out_path))
     out_file = None
     try:
         offset = 0
         while True:
             try:
                 script = '''
                     If (Test-Path -PathType Leaf "%(path)s")
                     {
                         $stream = [System.IO.File]::OpenRead("%(path)s");
                         $stream.Seek(%(offset)d, [System.IO.SeekOrigin]::Begin) | Out-Null;
                         $buffer = New-Object Byte[] %(buffer_size)d;
                         $bytesRead = $stream.Read($buffer, 0, %(buffer_size)d);
                         $bytes = $buffer[0..($bytesRead-1)];
                         [System.Convert]::ToBase64String($bytes);
                         $stream.Close() | Out-Null;
                     }
                     ElseIf (Test-Path -PathType Container "%(path)s")
                     {
                         Write-Host "[DIR]";
                     }
                     Else
                     {
                         Write-Error "%(path)s does not exist";
                         Exit 1;
                     }
                 ''' % dict(buffer_size=buffer_size, path=powershell._escape(in_path), offset=offset)
                 vvvv("WINRM FETCH %s to %s (offset=%d)" % (in_path, out_path, offset), host=self.host)
                 cmd_parts = powershell._encode_script(script, as_list=True)
                 result = self._winrm_exec(cmd_parts[0], cmd_parts[1:])
                 if result.status_code != 0:
                     raise IOError(result.std_err.encode('utf-8'))
                 if result.std_out.strip() == '[DIR]':
                     data = None
                 else:
                     data = base64.b64decode(result.std_out.strip())
                 if data is None:
                     if not os.path.exists(out_path):
                         os.makedirs(out_path)
                     break
                 else:
                     if not out_file:
                         # If out_path is a directory and we're expecting a file, bail out now.
                         if os.path.isdir(out_path):
                             break
                         out_file = open(out_path, 'wb')
                     out_file.write(data)
                     if len(data) < buffer_size:
                         break
                     offset += len(data)
             except Exception:
                 traceback.print_exc()
                 raise errors.AnsibleError("failed to transfer file to %s" % out_path)
     finally:
         if out_file:
             out_file.close()