imw 0.1.1 → 0.2.0

data/spec/imw/resources/schemes/hdfs_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__),'../../../spec_helper')
+
+describe IMW::Resources::Schemes::HDFS do
+  before do
+    def fake_hdfs_resource path, num_dirs=nil, num_files=nil, size=nil
+      if num_dirs && num_files && size
+        response = "           #{num_dirs}            #{num_files}              #{size} hdfs://localhost#{path}"
+      else
+        response = ""
+      end
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:count, path).and_return(response)
+      IMW.open("hdfs://#{path}")
+    end
+    @path = '/path/to/myfile'    
+  end
+  
+  describe "refreshing its properties" do
+    it "should correctly get properties for a resource which exists" do
+      resource = fake_hdfs_resource(@path, 2, 3, 1000)
+      resource.exist?.should    be_true
+      resource.num_dirs.should  == 2
+      resource.num_files.should == 3
+      resource.size.should      == 1000
+    end
+
+    it "should gracefully handle a resource which doesn't exist" do
+      resource = fake_hdfs_resource(@path)
+      resource.exist?.should be_false
+    end
+
+    it "should execute the correct command to delete the path" do
+      resource = fake_hdfs_resource(@path, 2, 3, 1000)
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:rm, resource.path)
+      resource.rm
+    end
+
+    it "should execute the correct command to delete the path when skipping the trash" do
+      resource = fake_hdfs_resource(@path, 2, 3, 1000)      
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:rm, '-skipTrash', resource.path)
+      resource.rm :skip_trash => true
+    end
+
+    it "should recognize a file and extend it properly" do
+      resource = fake_hdfs_resource(@path, 0, 1, 1000)
+      resource.num_dirs.should == 0      
+      resource.num_files.should == 1
+      resource.exist?.should be_true
+      resource.is_directory?.should be_false
+      resource.resource_modules.should include(IMW::Resources::Schemes::HDFSFile)
+    end
+
+    it "should recognize a directory and extend it properly" do
+      resource = fake_hdfs_resource(@path, 2, 1, 1000)
+      resource.num_dirs.should == 2
+      resource.num_files.should == 1
+      resource.exist?.should be_true
+      resource.is_directory?.should be_true
+      resource.resource_modules.should include(IMW::Resources::Schemes::HDFSDirectory)
+    end
+  end
+end

data/spec/imw/resources/schemes/http_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__),'../../../spec_helper')
+
+describe IMW::Resources::Schemes::HTTP do
+
+  describe "finding its effective basename" do
+    it "should use the real basename when present" do
+      IMW.open('http://www.google.com/foobar').effective_basename.should == 'foobar'
+    end
+
+    it "should use '_index' when at the root (without a slash)" do
+      IMW.open('http://www.google.com').effective_basename.should == '_index'
+    end
+
+    it "should use '_index' when at the root (even when a slash is given)" do
+      IMW.open('http://www.google.com/').effective_basename.should == '_index'
+    end
+    
+  end
+end

data/spec/imw/resources/schemes/s3_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__),'../../../spec_helper')
+
+describe IMW::Resources::Schemes::S3 do
+
+  describe 'manipulating S3 paths' do
+    before do
+      @resource = IMW::Resource.new('s3://mybucket/foobar/foo.txt')
+    end
+
+    it "should set the bucket" do
+      @resource.bucket.should == 'mybucket'
+    end
+
+    it "can generate an S3N url" do
+      @resource.s3n_url.should == 's3n://mybucket/foobar/foo.txt'
+    end
+  end
+  
+end

data/spec/imw/transforms/archiver_spec.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe IMW::Transforms::Archiver do
+  before do
+    @name = 'foobar'
+
+    # remote files
+    @homepage = "http://www.google.com"
+    @website  = "http://www.google.com/support/"
+    @remote_files = [@homepage, @website]
+
+    # regular files
+    @csv  = "foobar-csv.csv"
+    @xml  = "foobar-xml.xml"
+    @txt  = "foobar-txt.txt"
+    @blah = "foobar"
+    @files = [@csv, @xml, @txt, @blah]
+
+    # compressed files
+    @bz2  = "foobar-bz2.bz2"
+    @gz   = "foobar-gz.gz"
+    @compressed_files = [@bz2, @gz]
+
+    # archives
+    @zip      = "foobar-zip.zip"
+    @tarbz2   = "foobar-tarbz2.tar.bz2"
+    @targz    = "foobar-targz.tar.gz"
+    @tar      = "foobar-tar.tar"
+    @rar      = "foobar-rar.rar"
+    @archives = [@zip, @tarbz2, @targz, @rar, @tar]
+
+    @local_files = @files + @compressed_files + @archives
+
+    @all_files = @remote_files + @local_files
+    
+    @local_files.each do |path|
+      IMWTest::Random.file path
+    end
+
+    @archiver = IMW::Transforms::Archiver.new @name, @all_files
+  end
+
+  after do
+    @archiver.clean!
+  end
+  
+  describe "preparing input files" do
+    
+    describe "before preparing input files" do
+      it "should not be prepared when initialized" do
+        @archiver.prepared?.should be_false
+      end
+    end
+
+    describe "after preparing files" do
+      before { @archiver.prepare! }
+
+      it "should be prepared" do
+        @archiver.prepared?.should be_true
+      end
+
+      it "should name its archive directory properly" do
+        @archiver.tmp_dir.should contain(@name)
+      end
+      
+      it "should copy regular files to its archive directory" do
+        @archiver.dir.should contain(*@files)
+        @local_files.each { |path| IMW.open(path).exist?.should be_true }
+      end
+
+      it "should copy remote files to its archive directory" do
+        @archiver.dir.should contain('_index', 'support') # _index from Http#effective_basename on http://www.google.com
+      end
+
+      it "should uncompress compressed files to its archive directory" do
+        @archiver.dir.should     contain('foobar-bz2', 'foobar-gz')
+        @archiver.dir.should_not contain(*@compressed_files)
+      end
+      
+      it "should copy the content of archive files to its archive directory (but not the actual archives)" do
+        @archives.each do |archive|
+          @archiver.dir.should_not contain(archive)
+          @archiver.dir.should     contain(*IMW.open(archive).contents)
+        end
+      end
+
+    end
+  end
+  
+  describe "when packaging files" do
+    @packages = ["package.tar.bz2", "package.zip", "package.tar.gz", "package.tar", "package.rar"]
+
+    @packages.each do |package|    
+      it "should create a #{package} file containing all the files and return it" do
+        output = @archiver.package!(package)
+        output.basename.should == package
+        @archiver.tmp_dir.should contain(IMW.open(package).contents)
+      end
+    end
+
+    describe 'when packaging into multiple output formats' do
+
+      it "should prepare input files without being asked" do
+        @archiver.prepared?.should be_false
+        @archiver.package! 'package.tar.bz2'
+        @archiver.prepared?.should be_true
+      end
+      
+      it "should not prepare input files once they've already been prepared" do
+        @archiver.prepared?.should be_false
+        @archiver.package! 'package.tar.bz2'
+        @archiver.prepared?.should be_true        
+        @archiver.should_not_receive(:prepare!)
+        @archiver.package! 'package.tar.gz'
+      end
+    end
+  end
+end
+
+

data/spec/imw/transforms/transferer_spec.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + "/../../spec_helper"
+
+describe IMW::Transforms::Transferer do
+  before do
+    @local  = IMW.open("foobar.txt")
+    @http   = IMW.open("http://www.google.com")
+    @hdfs   = IMW.open("hdfs:///path/to/foobar.txt")
+    @s3     = IMW.open("s3://mybucket/foo/bar")
+  end
+
+  it "should raise an error unless the action is one of :cp, :copy, :mv :move, or :mv!" do
+    IMW::Transforms::Transferer.new(:cp,   @local, @http).should be
+    IMW::Transforms::Transferer.new(:copy, @local, @http).should be
+    IMW::Transforms::Transferer.new(:mv,   @local, @http).should be
+    IMW::Transforms::Transferer.new(:move, @local, @http).should be
+    IMW::Transforms::Transferer.new(:mv!,  @local, @http).should be
+    lambda { IMW::Transforms::Transferer.new(:foobar, @local, @http) }.should raise_error(IMW::ArgumentError)
+  end
+
+  it "should raise an error if the source and the destination have the same URI" do
+    lambda { IMW::Transforms::Transferer.new(:cp, @local, @local) }.should raise_error(IMW::PathError)
+  end
+
+  describe "transfering local files" do
+    it "should raise an error if the source doesn't exist" do
+      lambda { IMW::Transforms::Transferer.new(:cp, @local, 'barbaz.txt').transfer! }.should raise_error(IMW::PathError)
+    end
+
+    it "can copy a local file" do
+      IMWTest::Random.file @local.path
+      IMW::Transforms::Transferer.new(:cp, @local, 'barbaz.txt').transfer!
+      @local.exist?.should be_true
+      IMW.open('barbaz.txt').exist?.should be_true
+    end
+
+    it "can move a local file" do
+      IMWTest::Random.file @local.path 
+      IMW::Transforms::Transferer.new(:mv, @local, 'barbaz.txt').transfer!
+      @local.exist?.should be_false
+      IMW.open('barbaz.txt').exist?.should be_true
+    end
+
+  end
+
+  describe "transferring HTTP files" do
+    it "can copy a remote file to a local path" do
+      IMW::Transforms::Transferer.new(:cp, @http, @local).transfer!
+      @local.exist?.should be_true
+    end
+  end
+
+  describe "transferring S3 files" do
+
+    it "can copy an S3 file to a local path" do
+      IMW::Resources::Schemes::S3.should_receive(:get).with(@s3, @local)
+      IMW::Transforms::Transferer.new(:cp, @s3, @local).transfer!
+    end
+
+    it "can copy a local path to an S3 file" do
+      IMWTest::Random.file @local.path
+      IMW::Resources::Schemes::S3.should_receive(:put).with(@local, @s3)
+      IMW::Transforms::Transferer.new(:cp, @local, @s3).transfer!
+    end
+
+    it "can copy between S3 files" do
+      @new_s3 = IMW.open('s3://mybucket/new/path')
+      IMW::Resources::Schemes::S3.should_receive(:copy).with(@s3, @new_s3)
+      IMW::Transforms::Transferer.new(:cp, @s3, @new_s3).transfer!
+    end
+  end
+
+  describe "transferring HDFS files" do
+    before do
+      IMW::Resources::Schemes::HDFS.stub!(:fs)
+    end
+
+    it "can copy a local file to an HDFS path" do
+      IMWTest::Random.file @local.path
+
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:put, @local.path, @hdfs.path)
+      IMW::Transforms::Transferer.new(:cp, @local, @hdfs).transfer!
+    end
+
+    it "can copy an HDFS file to a local path" do
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:get, @hdfs.path, @local.path)
+      IMW::Transforms::Transferer.new(:cp, @hdfs, @local).transfer!
+    end
+
+    it "can copy between HDFS paths" do
+      @new_hdfs = IMW.open('hdfs:///a/new/path')
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:cp, @hdfs.path, @new_hdfs.path)
+      IMW::Transforms::Transferer.new(:cp, @hdfs, @new_hdfs).transfer!
+    end
+
+    it "can move between HDFS paths" do
+      @new_hdfs = IMW.open('hdfs:///a/new/path')
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:mv, @hdfs.path, @new_hdfs.path)
+      IMW::Transforms::Transferer.new(:mv, @hdfs, @new_hdfs).transfer!
+    end
+
+    it "can copy from S3 to HDFS" do
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:cp, @s3.s3n_url, @hdfs.path)
+      IMW::Transforms::Transferer.new(:cp, @s3, @hdfs).transfer!
+    end
+
+    it "can copy from HDFS to S3" do
+      IMW::Resources::Schemes::HDFS.should_receive(:fs).with(:cp, @hdfs.path, @s3.s3n_url)
+      IMW::Transforms::Transferer.new(:cp, @hdfs, @s3).transfer!
+    end
+  end
+end
+
+

data/spec/imw/utils/paths_spec.rb

@@ -1,38 +1,10 @@
 require File.join(File.dirname(__FILE__),'../../spec_helper')
-require 'imw'
-require 'imw/utils/paths'
+require File.join(File.dirname(__FILE__), '/shared_paths_spec')
 
 describe IMW do
-  include IMW
-  before(:each) do
-    IMW::PATHS = {
-      :data    => '/data',
-      :weather => 'ftp.ncdc.noaa.gov/pub/data/noaa',
-      :first   => ['1', :second, 'last'],
-      :second  => ['2', :third],
-      :third   => ['3'],
-    }
+  before do
+    @path_manager = IMW
   end
-
-  it 'is idempotent on a string' do
-    path_to('hi').should == 'hi'
-  end
-
-  it 'has an absolute path to the data dir' do
-    path_to(:data).should =~ %r{^/}
-  end
-
-  it 'handles mixed array and sym args' do
-    path_to( [:data, 'hi'], [[['there']]]).should == '/data/hi/there'
-  end
-
-  it 'expands to later generations' do
-    path_to(:first).should == File.join('1/2/3/last')
-  end
-
-  it 'expands interior symbols' do
-    path_to(['hadoop1:/working', :data, :weather]).should ==
-      File.join('hadoop1:/working/data/ftp.ncdc.noaa.gov/pub/data/noaa')
-  end
-
+  it_should_behave_like "an object that manages paths"
 end
+

data/spec/imw/utils/shared_paths_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__),'../../spec_helper')
+
+share_examples_for "an object that manages paths" do
+  before do
+    @path_manager.add_path :testing, '/testing'
+    @path_manager.add_path :first,   '/1'
+  end
+  
+  it 'returns a string when given a string' do
+    @path_manager.path_to('hi').should == 'hi'
+  end
+
+  it 'returns a path when given a registered symbol' do
+    @path_manager.path_to(:testing).should == '/testing'
+  end
+
+  it 'raises an error when given a unregistered symbol' do
+    lambda { @path_manager.path_to(:foobar) }.should raise_error(IMW::PathError)
+  end
+  
+  it 'returns a constructed path when passed a mixture of symbols, strings, and arrays ' do
+    @path_manager.path_to( [:testing, 'hi'], [[['there']]]).should == '/testing/hi/there'
+  end
+  
+  it 'will correctly expand paths themselves defined via symbols' do
+    @path_manager.add_path(:first, :testing, '1')
+    @path_manager.path_to(:first).should == '/testing/1'
+  end
+end

data/spec/spec_helper.rb

@@ -1,23 +1,23 @@
 IMW_ROOT_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..') unless defined? IMW_ROOT_DIR
-IMW_SPEC_DIR = File.join(IMW_ROOT_DIR, 'spec')         unless defined? IMW_SPEC_DIR
-IMW_LIB_DIR  = File.join(IMW_ROOT_DIR, 'lib')          unless defined? IMW_LIB_DIR
+IMW_SPEC_DIR = File.join(IMW_ROOT_DIR, 'spec')                           unless defined? IMW_SPEC_DIR
+IMW_LIB_DIR  = File.join(IMW_ROOT_DIR, 'lib')                            unless defined? IMW_LIB_DIR
 $: << IMW_LIB_DIR
 
 require 'rubygems'
 require 'spec'
-require 'fileutils'
 require 'imw'
 
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |path| require path }
 
 module IMWTest
-  TMP_DIR = "/tmp/imwtest"
+  TMP_DIR   = "/tmp/imwtest" unless defined?(TMP_DIR)
+  DATA_DIR  = File.join(IMW_SPEC_DIR, 'data') unless defined?(DATA_DIR)
 end
 
 Spec::Runner.configure do |config|
 
   config.include CustomMatchers
-
+  
   config.before do
     FileUtils.mkdir_p IMWTest::TMP_DIR
     FileUtils.cd IMWTest::TMP_DIR

data/spec/support/paths_matcher.rb

@@ -0,0 +1,67 @@
+require 'set'
+
+module Spec
+  module Matchers
+    module IMW
+
+      class PathsMatcher
+
+        attr_accessor :given, :given_contents, :given_base, :to_match, :to_match_contents, :to_match_base
+
+        def initialize given, options={}
+          @given_base     = options[:given_base] || options[:relative_to]
+          @to_match_base  = options[:to_match_base]
+          @given          = given
+          @given_contents = get_contents(given, given_base)
+        end
+        
+        def matches? to_match
+          @to_match          = to_match
+          @to_match_contents = get_contents(to_match, to_match_base)
+          to_match_contents == given_contents
+        end
+
+        def failure_message
+          given_string    = given_contents.to_a.join("\n\t")
+          to_match_string = to_match_contents.to_a.join("\n\t")          
+          "expected contents to be identical.\n\ngiven #{given.inspect}:\n\t#{given_string}\n\nto match #{to_match}:\n\t#{to_match_string}"
+        end
+
+        def negative_failure_message
+          "expected contents of #{given} and #{to_match} to be different"
+        end
+
+        protected
+        def get_contents obj, base=nil
+          if obj.is_a?(String) || obj.is_a?(Array)
+            contents = [obj].flatten.map do |raw_path|
+              path = File.expand_path(raw_path)
+              if File.directory?(path)
+                Dir[path + "/**/*"]
+              else
+                path
+              end
+            end.flatten
+          else
+            # obj is an IMW obj (archive or directory) so it has a
+            # contents method
+            contents = obj.contents
+          end
+          if base
+            contents.map do |path|
+              new_path = path[base.length + 1..-1]
+              new_path = nil if !new_path.nil? && new_path.size == 0
+              new_path
+            end.compact.to_set
+          else
+            contents.to_set
+          end
+        end
+      end
+      
+      def contain_paths_like given, options={}
+        PathsMatcher.new(given, options)
+      end
+    end
+  end
+end

data/spec/support/random.rb

@@ -3,36 +3,23 @@ require 'fileutils'
 module IMWTest
   module Random
 
-    STRING_CHARS        = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' ']
-    TEXT_CHARS          = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' ',"\n"]
-    FILENAME_CHARS      = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["-","_"]
-    FILENAME_MAX_LENGTH = 9
-    TEXT_MAX_LENGTH     = 1024
-    EXTENSIONS          = {
-      /\.csv$/      => :csv_file,
-      /\.xml$/      => :xml_file,
-      /\.html$/     => :html_file,
-      /\.tar$/      => :tar_file,
-      /\.tar\.gz$/  => :targz_file,
-      /\.tar\.bz2$/ => :tarbz2_file,
-      /\.rar$/      => :rar_file,
-      /\.zip$/      => :zip_file
-    }
-    EXTERNAL_PROGRAMS = if defined?(IMW) && defined?(IMW::EXTERNAL_PROGRAMS)
-                          IMW::EXTERNAL_PROGRAMS
-                        else
-                          {
-        :tar => "tar",
-        :rar => "rar",
-        :zip => "zip",
-        :unzip => "unzip",
-        :gzip => "gzip",
-        :bzip2 => "bzip2",
-        :wget => "wget"
-      }
-                        end
-
-    private
+    STRING_CHARS        = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' '] unless defined?(STRING_CHARS)
+    TEXT_CHARS          = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + [' ',' ',' ',' ',' ',"\n"] unless defined?(TEXT_CHARS)
+    FILENAME_CHARS      = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a + ["-","_",' '] unless defined?(FILENAME_CHARS)
+    FILENAME_MAX_LENGTH = 9 unless defined?(FILENAME_MAX_LENGTH)
+    TEXT_MAX_LENGTH     = 1024 unless defined?(TEXT_MAX_LENGTH)
+    EXTENSIONS          = [
+                           [/\.csv$/      , :csv_file],
+                           [/\.xml$/      , :xml_file],
+                           [/\.html$/     , :html_file],
+                           [/\.tar\.gz$/  , :targz_file],
+                           [/\.tar\.bz2$/ , :tarbz2_file],
+                           [/\.bz2$/      , :bz2_file],
+                           [/\.gz$/       , :gz_file],
+                           [/\.tar$/      , :tar_file],                           
+                           [/\.rar$/      , :rar_file],
+                           [/\.zip$/      , :zip_file]
+                         ] unless defined?(EXTENSIONS)
     # Return a random filename.  Optional +length+ to set the maximum
     # length of the filename returned.
     def self.basename options = {}
@@ -54,7 +41,6 @@ module IMWTest
       (1..length).map { |i| char_pool.random }.join
     end
 
-    public
     # Create a random file by matching the extension of the given
     # +filename+ or a text file if no match is found.
     def self.file filename
@@ -115,7 +101,7 @@ module IMWTest
     def self.tar_file filename
       tmpd = File.dirname(filename) + '/dir'
       directory_with_files(tmpd)
-      FileUtils.cd(tmpd) {|dir| system("#{EXTERNAL_PROGRAMS[:tar]} -cf file.tar *") }
+      FileUtils.cd(tmpd) {|dir| system("tar -cf file.tar *") }
       FileUtils.cp(tmpd + "/file.tar",filename)
       FileUtils.rm_rf(tmpd)
     end
@@ -126,7 +112,7 @@ module IMWTest
       tar = File.dirname(filename) + "/file.tar"
       targz = tar + ".gz"
       tar_file tar
-      system("#{EXTERNAL_PROGRAMS[:gzip]} #{tar}")
+      system("gzip #{tar}")
       FileUtils.cp(targz,filename)
       FileUtils.rm(targz)
     end
@@ -137,17 +123,34 @@ module IMWTest
       tar = File.dirname(filename) + "/file.tar"
       tarbz2 = tar + ".bz2"
       tar_file tar
-      system("#{EXTERNAL_PROGRAMS[:bzip2]} #{tar}")
+      system("bzip2 #{tar}")
       FileUtils.cp(tarbz2,filename)
       FileUtils.rm(tarbz2)
     end
 
+    # Create a .bz2 file at the given +filename+.
+    def self.bz2_file filename
+      text_path = File.dirname(filename) + "/fake_file"
+      text_file(text_path)
+      system("bzip2 #{text_path}")
+      FileUtils.mv(text_path + ".bz2", filename)
+    end
+
+    # Create a .gz file at the given +filename+.
+    def self.gz_file filename
+      text_path = File.dirname(filename) + "/fake_file"
+      text_file(text_path)
+      system("gzip #{text_path}")
+      FileUtils.mv(text_path + ".gz", filename)
+    end
+    
+
     # Create a compressed rar archive at the given +filename+
     # containing random files.
     def self.rar_file filename
       tmpd = File.dirname(filename) + '/dir'
       directory_with_files(tmpd)
-      FileUtils.cd(tmpd) {|dir| system("#{EXTERNAL_PROGRAMS[:rar]} a -r -o+ file.rar *") }
+      FileUtils.cd(tmpd) {|dir| system("rar a -o+ -inul file.rar *") }
       FileUtils.cp(tmpd + "/file.rar",filename)
       FileUtils.rm_rf(tmpd)
     end
@@ -157,7 +160,7 @@ module IMWTest
     def self.zip_file filename
       tmpd = File.dirname(filename) + '/dir'
       directory_with_files(tmpd)
-      FileUtils.cd(tmpd) {|dir| system("#{EXTERNAL_PROGRAMS[:zip]} -r file.zip *") }
+      FileUtils.cd(tmpd) {|dir| system("zip -qqr file.zip *") }
       FileUtils.cp(tmpd + "/file.zip",filename)
       FileUtils.rm_rf(tmpd)
     end