cifrado 0.1

data/tests/swift_client/match_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Cifrado | SwiftClient#match') do
+
+  obj = create_bin_payload 1
+
+  tests("#match") do
+
+    response = client.upload(test_container_name, obj) 
+
+    test "#{test_container_name}/#{obj} available" do
+      (client.match obj, test_container_name) == 1
+    end
+    
+    test "#{test_container_name}////#{obj} available" do
+      (client.match "///" + obj, test_container_name) == 1
+    end
+    
+    test "#{test_container_name}/#{obj} MD5 changed" do
+      File.open(obj, 'w') { |f| f.puts 'foo' }
+      (client.match obj, test_container_name) == 2
+    end
+    
+    test "#{test_container_name}/#{obj} not available" do
+      clean_test_container
+      (client.match obj, test_container_name) == 0
+    end
+
+  end
+
+end

data/tests/swift_client/upload_tests.rb

@@ -0,0 +1,70 @@
+Shindo.tests('Cifrado | SwiftClient#upload') do
+
+  obj = create_bin_payload 1
+
+  tests("#upload") do
+
+    tests("responds to") do
+      [:upload].each do |m|
+        test "#{m}" do
+          client.respond_to? m
+        end
+      end
+    end
+
+    raises ArgumentError, "ArgumentError when container nil" do
+      client.upload nil, 'foo'
+    end
+    raises ArgumentError, "ArgumentError when object nil" do
+      client.upload 'foo', nil
+    end
+    raises ArgumentError, "when not enough arguments" do
+      client.upload
+    end
+
+    tests "success" do
+      test "upload OK" do
+        response = client.upload('cifrado-tests', obj) 
+        response.status == 201
+      end
+
+      test "correct path" do
+        file = create_bin_payload 1
+        client.upload('cifrado-tests', file) 
+        dir = client.service.directories.get 'cifrado-tests'
+        !(dir.files.get file[1..-1]).nil?
+      end
+      
+      test "custom object path" do
+        file = create_bin_payload 1
+        client.upload('cifrado-tests', file, :object_path => '/foobar')
+        dir = client.service.directories.get 'cifrado-tests'
+        !(dir.files.get 'foobar').nil?
+      end
+    end
+
+    tests "progress callback" do
+      chunks = []
+      cb = Proc.new do |tsize, bytes, nchunk|
+        chunks << bytes 
+      end
+      client.upload 'cifrado-tests', obj, :progress_callback => cb
+      test "chunks equal File.size" do
+        # FIXME
+        # File.size should be equal to the bytes read
+        # but StreamUploader is buggy
+        File.size(obj) <= chunks.inject(:+)
+      end
+    end
+  end
+
+  clean_test_payloads
+  dir = client.service.directories.get('cifrado-tests')
+  dir.files.each do |f|
+    f.destroy
+  end
+  dir.destroy
+
+  cleanup 
+
+end

data/tests/swift_client_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests('Cifrado | SwiftClient') do
+      
+  obj = create_bin_payload 1
+
+  tests('set_acl') do
+    dir = test_container
+    response = client.set_acl '.r:*,.rlistings', test_container.key
+    test 'success' do
+      [202,201].include? response.status
+    end
+    test 'ACL present' do
+      response = client.service.request :method => 'GET', 
+                                        :path => test_container.key
+      response.headers['X-Container-Read'] == '.r:*,.rlistings'
+    end
+    dir.destroy
+  end
+
+  tests('#encrypted_upload') do
+    test 'success' do
+      response = client.encrypted_upload('cifrado-tests', obj) 
+      cipher = CryptoEngineAES.new client.api_key
+      headers = client.head(test_container_name, clean_object_name(obj))
+      fname = headers['X-Object-Meta-Encrypted-Name']
+      ([202,201].include? response.status) and obj == cipher.decrypt(fname)
+    end
+  end
+
+end

data/tests/utils_tests.rb

@@ -0,0 +1,33 @@
+include Cifrado::Utils
+
+Shindo.tests('Cifrado | Utils') do
+
+  tests 'clean_object_name' do
+    test './foo/bar/stuff' do
+      clean_object_name('./foo/bar/stuff') == 'foo/bar/stuff'
+    end
+    test '//foo/bar/stuff' do
+      clean_object_name('//foo/bar/stuff') == 'foo/bar/stuff'
+    end
+    test '/foo/bar/stuff' do
+      clean_object_name('/foo/bar/stuff') == 'foo/bar/stuff'
+    end
+    test 'foo/bar/stuff' do
+      clean_object_name('foo/bar/stuff') == 'foo/bar/stuff'
+    end
+  end
+
+  test 'encrypt_filename' do
+    cs = CryptoEngineAES.new passphrase
+    filename = "/tmp/cifrado-payload-foobaro8u2ojf98"
+    n = cs.encrypt filename
+    cs.decrypt(n) == filename and n.lines.count == 1
+  end
+
+  test 'decrypt_filename' do
+    cs = CryptoEngineAES.new passphrase
+    fname = 'U2FsdGVkX19Wm6CdV6LF7j7wATQjH02-jeOJTy-Rt_Qs4WCDRblLWvHkvadbuZV9OKn0Rc5_X4BOwspPSV6ZBA=='
+    cs.decrypt(fname) == "/tmp/cifrado-payload-foobaro8u2ojf98"
+  end
+  
+end

data/vendor/fog/.document

@@ -0,0 +1,3 @@
+README.md
+lib/**/*.rb
+bin/*

data/vendor/fog/.gitignore

@@ -0,0 +1,23 @@
+*~
+*.gem
+*.rbc
+*.sw?
+.rvmrc
+.bundle
+.DS_Store
+.idea
+.yardoc
+/tests/.fog
+bin/*
+!bin/fog
+.fog
+coverage
+doc/*
+docs/_site/*
+docs/about/supported_services.markdown
+Gemfile.lock
+yardoc
+pkg
+spec/credentials.yml
+vendor/*
+tags

data/vendor/fog/.irbrc

@@ -0,0 +1,82 @@
+## This is primarily used for easier testing and development or
+#  usage of Fog.
+#
+#  How to use:
+#  1. Add this at the end of your `.irbrc` in your home directory.
+#
+#    @working_directory = Dir.pwd
+#    @local_irbrc = File.join(@working_directory, '.irbrc')
+#
+#    if @working_directory != ENV['HOME']
+#      load @local_irbrc if File.exists?(@local_irbrc)
+#    end
+#
+#    remove_instance_variable(:@working_directory)
+#    remove_instance_variable(:@local_irbrc)
+#
+#  2. Inside the Fog execute `bundle exec irb`
+#
+
+require 'fog'
+
+class ConnectionManager < Hash
+  def [](key)
+    $connection_manager_previous_key = key
+    super(key)
+  end
+
+  def []=(key, value)
+    $connection_manager_previous_key = key
+    super(key, value)
+  end
+end
+
+def connections
+  return @connections if @connections
+  @connections = ConnectionManager.new
+end
+
+def connection
+  connections[$connection_manager_previous_key]
+end
+
+def connect_openstack(username, password, tenant = nil, url = 'http://192.168.27.100:35357/')
+  parameters = {
+    :provider => 'openstack',
+    :openstack_api_key => password,
+    :openstack_username => username,
+    :openstack_auth_url => "#{url}v2.0/tokens"
+  }
+
+  parameters.merge!(:openstack_tenant => tenant) if tenant
+
+  key = username.to_sym
+  set_service(key, Fog::Identity, parameters)
+  set_service(key, Fog::Compute, parameters)
+  set_service(key, Fog::Volume, parameters)
+  set_service(key, Fog::Image, parameters)
+end
+
+def connect(parameters)
+  connections_count = connections.count
+  connections[connections_count] = Hash.new
+
+  set_service(connections_count, Fog::Identity, parameters)
+  set_service(connections_count, Fog::Compute , parameters)
+  set_service(connections_count, Fog::Storage , parameters)
+  set_service(connections_count, Fog::Volume  , parameters)
+  set_service(connections_count, Fog::Image   , parameters)
+  set_service(connections_count, Fog::DNS     , parameters)
+  set_service(connections_count, Fog::CDN     , parameters)
+  connection
+end
+
+def set_service(connections_count, type, parameters)
+  service_symbol = type.to_s.split('::').last.downcase.to_sym
+
+  connections[connections_count].merge!({
+    service_symbol => type.new(parameters)
+  })
+rescue
+  # Service not available
+end

data/vendor/fog/.travis.yml

@@ -0,0 +1,21 @@
+language: ruby
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+
+script: FOG_MOCK=true bundle exec shindont
+
+notifications:
+  email: false
+  irc: 
+    channels:
+      - "irc.freenode.org#ruby-fog"
+    template:
+      - "[#%{build_number}] %{message} %{build_url}"
+      - "[#%{build_number}] %{commit} on %{branch} by %{author}"
+      - "[#%{build_number}] %{compare_url}"
+    on_success: always
+    on_failure: always
+    use_notice: false

data/vendor/fog/README.cifrado

@@ -0,0 +1,3 @@
+Portions of Fog (http://fog.io) vendored
+
+All the changes required, if any are, submitted upstream.

data/vendor/fog/README.md

@@ -0,0 +1,156 @@
+![fog](http://geemus.s3.amazonaws.com/fog.png)
+
+fog is the Ruby cloud services library, top to bottom:
+
+* Collections provide a simplified interface, making clouds easier to work with and switch between.
+* Requests allow power users to get the most out of the features of each individual cloud.
+* Mocks make testing and integrating a breeze.
+
+[![Build Status](https://secure.travis-ci.org/fog/fog.png?branch=master)](http://travis-ci.org/fog/fog)
+[![Gem Version](https://fury-badge.herokuapp.com/rb/fog.png)](http://badge.fury.io/rb/fog)
+[![Dependency Status](https://gemnasium.com/fog/fog.png)](https://gemnasium.com/fog/fog)
+[![Code Climate](https://codeclimate.com/github/fog/fog.png)](https://codeclimate.com/github/fog/fog)
+
+## Getting Started
+
+    sudo gem install fog
+
+Now type `fog` to try stuff, confident that fog will let you know what to do. 
+Here is an example of wading through server creation for Amazon Elastic Compute Cloud:
+
+    >> server = Compute[:aws].servers.create
+    ArgumentError: image_id is required for this operation
+
+    >> server = Compute[:aws].servers.create(:image_id => 'ami-5ee70037')
+    <Fog::AWS::EC2::Server [...]>
+
+    >> server.destroy # cleanup after yourself or regret it, trust me
+    true
+
+## Collections
+
+A high level interface to each cloud is provided through collections, such as `images` and `servers`.
+You can see a list of available collections by calling `collections` on the connection object. 
+You can try it out using the `fog` command:
+
+    >> Compute[:aws].collections
+    [:addresses, :directories, ..., :volumes, :zones]
+
+Some collections are available across multiple providers:
+
+* compute providers have `flavors`, `images` and `servers`
+* dns providers have `zones` and `records`
+* storage providers have `directories` and `files`
+
+Collections share basic CRUD type operations, such as:
+
+* `all` - fetch every object of that type from the provider.
+* `create` - initialize a new record locally and a remote resource with the provider.
+* `get` - fetch a single object by it's identity from the provider.
+* `new` - initialize a new record locally, but do not create a remote resource with the provider.
+
+As an example, we'll try initializing and persisting a Rackspace Cloud server:
+
+    require 'fog'
+
+    compute = Fog::Compute.new(
+      :provider           => 'Rackspace',
+      :rackspace_api_key  => key,
+      :rackspace_username => username
+    )
+
+    # boot a gentoo server (flavor 1 = 256, image 3 = gentoo 2008.0)
+    server = compute.servers.create(:flavor_id => 1, :image_id => 3, :name => 'my_server')
+    server.wait_for { ready? } # give server time to boot
+
+    # DO STUFF
+
+    server.destroy # cleanup after yourself or regret it, trust me
+
+## Models
+
+Many of the collection methods return individual objects, which also provide common methods:
+
+* `destroy` - will destroy the persisted object from the provider
+* `save` - persist the object to the provider
+* `wait_for` - takes a block and waits for either the block to return true for the object or for a timeout (defaults to 10 minutes)
+
+## Mocks
+
+As you might imagine, testing code using Fog can be slow and expensive, constantly turning on and and shutting down instances.
+Mocking allows skipping this overhead by providing an in memory representation resources as you make requests.
+Enabling mocking easy to use, before you run other commands, simply run:
+
+    Fog.mock!
+
+Then proceed as usual, if you run into unimplemented mocks, fog will raise an error and as always contributions are welcome!
+
+## Requests
+
+Requests allow you to dive deeper when the models just can't cut it.
+You can see a list of available requests by calling `#requests` on the connection object.
+
+For instance, ec2 provides methods related to reserved instances that don't have any models (yet). Here is how you can lookup your reserved instances:
+
+    $ fog
+    >> Compute[:aws].describe_reserved_instances
+    #<Excon::Response [...]>
+
+It will return an [excon](http://github.com/geemus/excon) response, which has `body`, `headers` and `status`. Both return nice hashes.
+
+## Go forth and conquer
+
+Play around and use the console to explore or check out [fog.io](http://fog.io) for more details and examples. 
+Once you are ready to start scripting fog, here is a quick hint on how to make connections without the command line thing to help you.
+
+    # create a compute connection
+    compute = Fog::Compute.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
+    # compute operations go here
+
+    # create a storage connection
+    storage = Fog::Storage.new(:provider => 'AWS', :aws_access_key_id => ACCESS_KEY_ID, :aws_secret_access_key => SECRET_ACCESS_KEY)
+    # storage operations go here
+
+geemus says: "That should give you everything you need to get started, but let me know if there is anything I can do to help!"
+
+## Contributing
+
+* Find something you would like to work on.
+  * Look for anything you can help with in the [issue tracker](https://github.com/fog/fog/issues).
+  * Look at the [code quality metrics](https://codeclimate.com/github/fog/fog) for anything you can help clean up.
+  * Or anything else!
+* Fork the project and do your work in a topic branch.
+  * Make sure your changes will work on both Ruby 1.8.7 and Ruby 1.9
+* Add a config at `tests/.fog` for the component you want to test.
+* Add shindo tests to prove your code works and run all the tests using `bundle exec rake`.
+* Rebase your branch against `fog/fog` to make sure everything is up to date.
+* Commit your changes and send a pull request.
+
+## Additional Resources
+
+[fog.io](http://fog.io)
+
+## Copyright
+
+(The MIT License)
+
+Copyright (c) 2013 [geemus (Wesley Beary)](http://github.com/geemus)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.