winrm-fs 0.1.0

data/lib/winrm-fs/scripts/checksum.ps1.erb

@@ -0,0 +1,13 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+
+if (Test-Path $path -PathType Leaf) {
+  $cryptoProv = New-Object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider
+  $file = [System.IO.File]::Open($path,
+      [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read)
+  $md5 = ([System.BitConverter]::ToString($cryptoProv.ComputeHash($file)))
+  $md5 = $md5.Replace("-","").ToLower()
+  $file.Close()
+
+  Write-Host $md5
+}

data/lib/winrm-fs/scripts/create_dir.ps1.erb

@@ -0,0 +1,6 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (!(Test-Path $path)) {
+  New-Item -ItemType Directory -Force -Path $path | Out-Null
+}
+exit 0

data/lib/winrm-fs/scripts/decode_file.ps1.erb

@@ -0,0 +1,36 @@
+$path = $ExecutionContext.SessionState.Path
+$tempFile = $path.GetUnresolvedProviderPathFromPSPath("<%= src %>")
+$dest = $path.GetUnresolvedProviderPathFromPSPath("<%= dest %>")
+
+function Decode-File($encodedFile, $decodedFile) {
+    if (Test-Path $encodedFile) {
+      $base64Content = Get-Content $encodedFile
+    }
+    if ($base64Content -eq $null) {
+        New-Item -ItemType file -Force $decodedFile | Out-Null
+    }
+    else {
+        $bytes = [System.Convert]::FromBase64String($base64Content)
+        [System.IO.File]::WriteAllBytes($decodedFile, $bytes) | Out-Null
+    }
+}
+
+function Ensure-Dir-Exists($path) {
+    # ensure the destination directory exists
+    if (!(Test-Path $path)) {
+        New-Item -ItemType Directory -Force -Path $path | Out-Null
+    }
+}
+
+if ([System.IO.Path]::GetExtension($tempFile) -eq '.zip') {
+    Ensure-Dir-Exists $dest
+    Decode-File $tempFile $tempFile
+    $shellApplication = New-Object -com shell.application
+    $zipPackage = $shellApplication.NameSpace($tempFile)
+    $destinationFolder = $shellApplication.NameSpace($dest)
+    $destinationFolder.CopyHere($zipPackage.Items(), 0x10) | Out-Null
+}
+else {
+    Ensure-Dir-Exists ([System.IO.Path]::GetDirectoryName($dest))
+    Decode-File $tempFile $dest
+}

data/lib/winrm-fs/scripts/delete.ps1.erb

@@ -0,0 +1,6 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path) {
+  Remove-Item $path -Force -Recurse
+}
+exit 0

data/lib/winrm-fs/scripts/download.ps1.erb

@@ -0,0 +1,7 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path -PathType Leaf) {
+  [System.convert]::ToBase64String([System.IO.File]::ReadAllBytes($path))
+  exit 0
+}
+exit 1

data/lib/winrm-fs/scripts/exists.ps1.erb

@@ -0,0 +1,8 @@
+$p = $ExecutionContext.SessionState.Path
+$path = $p.GetUnresolvedProviderPathFromPSPath("<%= path %>")
+if (Test-Path $path) {
+  exit 0
+}
+else {
+  exit 1
+}

data/lib/winrm-fs/scripts/scripts.rb

@@ -0,0 +1,31 @@
+# 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 'erubis'
+
+module WinRM
+  module FS
+    # PS1 scripts
+    module Scripts
+      def self.render(template, context)
+        template_path = File.expand_path(
+          "#{File.dirname(__FILE__)}/#{template}.ps1.erb")
+        template = File.read(template_path)
+        Erubis::Eruby.new(template).result(context)
+      end
+    end
+  end
+end

data/spec/config-example.yml

@@ -0,0 +1,5 @@
+auth_type: plaintext
+endpoint: "http://localhost:55985/wsman"
+options:
+  user: vagrant
+  pass: vagrant

data/spec/file_manager_spec.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+describe WinRM::FS::FileManager, integration: true do
+  let(:dest_dir) { File.join(subject.temp_dir, "winrm_#{rand(2**16)}") }
+  let(:temp_upload_dir) { '$env:TEMP/winrm-upload' }
+  let(:src_dir) { File.expand_path(File.dirname(__FILE__)) }
+  let(:service) { winrm_connection }
+
+  subject { WinRM::FS::FileManager.new(service) }
+
+  before(:each) do
+    expect(subject.delete(dest_dir)).to be true
+    expect(subject.delete(temp_upload_dir)).to be true
+  end
+
+  context 'exists?' do
+    it 'should exist' do
+      expect(subject.exists?('c:/windows')).to be true
+      expect(subject.exists?('c:/foobar')).to be false
+    end
+  end
+
+  context 'create and delete dir' do
+    it 'should create the directory recursively' do
+      subdir = File.join(dest_dir, 'subdir1', 'subdir2')
+      expect(subject.create_dir(subdir)).to be true
+      expect(subject.exists?(subdir)).to be true
+      expect(subject.create_dir(subdir)).to be true
+      expect(subject.delete(subdir)).to be true
+      expect(subject.exists?(subdir)).to be false
+    end
+  end
+
+  context 'temp_dir' do
+    it 'should return the remote users temp dir' do
+      expect(subject.temp_dir).to match(%r{C:/Users/\w+/AppData/Local/Temp})
+    end
+  end
+
+  context 'upload file' do
+    let(:src_file) { __FILE__ }
+    let(:dest_file) { File.join(dest_dir, File.basename(src_file)) }
+
+    before(:each) do
+      expect(subject.delete(dest_dir)).to be true
+    end
+
+    it 'should upload the file to the specified file' do
+      subject.upload(src_file, dest_file)
+      expect(subject).to have_created(dest_file).with_content(src_file)
+    end
+
+    it 'should upload the file to the specified directory' do
+      subject.upload(src_file, dest_dir)
+      expect(subject).to have_created(dest_file).with_content(src_file)
+    end
+
+    it 'should upload the file to the specified directory with env var' do
+      subject.upload(src_file, '$env:Temp')
+      expected_dest_file = File.join(subject.temp_dir, File.basename(src_file))
+      expect(subject).to have_created(expected_dest_file).with_content(src_file)
+    end
+
+    it 'should upload the file to the specified nested directory' do
+      dest_sub_dir = File.join(dest_dir, 'subdir')
+      dest_sub_dir_file = File.join(dest_sub_dir, File.basename(src_file))
+      subject.upload(src_file, dest_sub_dir)
+      expect(subject).to have_created(dest_sub_dir_file).with_content(src_file)
+    end
+
+    it 'yields progress data' do
+      total = subject.upload(src_file, dest_file) do \
+        |bytes_copied, total_bytes, local_path, remote_path|
+        expect(total_bytes).to be > 0
+        expect(bytes_copied).to eq(total_bytes)
+        expect(local_path).to eq(src_file)
+        expect(remote_path).to eq(dest_file)
+      end
+      expect(total).to be > 0
+    end
+
+    it 'should not upload the file when content matches' do
+      subject.upload(src_file, dest_dir)
+      bytes_uploaded = subject.upload(src_file, dest_dir)
+      expect(bytes_uploaded).to eq 0
+    end
+
+    it 'should upload file when content differs' do
+      another_src_file = File.join(src_dir, 'matchers.rb')
+      subject.upload(another_src_file, dest_file)
+      bytes_uploaded = subject.upload(src_file, dest_file)
+      expect(bytes_uploaded).to be > 0
+    end
+
+    it 'raises WinRMUploadError when a bad source path is specified' do
+      expect { subject.upload('c:/some/non-existant/path/foo', dest_file) }.to raise_error
+    end
+  end
+
+  context 'upload empty file' do
+    let(:src_file) { __FILE__ }
+    let(:empty_src_file) { Tempfile.new('empty').path }
+    let(:dest_file) { File.join(dest_dir, 'emptyfile.txt') }
+
+    it 'creates a new empty file' do
+      expect(subject.upload(empty_src_file, dest_file)).to be 0
+      expect(subject).to have_created(dest_file).with_content('')
+    end
+
+    it 'overwrites an existing file' do
+      expect(subject.upload(src_file, dest_file)).to be > 0
+      expect(subject.upload(empty_src_file, dest_file)).to be 0
+      expect(subject).to have_created(dest_file).with_content('')
+    end
+  end
+
+  context 'upload directory' do
+    it 'copies the entire directory' do
+      bytes_uploaded = subject.upload(src_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+      Dir.glob(src_dir + '/*.rb').each do |host_file|
+        host_file_rel = host_file[src_dir.length..-1]
+        remote_file = File.join(dest_dir, host_file_rel)
+        expect(subject).to have_created(remote_file).with_content(host_file)
+      end
+    end
+
+    it 'does not copy the directory when content is the same' do
+      subject.upload(src_dir, dest_dir)
+      bytes_uploaded = subject.upload(src_dir, dest_dir)
+      expect(bytes_uploaded).to eq 0
+    end
+
+    it 'copies the directory when content differs' do
+      subject.upload(src_dir, dest_dir)
+      another_dir = File.dirname(src_dir)
+      bytes_uploaded = subject.upload(another_dir, dest_dir)
+      expect(bytes_uploaded).to be > 0
+    end
+  end
+end

data/spec/matchers.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+require 'rspec/expectations'
+
+RSpec::Matchers.define :have_created do |remote_file|
+  match do |file_manager|
+    if @expected_content
+      downloaded_file = Tempfile.new('downloaded')
+      downloaded_file.close
+
+      subject.download(remote_file, downloaded_file.path)
+      @actual_content = File.read(downloaded_file.path)
+      downloaded_file.delete
+
+      file_manager.exists?(remote_file) && \
+        @actual_content == @expected_content
+    else
+      file_manager.exists?(remote_file)
+    end
+  end
+  chain :with_content do |expected_content|
+    expected_content = File.read(expected_content) if File.file?(expected_content)
+    @expected_content = expected_content
+  end
+  failure_message do
+    if @expected_content
+      <<-EOH
+Expected file '#{remote_file}' to exist with content:
+
+#{@expected_content}
+
+but instead got content:
+
+#{@actual_content}
+      EOH
+    else
+      "Expected file '#{remote_file}' to exist"
+    end
+  end
+end
+
+RSpec::Matchers.define :contain_zip_entries do |zip_entries|
+  match do |temp_zip_file|
+    zip_entries = [zip_entries] if zip_entries.is_a? String
+    zip_file = Zip::File.open(temp_zip_file.path)
+    @missing_entries = []
+    zip_entries.each do |entry|
+      @missing_entries << entry unless zip_file.find_entry(entry)
+    end
+    @missing_entries.empty?
+  end
+  failure_message do |temp_zip_file|
+    "Expected #{temp_zip_file.path} to contain zip entries: #{@missing_entries}"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler/setup'
+require 'winrm-fs'
+require 'json'
+require_relative 'matchers'
+
+# Creates a WinRM connection for integration tests
+module ConnectionHelper
+  def winrm_connection
+    config = symbolize_keys(YAML.load(File.read(winrm_config_path)))
+    config[:options].merge!(basic_auth_only: true) unless config[:auth_type].eql? :kerberos
+    winrm = WinRM::WinRMWebService.new(
+      config[:endpoint], config[:auth_type].to_sym, config[:options])
+    winrm
+  end
+
+  def winrm_config_path
+    # Copy config-example.yml to config.yml and edit for your local configuration
+    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
+    unless File.exist?(path)
+      # user hasn't done this, so use sane defaults for unit tests
+      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
+    end
+    path
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def symbolize_keys(hash)
+    hash.each_with_object({}) do |(key, value), result|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end
+
+RSpec.configure do |config|
+  config.include(ConnectionHelper)
+end

data/spec/temp_zip_file_spec.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+require 'zip'
+require_relative '../lib/winrm-fs/core/temp_zip_file'
+
+describe WinRM::FS::Core::TempZipFile, integration: true do
+  let(:src_dir) { File.expand_path('../lib/winrm-fs', File.dirname(__FILE__)) }
+  let(:src_file) { __FILE__ }
+
+  subject { WinRM::FS::Core::TempZipFile.new }
+  after(:each) { subject.delete }
+
+  context 'temp file creation' do
+    it 'should create a temp file on disk' do
+      expect(File.exist?(subject.path)).to be true
+      subject.delete
+      expect(File.exist?(subject.path)).to be false
+    end
+  end
+
+  context 'add_file' do
+    it 'should raise error when file doesn not exist' do
+      expect { subject.add_file('/etc/foo/does/not/exist') }.to \
+        raise_error('/etc/foo/does/not/exist isn\'t a file')
+    end
+
+    it 'should raise error when file is a directory' do
+      dir = File.dirname(subject.path)
+      expect { subject.add_file(dir) }.to \
+        raise_error("#{dir} isn\'t a file")
+    end
+
+    it 'should add a file to the zip' do
+      subject.add_file(src_file)
+      expect(subject).to contain_zip_entries(File.basename(src_file))
+    end
+  end
+
+  context 'add_directory' do
+    it 'should raise error when directory does not exist' do
+      expect { subject.add_directory('/etc/does/not/exist') }.to \
+        raise_error('/etc/does/not/exist isn\'t a directory')
+    end
+
+    it 'should raise error when directory is a file' do
+      expect { subject.add_directory(subject.path) }.to \
+        raise_error("#{subject.path} isn\'t a directory")
+    end
+
+    it 'should add all files in directory to the zip recursively' do
+      subject.add_directory(src_dir)
+      expect(subject).to contain_zip_entries(['exceptions.rb', 'core/temp_zip_file.rb'])
+    end
+  end
+
+  context 'add' do
+    it 'should add all files when given a directory' do
+      subject.add(src_dir)
+      expect(subject).to contain_zip_entries(['exceptions.rb', 'core/temp_zip_file.rb'])
+    end
+
+    it 'should add a file when given only a file' do
+      subject.add(src_file)
+      expect(subject).to contain_zip_entries(File.basename(src_file))
+    end
+
+    it 'should raise error when given a non-path' do
+      expect { subject.add('garbage') }.to \
+        raise_error("garbage doesn't exist")
+    end
+  end
+end

data/winrm-fs.gemspec

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+require 'date'
+
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name = 'winrm-fs'
+  s.version = version
+  s.date		= Date.today.to_s
+
+  s.author = ['Shawn Neal', 'Matt Wrock']
+  s.email = ['sneal@sneal.net', 'matt@mattwrock.com']
+  s.homepage = 'http://github.com/WinRb/winrm-fs'
+
+  s.summary = 'WinRM File System'
+  s.description	= <<-EOF
+    Ruby library for file system operations via Windows Remote Management
+  EOF
+
+  s.files = `git ls-files`.split(/\n/)
+  s.require_path = 'lib'
+  s.rdoc_options	= %w(-x test/ -x examples/)
+  s.extra_rdoc_files = %w(README.md LICENSE)
+
+  s.bindir = 'bin'
+  s.executables   = ['rwinrmcp']
+  s.required_ruby_version	= '>= 1.9.0'
+  s.add_runtime_dependency 'erubis', '~> 2.7'
+  s.add_runtime_dependency 'logging', '~> 1.6', '>= 1.6.1'
+  s.add_runtime_dependency 'rubyzip', '~> 1.1'
+  s.add_runtime_dependency 'winrm', '~> 1.3.0'
+  s.add_development_dependency 'rspec', '~> 3.0.0'
+  s.add_development_dependency 'rake', '~> 10.3.2'
+  s.add_development_dependency 'rubocop', '~> 0.28.0'
+end