winrm-fs 0.1.0

data/changelog.md

@@ -0,0 +1 @@
+0.1.0 - Initial alpha quality release

data/lib/winrm-fs.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'winrm'
+require 'logger'
+require_relative 'winrm-fs/exceptions'
+require_relative 'winrm-fs/file_manager'
+
+module WinRM
+  # WinRM File System
+  module FS
+    # Top level module code
+  end
+end

data/lib/winrm-fs/core/command_executor.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module WinRM
+  module FS
+    module Core
+      # Executes commands used by the WinRM file management module
+      class CommandExecutor
+        def initialize(service)
+          @service = service
+        end
+
+        def open
+          @shell = @service.open_shell
+          @shell_open = true
+        end
+
+        def close
+          @service.close_shell(@shell) if @shell
+          @shell_open = false
+        end
+
+        def run_powershell(script)
+          assert_shell_is_open
+          run_cmd('powershell', ['-encodedCommand', encode_script(script)])
+        end
+
+        def run_cmd(command, arguments = [])
+          assert_shell_is_open
+          result = nil
+          @service.run_command(@shell, command, arguments) do |command_id|
+            result = @service.get_command_output(@shell, command_id)
+          end
+          assert_command_success(command, result)
+          result.stdout
+        end
+
+        private
+
+        def assert_shell_is_open
+          fail 'You must call open before calling any run methods' unless @shell_open
+        end
+
+        def assert_command_success(command, result)
+          return if result[:exitcode] == 0 && result.stderr.length == 0
+          fail WinRMUploadError, command + '\n' + result.output
+        end
+
+        def encode_script(script)
+          encoded_script = script.encode('UTF-16LE', 'UTF-8')
+          Base64.strict_encode64(encoded_script)
+        end
+      end
+    end
+  end
+end

data/lib/winrm-fs/core/file_uploader.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'command_executor'
+
+module WinRM
+  module FS
+    module Core
+      # Uploads the given source file to a temp file in 8k chunks
+      class FileUploader
+        def initialize(command_executor)
+          @command_executor = command_executor
+        end
+
+        # Uploads the given file to the specified temp file as base64 encoded.
+        #
+        # @param [String] Path to the local source file on this machine
+        # @param [String] Path to the file on the target machine
+        # @return [Integer] Count of bytes uploaded
+        def upload(local_file, remote_file)
+          @command_executor.run_powershell(prepare_script(remote_file))
+          do_upload(local_file, dos_path(remote_file))
+        end
+
+        private
+
+        def do_upload(local_file, remote_file)
+          bytes_copied = 0
+          base64_array = base64_content(local_file)
+          base64_array.each_slice(8000 - remote_file.size) do |chunk|
+            @command_executor.run_cmd("echo #{chunk.join} >> \"#{remote_file}\"")
+            bytes_copied += chunk.count
+            yield bytes_copied, base64_array.count if block_given?
+          end
+          base64_array.length
+        end
+
+        def base64_content(local_file)
+          base64_host_file = Base64.encode64(IO.binread(local_file)).gsub("\n", '')
+          base64_host_file.chars.to_a
+        end
+
+        def dos_path(path)
+          # TODO: convert all env vars
+          path = path.gsub(/\$env:TEMP/, '%TEMP%')
+          path.gsub(/\\/, '/')
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def prepare_script(remote_file)
+          <<-EOH
+            $p = $ExecutionContext.SessionState.Path
+            $path = $p.GetUnresolvedProviderPathFromPSPath("#{remote_file}")
+
+            # if the file exists, truncate it
+            if (Test-Path $path -PathType Leaf) {
+              '' | Set-Content $path
+            }
+
+            # ensure the target directory exists
+            $dir = [System.IO.Path]::GetDirectoryName($path)
+            if (!(Test-Path $dir -PathType Container)) {
+              mkdir $dir -ErrorAction SilentlyContinue | Out-Null
+            }
+          EOH
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end

data/lib/winrm-fs/core/temp_zip_file.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'zip'
+
+module WinRM
+  module FS
+    module Core
+      # Temporary zip file on the local system
+      class TempZipFile
+        attr_reader :path
+
+        def initialize
+          @logger = Logging.logger[self]
+          @zip_file = Tempfile.new(['winrm_upload', '.zip'])
+          @zip_file.close
+          @path = @zip_file.path
+        end
+
+        # Adds a file or directory to the temporary zip file
+        # @param [String] Directory or file path to add into zip
+        def add(path)
+          if File.directory?(path)
+            add_directory(path)
+          elsif File.file?(path)
+            add_file(path)
+          else
+            fail "#{path} doesn't exist"
+          end
+        end
+
+        # Adds all files in the specified directory recursively into the zip file
+        # @param [String] Directory to add into zip
+        def add_directory(dir)
+          fail "#{dir} isn't a directory" unless File.directory?(dir)
+          glob = File.join(dir, '**/*')
+          Dir.glob(glob).each do |file|
+            add_file_entry(file, dir)
+          end
+        end
+
+        def add_file(file)
+          fail "#{file} isn't a file" unless File.file?(file)
+          add_file_entry(file, File.dirname(file))
+        end
+
+        def delete
+          @zip_file.delete
+        end
+
+        private
+
+        def add_file_entry(file, base_dir)
+          base_dir = "#{base_dir}/" unless base_dir.end_with?('/')
+          file_entry_path = file[base_dir.length..-1]
+          write_zip_entry(file, file_entry_path)
+        end
+
+        def write_zip_entry(file, file_entry_path)
+          @logger.debug("adding zip entry: #{file_entry_path}")
+          Zip::File.open(@path, 'w') do |zipfile|
+            entry = new_zip_entry(file_entry_path)
+            zipfile.add(entry, file)
+          end
+        end
+
+        def new_zip_entry(file_entry_path)
+          Zip::Entry.new(
+            @path,
+            file_entry_path,
+            nil,
+            nil,
+            nil,
+            nil,
+            nil,
+            nil,
+            ::Zip::DOSTime.new(2000))
+        end
+      end
+    end
+  end
+end

data/lib/winrm-fs/core/upload_orchestrator.rb

@@ -0,0 +1,118 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'temp_zip_file'
+require_relative 'file_uploader'
+require_relative 'command_executor'
+require_relative '../scripts/scripts'
+
+module WinRM
+  module FS
+    module Core
+      # Orchestrates the upload of a file or directory
+      class UploadOrchestrator
+        def initialize(service)
+          @service = service
+          @logger = Logging.logger[self]
+        end
+
+        def upload_file(local_path, remote_path)
+          # If the src has a file extension and the destination does not
+          # we can assume the caller specified the dest as a directory
+          if File.extname(local_path) != '' && File.extname(remote_path) == ''
+            remote_path = File.join(remote_path, File.basename(local_path))
+          end
+          temp_path = temp_file_path(local_path)
+          with_command_executor do |cmd_executor|
+            return 0 unless out_of_date?(cmd_executor, local_path, remote_path)
+            do_file_upload(cmd_executor, local_path, temp_path, remote_path)
+          end
+        end
+
+        def upload_directory(local_paths, remote_path)
+          with_local_zip(local_paths) do |local_zip|
+            temp_path = temp_file_path(local_zip.path)
+            with_command_executor do |cmd_executor|
+              return 0 unless out_of_date?(cmd_executor, local_zip.path, temp_path)
+              do_file_upload(cmd_executor, local_zip.path, temp_path, remote_path)
+            end
+          end
+        end
+
+        private
+
+        def do_file_upload(cmd_executor, local_path, temp_path, remote_path)
+          file_uploader = WinRM::FS::Core::FileUploader.new(cmd_executor)
+          bytes = file_uploader.upload(local_path, temp_path) do |bytes_copied, total_bytes|
+            yield bytes_copied, total_bytes, local_path, remote_path if block_given?
+          end
+
+          cmd_executor.run_powershell(
+            WinRM::FS::Scripts.render('decode_file', src: temp_path, dest: remote_path))
+
+          bytes
+        end
+
+        def with_command_executor
+          cmd_executor = WinRM::FS::Core::CommandExecutor.new(@service)
+          cmd_executor.open
+          yield cmd_executor
+        ensure
+          cmd_executor.close
+        end
+
+        def with_local_zip(local_paths)
+          local_zip = create_temp_zip_file(local_paths)
+          yield local_zip
+        ensure
+          local_zip.delete if local_zip
+        end
+
+        def out_of_date?(cmd_executor, local_path, remote_path)
+          local_checksum = local_checksum(local_path)
+          remote_checksum = remote_checksum(cmd_executor, remote_path)
+
+          if remote_checksum == local_checksum
+            @logger.debug("#{remote_path} is up to date")
+            return false
+          end
+          true
+        end
+
+        def remote_checksum(cmd_executor, remote_path)
+          script = WinRM::FS::Scripts.render('checksum', path: remote_path)
+          cmd_executor.run_powershell(script).chomp
+        end
+
+        def local_checksum(local_path)
+          Digest::MD5.file(local_path).hexdigest
+        end
+
+        def temp_file_path(local_path)
+          ext = '.tmp'
+          ext = '.zip' if File.extname(local_path) == '.zip'
+          "$env:TEMP/winrm-upload/#{local_checksum(local_path)}#{ext}"
+        end
+
+        def create_temp_zip_file(local_paths)
+          temp_zip = WinRM::FS::Core::TempZipFile.new
+          local_paths.each { |p| temp_zip.add(p) }
+          temp_zip
+        end
+      end
+    end
+  end
+end

data/lib/winrm-fs/exceptions.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module WinRM
+  module FS
+    # WinRM-FS base class for errors
+    class WinRMFSError < StandardError; end
+
+    # Error that occurs when a file upload fails
+    class WinRMUploadError < WinRMFSError; end
+
+    # Error that occurs when a file download fails
+    class WinRMDownloadError < WinRMFSError; end
+  end
+end

data/lib/winrm-fs/file_manager.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+#
+# Copyright 2015 Shawn Neal <sneal@sneal.net>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative 'scripts/scripts'
+require_relative 'core/upload_orchestrator'
+
+module WinRM
+  module FS
+    # Perform file transfer operations between a local machine and winrm endpoint
+    class FileManager
+      # Creates a new FileManager instance
+      # @param [WinRMWebService] WinRM web service client
+      def initialize(service)
+        @service = service
+        @logger = Logging.logger[self]
+      end
+
+      # Gets the MD5 checksum of the specified file if it exists,
+      # otherwise ''
+      # @param [String] The remote file path
+      def checksum(path)
+        @logger.debug("checksum: #{path}")
+        script = WinRM::FS::Scripts.render('checksum', path: path)
+        @service.powershell(script).stdout.chomp
+      end
+
+      # Create the specifed directory recursively
+      # @param [String] The remote dir to create
+      # @return [Boolean] True if successful, otherwise false
+      def create_dir(path)
+        @logger.debug("create_dir: #{path}")
+        script = WinRM::FS::Scripts.render('create_dir', path: path)
+        @service.powershell(script)[:exitcode] == 0
+      end
+
+      # Deletes the file or directory at the specified path
+      # @param [String] The path to remove
+      # @return [Boolean] True if successful, otherwise False
+      def delete(path)
+        @logger.debug("deleting: #{path}")
+        script = WinRM::FS::Scripts.render('delete', path: path)
+        @service.powershell(script)[:exitcode] == 0
+      end
+
+      # Downloads the specified remote file to the specified local path
+      # @param [String] The full path on the remote machine
+      # @param [String] The full path to write the file to locally
+      def download(remote_path, local_path)
+        @logger.debug("downloading: #{remote_path} -> #{local_path}")
+        script = WinRM::FS::Scripts.render('download', path: remote_path)
+        output = @service.powershell(script)
+        return false if output[:exitcode] != 0
+        contents = output.stdout.gsub('\n\r', '')
+        out = Base64.decode64(contents)
+        IO.binwrite(local_path, out)
+        true
+      end
+
+      # Checks to see if the given path exists on the target file system.
+      # @param [String] The full path to the directory or file
+      # @return [Boolean] True if the file/dir exists, otherwise false.
+      def exists?(path)
+        @logger.debug("exists?: #{path}")
+        script = WinRM::FS::Scripts.render('exists', path: path)
+        @service.powershell(script)[:exitcode] == 0
+      end
+
+      # Gets the current user's TEMP directory on the remote system, for example
+      # 'C:/Windows/Temp'
+      # @return [String] Full path to the temp directory
+      def temp_dir
+        @guest_temp ||= (@service.cmd('echo %TEMP%')).stdout.chomp.gsub('\\', '/')
+      end
+
+      # Upload one or more local files and directories to a remote directory
+      # @example copy a single directory to a winrm endpoint
+      #
+      #   file_manager.upload('c:/dev/my_dir', '$env:AppData')
+      #
+      # @example copy several paths to the winrm endpoint
+      #
+      #   file_manager.upload(['c:/dev/file1.txt','c:/dev/dir1'], '$env:AppData')
+      #
+      # @param [Array<String>] One or more paths that will be copied to the remote path.
+      #   These can be files or directories to be deeply copied
+      # @param [String] The target directory or file
+      #   This path may contain powershell style environment variables
+      # @yieldparam [Fixnum] Number of bytes copied in current payload sent to the winrm endpoint
+      # @yieldparam [Fixnum] The total number of bytes to be copied
+      # @yieldparam [String] Path of file being copied
+      # @yieldparam [String] Target path on the winrm endpoint
+      # @return [Fixnum] The total number of bytes copied
+      def upload(local_paths, remote_path, &block)
+        @logger.debug("uploading: #{local_paths} -> #{remote_path}")
+        local_paths = [local_paths] if local_paths.is_a? String
+
+        upload_orchestrator = WinRM::FS::Core::UploadOrchestrator.new(@service)
+        if FileManager.src_is_single_file?(local_paths)
+          upload_orchestrator.upload_file(local_paths[0], remote_path, &block)
+        else
+          upload_orchestrator.upload_directory(local_paths, remote_path, &block)
+        end
+      end
+
+      def self.src_is_single_file?(local_paths)
+        local_paths.count == 1 && File.file?(local_paths[0])
+      end
+    end
+  end
+end