uricp 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+results.html
+pkg
+html
+Gemfile.lock
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in uricp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,16 @@
+Name: uricp
+Copyright (c) 2014
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+

data/README.md

@@ -0,0 +1,31 @@
+# Uricp
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'uricp'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install uricp
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/uricp/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/README.rdoc

@@ -0,0 +1,23 @@
+= uricp - DESCRIBE YOUR GEM
+
+Author::  YOUR NAME (YOUR EMAIL)
+Copyright:: Copyright (c) 2014 YOUR NAME
+
+
+License:: gplv3, see LICENSE.txt
+
+
+
+DESCRIBE YOUR GEM HERE
+
+== Links
+
+* {Source on Github}[LINK TO GITHUB]
+* RDoc[LINK TO RDOC.INFO]
+
+== Install
+
+== Examples
+
+== Contributing
+

data/Rakefile

@@ -0,0 +1,66 @@
+def dump_load_path
+  puts $LOAD_PATH.join("\n")
+  found = nil
+  $LOAD_PATH.each do |path|
+    if File.exists?(File.join(path,"rspec"))
+      puts "Found rspec in #{path}"
+      if File.exists?(File.join(path,"rspec","core"))
+        puts "Found core"
+        if File.exists?(File.join(path,"rspec","core","rake_task"))
+          puts "Found rake_task"
+          found = path
+        else
+          puts "!! no rake_task"
+        end
+      else
+        puts "!!! no core"
+      end
+    end
+  end
+  if found.nil?
+    puts "Didn't find rspec/core/rake_task anywhere"
+  else
+    puts "Found in #{path}"
+  end
+end
+require 'bundler'
+require 'rake/clean'
+
+begin
+require 'rspec/core/rake_task'
+rescue LoadError
+dump_load_path
+raise
+end
+
+require 'cucumber'
+require 'cucumber/rake/task'
+gem 'rdoc' # we need the installed RDoc gem, not the system one
+require 'rdoc/task'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+
+RSpec::Core::RakeTask.new do |t|
+  # Put spec opts in a file named .rspec in root
+end
+
+
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty --no-source -x"
+  t.fork = false
+end
+
+Rake::RDocTask.new do |rd|
+  
+  rd.main = "README.rdoc"
+  
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+end
+
+task :default => [:spec,:features]
+

data/bin/segment_upload

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'uri'
+require 'methadone'
+require 'filesize'
+require 'segment_upload.rb'
+
+class App
+  include Methadone::Main
+  include Methadone::SH
+  include Methadone::CLILogging
+
+  main do |to_uri|
+    options['auth_uri'] = options['to_uri'] = URI(to_uri)
+    options['segment-size'] = Filesize.from(options['segment-size'])
+    Uricp::OrbitAuth.validate_options(options)
+    Uricp::OrbitAuth.add_auth_token(options)
+    validate_options
+    run_command
+  end
+
+  def self.run_command
+    Uricp::Segmenter.new(options).upload
+  end
+
+  def self.validate_options
+    unless %w{http https}.include? options['to_uri'].scheme
+      raise Uricp::UnsupportedURLtype,
+        "unsupported url: Can only perform a segmented upload to an HTTP(S) URL"
+    end
+    unless options['auth-token']
+      raise OptionParser::MissingArgument,
+        "Need authentication to proceed - supply 'auth-user' or 'auth-token'"
+    end
+    if options['from'].to_s =~ /^\s*\|/
+      raise OptionParser::InvalidArgument,
+        "Source filenames starting with '|' not supported"
+    end
+  end
+
+  # Declare command-line interface here
+
+  description "Split input into chunks and upload as Dynamic Large Object"
+  
+  options['segment-size'] = Uricp::DEFAULT_SEGMENT_SIZE
+  Uricp::OrbitAuth.add_auth_to_optionparser(self)
+  on("--from FILE",
+    "Upload from FILE rather than stdin")
+  on("--segment-size SEGMENT_SIZE",
+    "Size of required segment in [GMk][i]B.")
+  on("--[no-]dry-run",
+    "Show what would be run,","but don't run the command")
+
+
+  #Arguments
+  arg :to_uri, "URI to upload to"
+
+  defaults_from_env_var 'URICP'
+
+  version Uricp::VERSION
+
+  use_log_level_option :toggle_debug_on_signal => 'USR1'
+
+  go!
+end

data/bin/uricp

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'uri'
+require 'methadone'
+require 'filesize'
+require 'uricp.rb'
+
+class App
+  include Methadone::Main
+  include Methadone::SH
+  include Methadone::CLILogging
+
+  main do |from_uri, to_uri|
+    options['from_uri'] = URI(from_uri)
+    options['to_uri'] = URI(to_uri)
+    options['auth_uri'] = select_auth_url
+    if options['segment-size']
+      options['segment-size'] = Filesize.from(options['segment-size'])
+    end
+    validate_options
+    Uricp::OrbitAuth.validate_options(options)
+    Uricp::OrbitAuth.add_auth_token(options)
+    ENV['URICP'] = "--auth-token='#{options['auth-token']}'"
+    add_cache_name
+    add_temp_area
+    run_command
+  end
+
+  def self.run_command
+    command_list = build_command
+    if options['dry-run']
+      info "Would execute:\n###\n#{command_list}\n###"
+    else
+      sh! pipefail_wrapper(command_list),
+	:on_fail => "Copy from #{options['from_uri']} to #{options['to_uri']} failed"
+    end
+  end
+
+  def self.build_command
+    command_sequence = Uricp::UriStrategy.choose_strategy(options)
+    debug "#{self.name} Command sequence is #{command_sequence.inspect}"
+    command_sequence.map{|c| c.command}.join('')
+  end
+
+  def self.validate_options
+    if options['target-format'] && !options['cache']
+      raise ::OptionParser::MissingArgument,
+        "'target-format' requires 'cache' option"
+    end
+  end
+
+  def self.add_cache_name
+    if options['cache']
+      options['cache_name'] = File.basename(options['from_uri'].path)
+    end
+  end
+
+  def self.add_temp_area
+    if options['cache']
+      options['temp'] = File.join(options['cache'], 'temp/')
+    else
+      options['temp'] = '/tmp'
+    end
+  end
+
+  def self.select_auth_url
+    [options['from_uri'], options['to_uri']].detect do |x|
+      x && x.scheme =~ /https?/
+    end
+  end
+
+  def self.pipefail_wrapper(command)
+    ['bash', '-c', 'set -e -o pipefail;'+command]
+  end
+
+  # Declare command-line interface here
+
+  description "Copy one URI to another"
+  
+  Uricp::OrbitAuth.add_auth_to_optionparser(self)
+  on("--cache CACHE_ROOT",
+    "Root directory of cache area")
+  on("--target-format FORMAT", [:qcow2, :raw, :qcow3, :qcow2v3],
+    "Image format of target", "[qcow2, raw, qcow3, qcow2v3]")
+  on("--segment-size SEGMENT_SIZE",
+    "Size of required segment in [GMk][i]B.")
+  on("--[no-]compress",
+    "Compress output")
+  on("--[no-]dry-run",
+    "Show what would be run,", "but don't run the command")
+  #Arguments
+  arg :from_uri, "URI to copy from"
+  arg :to_uri, "URI to copy to"
+
+  defaults_from_env_var 'URICP'
+
+  version Uricp::VERSION
+
+  use_log_level_option :toggle_debug_on_signal => 'USR1'
+
+  go!
+end

data/features/auth_download.feature

@@ -0,0 +1,106 @@
+@orbit
+@orbitdownloads
+Feature: Authenticated download of images from orbit
+  In order to download images from orbit
+  As a command line user
+  I want to retrieve the URI via an optional cache and copy correctly to target in the right format
+
+  Background: 
+    Given an empty directory named "/tmp/uricp"
+    And the default aruba timeout is 15 seconds
+    And a container called "test"
+
+  Scenario: qcow download no conversion, no cache
+    When I retrieve "img-qcow2" from container "test" into "file:///tmp/uricp/srv-test1"
+    Then a file named "/tmp/uricp/srv-test1" should exist
+    And the file named "/tmp/uricp/srv-test1" should have a file format of "qcow2v3"
+
+  Scenario: lz4 download no conversion, no cache
+    When I retrieve "img-lz4cy" from container "test" into "file:///tmp/uricp/srv-test2"
+    Then a file named "/tmp/uricp/srv-test2" should exist
+    And the file named "/tmp/uricp/srv-test2" should have a file format of "lz4"
+
+  Scenario: qcow download no conversion, cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I retrieve "img-qcow2" with options "--cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test3"
+    Then a file named "/tmp/uricp/srv-test3" should exist
+    And the file named "/tmp/uricp/srv-test3" should have a file format of "qcow2v3"
+    And a file named "/tmp/uricp/cache/img-qcow2" should exist
+    And the file named "/tmp/uricp/cache/img-qcow2" should have a file format of "qcow2v3"
+
+  Scenario: qcow download convert to raw, cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I retrieve "img-qcow2" with options "--target-format=raw --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test4"
+    Then a file named "/tmp/uricp/srv-test4" should exist
+    And the file named "/tmp/uricp/srv-test4" should have a file format of "raw"
+    And a file named "/tmp/uricp/cache/img-qcow2" should exist
+    And the file named "/tmp/uricp/cache/img-qcow2" should have a file format of "qcow2v3"
+
+  Scenario: qcow download convert to qcow2, cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I retrieve "img-qcow2" with options "--target-format=qcow2 --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test5"
+    Then a file named "/tmp/uricp/srv-test5" should exist
+    And the file named "/tmp/uricp/srv-test5" should have a file format of "qcow2"
+    And a file named "/tmp/uricp/cache/img-qcow2" should exist
+    And the file named "/tmp/uricp/cache/img-qcow2" should have a file format of "qcow2v3"
+
+  Scenario: qcow download no conversion, from cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    And a cache of "img-qcow2" from container "test" at "/tmp/uricp"
+    When I retrieve "img-qcow2" with options "--cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test6"
+    Then a file named "/tmp/uricp/srv-test6" should exist
+    And the file named "/tmp/uricp/srv-test6" should have a file format of "qcow2v3"
+    And a file named "/tmp/uricp/cache/img-qcow2" should exist
+    And the file named "/tmp/uricp/cache/img-qcow2" should have a file format of "qcow2v3"
+
+  Scenario: qcow download convert to raw from cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    And a cache of "img-qcow2" from container "test" at "/tmp/uricp"
+    When I retrieve "img-qcow2" with options "--target-format=raw --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test7"
+    Then a file named "/tmp/uricp/srv-test7" should exist
+    And the file named "/tmp/uricp/srv-test7" should have a file format of "raw"
+    And a file named "/tmp/uricp/cache/img-qcow2" should exist
+    And the file named "/tmp/uricp/cache/img-qcow2" should have a file format of "qcow2v3"
+
+  Scenario: qcow download convert to qcow2 from cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    And a cache of "img-qcow2" from container "test" at "/tmp/uricp"
+    When I retrieve "img-qcow2" with options "--target-format=qcow2 --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test8"
+    Then a file named "/tmp/uricp/srv-test8" should exist
+    And the file named "/tmp/uricp/srv-test8" should have a file format of "qcow2"
+    And a file named "/tmp/uricp/cache/img-qcow2" should exist
+    And the file named "/tmp/uricp/cache/img-qcow2" should have a file format of "qcow2v3"
+
+  Scenario: lz4 download convert to raw, cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I retrieve "img-lz4cy" with options "--target-format=raw --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-test9"
+    Then a file named "/tmp/uricp/srv-test9" should exist
+    And the file named "/tmp/uricp/srv-test9" should have a file format of "raw"
+    And a file named "/tmp/uricp/cache/img-lz4cy" should exist
+    And the file named "/tmp/uricp/cache/img-lz4cy" should have a file format of "lz4"
+
+  Scenario: lz4 download convert to raw, from cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    And a cache of "img-lz4cy" from container "test" at "/tmp/uricp"
+    When I retrieve "img-lz4cy" with options "--target-format=raw --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-testa"
+    Then a file named "/tmp/uricp/srv-testa" should exist
+    And the file named "/tmp/uricp/srv-testa" should have a file format of "raw"
+    And a file named "/tmp/uricp/cache/img-lz4cy" should exist
+    And the file named "/tmp/uricp/cache/img-lz4cy" should have a file format of "lz4"
+
+  Scenario: lz4 download convert to qcow2, cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I retrieve "img-lz4cy" with options "--target-format=qcow2 --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-testb"
+    Then a file named "/tmp/uricp/srv-testb" should exist
+    And the file named "/tmp/uricp/srv-testb" should have a file format of "qcow2"
+    And a file named "/tmp/uricp/cache/img-lz4cy" should exist
+    And the file named "/tmp/uricp/cache/img-lz4cy" should have a file format of "lz4"
+
+  Scenario: lz4 download convert to qcow2, from cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    And a cache of "img-lz4cy" from container "test" at "/tmp/uricp"
+    When I retrieve "img-lz4cy" with options "--target-format=qcow2 --cache=/tmp/uricp" from container "test" into "file:///tmp/uricp/srv-testa"
+    Then a file named "/tmp/uricp/srv-testa" should exist
+    And the file named "/tmp/uricp/srv-testa" should have a file format of "qcow2"
+    And a file named "/tmp/uricp/cache/img-lz4cy" should exist
+    And the file named "/tmp/uricp/cache/img-lz4cy" should have a file format of "lz4"

data/features/cacheable_from_uri.feature

@@ -0,0 +1,71 @@
+Feature: Download Public VM images
+  In order to download public VM images to the target
+  As a command line user
+  I want to retrieve the URI via an optional cache and copy correctly to target in the right format
+
+  Background: 
+    Given an empty directory named "/tmp/uricp"
+    And the default aruba timeout is 15 seconds
+
+  Scenario: HTTP URI qcow2 to qcow2
+    When I successfully run `uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 file:///tmp/uricp/srv-testy`
+    Then a file named "/tmp/uricp/srv-testy" should exist
+      And the file named "/tmp/uricp/srv-testy" should have a file format of "qcow2"
+
+  Scenario: HTTP URI qcow2 via cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I successfully run `uricp --cache=/tmp/uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 file:///tmp/uricp/srv-testy`
+    Then a file named "/tmp/uricp/srv-testy" should exist
+      And the file named "/tmp/uricp/srv-testy" should have a file format of "qcow2"
+      And a file named "/tmp/uricp/cache/freedos.qcow2" should exist
+      And the file named "/tmp/uricp/cache/freedos.qcow2" should have a file format of "qcow2"
+
+  Scenario: HTTP URI qcow2 to qcow2 via cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I successfully run `uricp --target-format=qcow2 --cache=/tmp/uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 file:///tmp/uricp/srv-testy`
+    Then a file named "/tmp/uricp/srv-testy" should exist
+      And the file named "/tmp/uricp/srv-testy" should have a file format of "qcow2"
+      And a file named "/tmp/uricp/cache/freedos.qcow2" should exist
+      And the file named "/tmp/uricp/cache/freedos.qcow2" should have a file format of "qcow2"
+
+  Scenario: HTTP URI qcow2 to qcow2v3 via cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I successfully run `uricp --target-format=qcow2v3 --cache=/tmp/uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 file:///tmp/uricp/srv-testy`
+    Then a file named "/tmp/uricp/srv-testy" should exist
+      And the file named "/tmp/uricp/srv-testy" should have a file format of "qcow2v3"
+      And a file named "/tmp/uricp/cache/freedos.qcow2" should exist
+      And the file named "/tmp/uricp/cache/freedos.qcow2" should have a file format of "qcow2"
+
+  Scenario: HTTP URI qcow2 to raw via cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I successfully run `uricp --target-format=raw --cache=/tmp/uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 file:///tmp/uricp/srv-testy`
+    Then a file named "/tmp/uricp/srv-testy" should exist
+      And the file named "/tmp/uricp/srv-testy" should have a file format of "raw"
+      And a file named "/tmp/uricp/cache/freedos.qcow2" should exist
+      And the file named "/tmp/uricp/cache/freedos.qcow2" should have a file format of "qcow2"
+
+
+  Scenario: HTTP URI from cache
+    Given a correctly initialised cache at "/tmp/uricp"
+    And a 102400 byte file named "/tmp/uricp/cache/freedos.qcow2"
+    When I successfully run `uricp --cache=/tmp/uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 file:///tmp/uricp/srv-testy`
+    Then a 102400 byte file named "/tmp/uricp/srv-testy" should exist
+    And a 102400 byte file named "/tmp/uricp/cache/freedos.qcow2" should exist
+
+  Scenario: Unsupported source URI should error
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I run `uricp --target-format=raw --cache=/tmp/uricp wibble://some/url file:///tmp/uricp/srv-testy`
+    Then the exit status should not be 0
+      And the stderr should contain "Unsupported transfer"
+  
+  Scenario: Unsupported target URI should error
+    Given a correctly initialised cache at "/tmp/uricp"
+    When I run `uricp --target-format=raw --cache=/tmp/uricp https://foss-lab-manual.googlecode.com/files/freedos.qcow2 http://foss-lab-manual.googlecode.com/files/freedos.qcow2`
+    Then the exit status should not be 0
+      And the stderr should contain "Unsupported transfer"
+
+  Scenario: Download from authorised http without authorisation
+    When I run `uricp https://orbit.brightbox.com/v1/acc-tqs4c/images/img-c5q5i file:///tmp/uricp/srv-testy`
+    Then the exit status should not be 0
+      And the stderr should contain "failed"
+

data/features/documented_options.feature

@@ -0,0 +1,73 @@
+Feature: Documented Help
+  In order to work out what uricp does
+  As a command line user
+  I want to get detailed usage information
+
+  Scenario: Basic UI
+    When I get help for "uricp"
+    Then the exit status should be 0
+    And the banner should include the version
+    And the banner should document that this app takes options
+    And the following options should be documented:
+      |--version|
+      |--target-format|
+      |--cache|
+      |--auth-token|
+      |--auth-user|
+      |--auth-key|
+      |--segment|
+    And the option "compress" should be documented which is negatable
+    And the option "dry-run" should be documented which is negatable
+    And the banner should document that this app's arguments are:
+      |from_uri|which is required|
+      |to_uri|which is required|
+
+  Scenario: target format requires cache
+    When I run `uricp --target-format=qcow2 source target`
+    Then the exit status should not be 0
+    And the stderr should contain "missing argument"
+
+  Scenario: target format should be appropriate
+    When I run `uricp --target-format=fred --cache=/tmp source target`
+    Then the exit status should not be 0
+    And the stderr should contain "invalid argument"
+
+  Scenario: target format should support qcow3
+    When I run `uricp --target-format=qcow3 --cache=/tmp source target`
+    Then the exit status should not be 0
+    And the stderr should not contain "invalid argument"
+
+  Scenario: auth token and auth-user are mutually exclusive
+    When I run `uricp --auth-token abcdef --auth-user xyz --auth-key abc http://source file:///target`
+    Then the exit status should not be 0
+    And the stderr should contain "needless argument"
+
+  Scenario: auth user needs auth key
+    When I run `uricp --auth-user xyz http://source file:///target`
+    Then the exit status should not be 0
+    And the stderr should contain "missing argument"
+
+  Scenario: auth key needs auth user
+    When I run `uricp --auth-user xyz http://source file:///target`
+    Then the exit status should not be 0
+    And the stderr should contain "missing argument"
+
+  Scenario: authorisation with no http should fail
+    When I run `uricp --auth-token abcdef ftp://source file:///target`
+    Then the exit status should not be 0
+    And the stderr should contain "needless argument"
+
+  Scenario: authentication with normal http should fail
+    When I run `uricp --auth-user cli-xxxxx --auth-key fred https://foss-lab-manual.googlecode.com/files file://tmp/temp`
+    Then the exit status should not be 0
+    And the stderr should contain "Cannot authenticate"
+
+  Scenario: bad authentication should fail against orbit
+    When I run `uricp --auth-user cli-xxxxx --auth-key fred https://orbit.brightbox.com/v1/acc-xxxxx/test/test.img file://tmp/temp`
+    Then the exit status should not be 0
+    And the stderr should contain "Cannot authenticate"
+
+  Scenario: should not accept plain number for segment size
+  When I run `uricp --segment-size 100 --auth-token abcdef file:///tmp/temp https:///orbit.brightbox.com/v1/acc-xxxxx/test/test.img`
+    Then the exit status should not be 0
+    And the stderr should contain "Unparseable filesize"

data/features/remote_upload.feature

@@ -0,0 +1,49 @@
+@orbit
+Feature: Upload VM images with authentication
+  In order to upload VM images to storage
+  As a command line user
+  I want to automatically convert and compress uploads to authenticated storage
+
+  Background:
+    Given a directory named "/tmp/uricp"
+    And the default aruba timeout is 15 seconds
+    And a container called "test_upload"
+
+  Scenario: Direct Upload
+    Given a 102400 byte file named "/tmp/uricp/srv-testy"
+    When I store "img-testy" into container "test_upload" from "file:///tmp/uricp/srv-testy"
+    Then a 102400 byte entry should exist in container "test_upload" called "img-testy"
+
+  Scenario: Compressed Upload
+    Given a 102400 byte file named "/tmp/uricp/srv-testy"
+    When I store "img-testy" with options "--compress" into container "test_upload" from "file:///tmp/uricp/srv-testy" 
+    Then an lz4 compressed entry should exist in container "test_upload" called "img-testy" 
+
+  Scenario: Direct Upload with userid
+    Given a 102400 byte file named "/tmp/uricp/srv-testa"
+    When I store "img-testa" into container "test_upload" from "file:///tmp/uricp/srv-testa" with a userid
+    Then a 102400 byte entry should exist in container "test_upload" called "img-testa"
+
+  Scenario: Direct segmented Upload with userid
+    Given a 102400 byte file named "/tmp/uricp/srv-testb"
+    When I store "img-testb" with segment size "10kiB" into container "test_upload" from "file:///tmp/uricp/srv-testb" with a userid
+    Then a 102400 byte entry should exist in container "test_upload" called "img-testb"
+    And the container "test_upload" should contain 11 entries
+
+  Scenario: Direct compressed segmented Upload with userid
+    Given a 102400 byte file named "/tmp/uricp/srv-testc"
+    When I store "img-testc" with segment size "10kiB" and options "--compress" into container "test_upload" from "file:///tmp/uricp/srv-testc" with a userid
+    Then an lz4 compressed entry should exist in container "test_upload" called "img-testc" 
+
+  Scenario: Direct segmented Upload with userid in qcow2 format
+    Given a 102400 byte file named "/tmp/uricp/srv-testd"
+    And a correctly initialised cache at "/tmp/uricp"
+    When I store "img-testd" with segment size "10kiB" and options "--target-format 'qcow2' --cache /tmp/uricp" into container "test_upload" from "file:///tmp/uricp/srv-testd" with a userid
+    Then a qcow2 entry should exist in container "test_upload" called "img-testd"
+
+  Scenario: Direct segmented upload of lz4 file with userid in qcow2 format
+    Given a 102400 byte lz4 file named "/tmp/uricp/srv-teste"
+    And the default aruba timeout is 60 seconds
+    And a correctly initialised cache at "/tmp/uricp"
+    When I store "img-teste" with segment size "10kiB" and options "--target-format 'qcow2' --cache /tmp/uricp" into container "test_upload" from "file:///tmp/uricp/srv-teste" with a userid
+    Then a qcow2 entry should exist in container "test_upload" called "img-teste"

data/features/segmented_upload.feature

@@ -0,0 +1,27 @@
+@orbit
+Feature: Segmented Upload Command
+  In order to upload streams in chunks
+  As a command line user
+  I want a tool that can do segmented uploads
+
+  Background:
+    Given a directory named "/tmp/uricp"
+    And the default aruba timeout is 15 seconds
+    And a container called "temp_dlo"
+
+  Scenario: Direct curl for smaller file
+    Given a 102400 byte file named "/tmp/uricp/srv-testy"
+    When I upload "img-testy" with segment size "100kib" into container "temp_dlo" from "/tmp/uricp/srv-testy"
+    Then a 102400 byte entry should exist in container "temp_dlo" called "img-testy"
+
+  Scenario: Create DLO with segmented file
+    Given a 102400 byte file named "/tmp/uricp/srv-testy"
+    When I upload "img-check" with segment size "10kib" into container "temp_dlo" from "/tmp/uricp/srv-testy"
+    Then a 102400 byte entry should exist in container "temp_dlo" called "img-check"
+    And the container "temp_dlo" should contain 11 entries
+
+  Scenario: Create DLO from stream
+    Given a 102400 byte file named "/tmp/uricp/srv-testb"
+    When I upload "img-testb" with segment size "10kib" into container "temp_dlo" from "/tmp/uricp/srv-testb" as a stream
+    Then a 102400 byte entry should exist in container "temp_dlo" called "img-testb"
+    And the container "temp_dlo" should contain 11 entries