ruby-cute 0.0.1 → 0.0.2

data/lib/cute/version.rb

@@ -0,0 +1,3 @@
+module Cute
+  VERSION = "0.0.2"
+end

data/ruby-cute.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cute/version'
+
+Gem::Specification.new do |s|
+  s.name        = "ruby-cute"
+  s.version     = Cute::VERSION
+  s.authors     = ["Algorille team"]
+  s.email       = "ruby-cute-staff@lists.gforge.inria.fr"
+  s.homepage    = "http://ruby-cute.gforge.inria.fr/"
+  s.summary     = "Critically Useful Tools for Experiments"
+  s.description = "Ruby library for controlling experiments"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.add_development_dependency "bundler", "~> 1.7"
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "rspec", "~> 3.1"
+  s.add_development_dependency "pry", "~> 0.10"
+  s.add_development_dependency "webmock", "~> 1.20"
+  s.add_development_dependency "yard", "~> 0.8"
+
+  s.add_dependency 'rest-client', '1.6.7'
+  s.add_dependency 'json', '~> 1.8'
+  s.add_dependency 'ipaddress', '~>0.8'
+  s.add_dependency 'net-ssh-multi', '~>1.2'
+
+  s.extra_rdoc_files = ['README.md', 'LICENSE']
+  s.license = 'CeCILL-B'
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+
+describe "Monkey patch to class String" do
+
+  it "converts walltime format into seconds" do
+    digits = []
+
+    (0..9).each{ |x| digits.push(x.to_s)}
+    time = digits.combination(2).to_a.map{ |x| x.join("")}.select{ |h| h.to_i < 60 }
+    walltime = time.combination(3).to_a.map{ |x| x.join(":")}
+
+    expect {walltime.each{ |t| t.to_secs}}.not_to raise_error
+  end
+
+
+end

data/spec/g5k_api_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+# These tests can be executed either real or using mocking through WebMock
+# Real tests can be activated by setting the shell variable TEST_REAL
+describe Cute::G5K::API do
+
+  subject { g5k = ENV['TEST_REAL'].nil?? Cute::G5K::API.new(:user => "test") : Cute::G5K::API.new() }
+
+  let(:sites) { subject.site_uids}
+
+  before :each do
+    # Choosing a random site based on the date
+    day = Time.now.day
+    index = ((day/31.to_f)*sites.length).to_i
+    index = 1 if index == 0
+    @rand_site = sites[index]
+    @env = subject.environment_uids(@rand_site).first
+    if ENV['TEST_REAL']
+      WebMock.disable!
+      puts "Testing in real Grid'5000 using site: #{@rand_site}"
+      puts "Warning G5K_USER environment variable has to be defined for some tests" if ENV['G5K_USER'].nil?
+    end
+  end
+
+  it "checks initialization of G5K::API" do
+    expect(subject.rest).to be_an_instance_of(Cute::G5K::G5KRest)
+  end
+
+
+  it "returns an array with the site ids" do
+    expect(sites.length).to be > 0
+  end
+
+  it "returns an array with the clusters ids" do
+    clusters = subject.cluster_uids(@rand_site)
+    expect(clusters.length).to be > 0
+  end
+
+  it "returns a JSON Hash with the status of a site" do
+    expect(subject.site_status(@rand_site)).to be_an_instance_of(Cute::G5K::G5KJSON)
+  end
+
+  it "returns a Hash with nodes status" do
+    expect(subject.nodes_status(@rand_site)).to be_an_instance_of(Hash)
+    expect(subject.nodes_status(@rand_site).length).to be > 0
+  end
+
+  it "returns an array with site status" do
+    expect(subject.sites).to be_an_instance_of(Cute::G5K::G5KArray)
+  end
+
+  it "returns jobs in the site" do
+    expect(subject.get_jobs(@rand_site)).to be_an_instance_of(Array)
+  end
+
+  it "return my_jobs in the site" do
+    expect(subject.get_my_jobs(@rand_site)).to be_an_instance_of(Array)
+  end
+
+  it "returns all deployments" do
+    expect(subject.get_deployments(@rand_site)).to be_an_instance_of(Cute::G5K::G5KArray)
+  end
+
+  it "raises an authentication error" do
+    expect{Cute::G5K::API.new(:user => "fake", :pass => "fake") }.to raise_error
+  end
+
+  it "raises a non found error" do
+    expect{subject.get_jobs("non-found")}.to raise_error(Cute::G5K::NotFound)
+  end
+
+  it "raises a bad request error" do
+    expect{ subject.reserve(:site => @rand_site, :resources =>"/slash_22=1+{nonsense}")}.to raise_error(Cute::G5K::BadRequest)
+#    expect{ subject.reserve(:site => @rand_site, :resources =>"{ib30g='YES'}/nodes=2")}.to raise_error(Cute::G5K::BadRequest)
+  end
+
+  it "raises an exception at deploying" do
+    expect{ subject.reserve(:site => @rand_site, :nodes => 1, :env => "nonsense")}.to raise_error(Cute::G5K::RequestFailed)
+  end
+
+  it "raises argument errors" do
+    job = Cute::G5K::G5KJSON.new
+    expect {subject.deploy(:env => "env")}.to raise_error(ArgumentError)
+    expect {subject.deploy(job)}.to raise_error(ArgumentError)
+    expect {subject.reserve(:non_existing => "site")}.to raise_error(ArgumentError)
+  end
+
+  it "raises invalid nodes format" do
+    job = Cute::G5K::G5KJSON.new
+    expect{subject.deploy(job,:env => "env")}.to raise_error(RuntimeError,"Unrecognized nodes format, use an Array")
+  end
+
+  it "raises error vlan" do
+    expect {subject.reserve(:site => @rand_site, :vlan => :nonsense)}.to raise_error(ArgumentError,'Option for vlan not recognized')
+  end
+
+
+  it "reserves and returns a valid job" do
+    job = subject.reserve(:site => @rand_site)
+    expect(job).to be_an_instance_of(Cute::G5K::G5KJSON)
+    subject.release(job)
+  end
+
+
+  it "reserves with vlan and get vlan hostnames" do
+    job = subject.reserve(:site => @rand_site, :nodes => 1, :type => :deploy, :vlan => :routed)
+    expect(subject.get_vlan_nodes(job)).to be_an_instance_of(Array)
+    subject.release(job)
+  end
+
+  it "vlan returns nil" do
+    job = Cute::G5K::G5KJSON.new
+    expect(subject.get_vlan_nodes(job)).to be_nil
+  end
+
+  it "performs an advanced reservation" do
+    time_schedule = Time.now + 60*30
+    job =subject.reserve(:site => @rand_site, :nodes => 1, :reservation => time_schedule.strftime("%Y-%m-%d %H:%M:%S"))
+    subject.release(job)
+  end
+
+  it "gets subnets from job" do
+    job = subject.reserve(:site => @rand_site, :nodes => 1, :subnets => [22,2])
+    expect(subject.get_subnets(job).first).to be_an_instance_of(IPAddress::IPv4)
+    subject.release(job)
+  end
+
+
+  it "does not deploy immediately" do
+    job = subject.reserve(:site => @rand_site, :type => :deploy )
+    expect(job).to include("types" => ["deploy"])
+    expect(job).to_not have_key("deploy")
+  end
+
+  it "tests deploy with keys option" do
+    # Getting a deploy job
+    job = subject.get_my_jobs(@rand_site).select{ |j| j.has_value?(["deploy"])}.first
+    fake_key = Tempfile.new(["keys",".pub"])
+    fake_key_path = fake_key.path.split(".pub").first
+    expect(subject.deploy(job,:env => @env,:wait => true, :keys => fake_key_path)).to be_an_instance_of(Cute::G5K::G5KJSON)
+    fake_key.delete
+  end
+
+  it "waits for a deploy" do
+    job = subject.get_my_jobs(@rand_site).select{ |j| j.has_value?(["deploy"])}.first
+    # It verifies that the job has been submitted with deploy
+    expect(subject.deploy_status(job)).to be_an_instance_of(Array)
+    subject.wait_for_deploy(job)
+    expect(subject.deploy_status(job)).to be_an_instance_of(Array)
+
+    #deploying again
+    # subject.deploy(job, :env => @env)
+    # subject.wait_for_deploy(job)
+    # expect(subject.deploy_status(job).uniq).to eq(["terminated"])
+  end
+
+
+  it "submits a job and then deploy" do
+    expect(subject.reserve(:site => @rand_site, :env => @env)).to have_key("deploy")
+  end
+
+
+  it "returns the same information" do
+    #low level REST access
+    jobs_running = subject.rest.get_json("sid/sites/#{@rand_site}/jobs/?state=running").items.length
+    expect(subject.get_jobs(@rand_site,nil,"running").length).to eq(jobs_running)
+  end
+
+  it "submit and does not wait for the reservation" do
+    cluster = subject.cluster_uids(@rand_site).first
+    job = subject.reserve(:site => @rand_site, :wait => false)
+    job = subject.wait_for_job(job, :wait_time => 600)
+    expect(job).to include('state' => "running")
+  end
+
+
+  it "should submit a job with OAR hierarchy" do
+
+   job1 = subject.reserve(:site => @rand_site, :switches => 2, :nodes=>1, :cpus => 1, :cores => 1,
+                      :keys => "/home/#{ENV['G5K_USER']}/.ssh/id_rsa",:walltime => '00:10:00')
+   job2 = subject.reserve(:site => @rand_site, :resources => "/switch=2/nodes=1/cpu=1/core=1",
+                     :keys => "/home/#{ENV['G5K_USER']}/.ssh/id_rsa",:walltime => '00:10:00')
+
+   expect(job1).to be_an_instance_of(Cute::G5K::G5KJSON)
+   expect(job2).to be_an_instance_of(Cute::G5K::G5KJSON)
+
+  end
+
+  it "releases all jobs in a site" do
+    expect(subject.release_all(@rand_site)).to be true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+require 'simplecov'
+require 'webmock/rspec'
+
+SimpleCov.start
+# The SimpleCov.start must be issued before any of the application code is required!
+require 'cute'
+
+# Disabling all external requests
+WebMock.disable_net_connect!(allow_localhost: true)
+
+
+class FakeG5KResponse < Hash
+  MEDIA_TYPE = {'uid' => "1",
+                'id' => "1",
+                'user' => "test",
+                'items' => [{'uid' => "item1"},{'uid' => "item2"}],
+                'total' => [2],
+                'offset' => 2,
+                'links' => [{"rel" => "self","href" => "path", "type"=>"application/vnd.grid5000.collection+json"},
+                            {"rel" => "parent","href" => "path", "type"=>"application/vnd.grid5000.collection+json"}],
+                'state' => "running",
+                'started_at' => Time.now,
+                'created_at' => Time.now,
+                'status' => "terminated",
+                'types' => ["deploy"],
+                'assigned_nodes' => ["node1","node2"],
+                'resources_by_type' => {"res" => "val1","subnets" => ["10.140.0.0/22"], "vlans"=>["4"]},
+                'nodes' => {"node1" => {"hard"=> "alive", "soft"=>"busy"}}
+               }
+  def initialize(num_items = 2)
+    MEDIA_TYPE.each { |key,value| self[key] = value}
+    self['items'] = []
+    num_items.times.each{ self['items'].push(MEDIA_TYPE) }
+  end
+
+end
+
+
+RSpec.configure do |config|
+  config.fail_fast = true
+
+  g5k_media_type = FakeG5KResponse.new
+  # Example using addressable templates
+  # uri_sites = Addressable::Template.new "https://{user}:{password}@api.grid5000.fr/{version}/sites"
+  config.before(:each) do
+
+    stub_request(:any,/^https:\/\/.*\:.*@api.grid5000.fr\/.*/).
+      to_return(:status => 200, :body => g5k_media_type.to_json, :headers => {})
+
+    stub_request(:any,/^https:\/\/fake:fake@api.grid5000.fr\.*/).
+      to_return(:status => 401)
+
+    stub_request(:any,/^https:\/\/.*\:.*@api.grid5000.fr\/...\/sites\/non-found\/.*/).
+      to_return(:status => 404)
+
+    stub_request(:post, /^https:\/\/.*\:.*@api.grid5000.fr\/.*/).
+      with(:body => hash_including("resources" => "/slash_22=1+{nonsense},walltime=01:00")).
+      to_return(:status => 400, :body => "Oarsub failed: please verify your request syntax")
+
+    stub_request(:post, /^https:\/\/.*\:.*@api.grid5000.fr\/.*/).
+      with(:body => hash_including("environment" => "nonsense")).
+      to_return(:status => 500, :body => "Invalid environment specification")
+
+  end
+
+end

data/spec/taktuk_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Cute::TakTuk::Stream do
+
+  subject { Cute::TakTuk::Stream.new([:output, :error, :status ]) }
+
+  def random_string(length)
+    valid_chars = []
+    (32..126).each{ |x| valid_chars.push(x.chr)}
+    (1..length).map{ valid_chars[rand(valid_chars.length-1)]}.join
+  end
+
+  it "creates an stream" do
+    stream = Cute::TakTuk::Stream.new
+    expect(stream.types.empty?).to be true
+  end
+
+  it "checking types" do
+    stream = Cute::TakTuk::Stream.new([:output, :error, :status ])
+    expect(stream.types.length).to be 3
+  end
+
+  it "returns empty result" do
+    string = random_string(50)
+    expect(subject.parse(string).empty?).to be true
+  end
+
+  it "returns empty value" do
+    string ="machine.fr/output/aaaaaaaaaa"
+    result = subject.parse(string)
+    expect(result.values.first[:output].length).to be 0
+  end
+
+  it "parses simple string" do
+    value = random_string(50)
+    string ="machine.fr/output/123:#{value}\n"
+    expect(subject.parse(string).empty?).to be false
+  end
+
+  it "parses string with number" do
+    string = "machine/output/1:1\n"
+    expect(subject.parse(string).empty?).to be false
+  end
+
+  it "parses the same line twice" do
+    string = "machine/output/1:1\n output/machine/1:2\n"
+    expect(subject.parse(string).empty?).to be false
+  end
+
+  it "has just one key" do
+    string = "machine/output/1:1\n"
+    expect(subject.parse(string).keys.length).to be 1
+  end
+
+  it "has two keys" do
+    string = "machine1/output/1:1\nmachine2/output/1:2\n"
+    expect(subject.parse(string).keys.length).to be 2
+  end
+
+  it "returns the same output" do
+    value = random_string(100)
+    stdout = "1:"+value
+    string = "machine.fr/output/#{stdout}"
+    result = subject.parse(string)
+    expect(result.values.first[:output]).to eq(value)
+  end
+
+  it "parses very long output" do
+    value = random_string(1000)
+    stdout = "1:"+value
+    string = "machine.fr/output/#{stdout}"
+    result = subject.parse(string)
+    expect(result.values.first[:output]).to eq(value)
+  end
+
+  it "parses hostname and ip" do
+    value = random_string(1000)
+    stdout = "1:"+value
+    machines =["machine.fr","192.168.101.56"]
+    string = "#{machines[0]}/output/#{stdout} \n#{machines[1]}/output/#{stdout}"
+    result = subject.parse(string)
+    expect(result.keys).to eq(machines)
+  end
+
+  it "concatenates stdouts" do
+    value = random_string(100)
+    stdout = "1:"+value # by default streams are formated /machine_name/stream/something:output
+                        # the "something:" it is just for making the execution time of the regex shorter.
+    string = "machine.fr/output/#{stdout}\nmachine.fr/output/#{stdout}\n"
+    expect(subject.parse(string).values.first[:output].length).to be 2*value.length + 1
+  end
+
+end
+
+describe "TakTuk" do
+  it "raises an argument error" do
+    expect{Cute::TakTuk::TakTuk.new()}.to raise_error(ArgumentError)
+  end
+
+  it "raises an argument error" do
+    expect{Cute::TakTuk::TakTuk.new("aaa","aaa")}.to raise_error(ArgumentError)
+  end
+
+  it "does not raise error" do
+    # TakTuk validate options at the beginning of the execution.
+    expect{Cute::TakTuk::TakTuk.new("aaa",{:aaa => "aaa"})}.not_to raise_error
+  end
+
+  it "raises an argu" do
+    tak = Cute::TakTuk::TakTuk.new("aaa",{:aaa => "aaa"})
+    expect{ tak.exec!("haha")}.to raise_error(ArgumentError)
+  end
+
+  it "raises error due to a non existing file " do
+    tak = Cute::TakTuk::TakTuk.new("aaa",{:user => "aaa"})
+    expect{ tak.exec!("haha")}.to raise_error
+  end
+
+  it "raises er" do
+    tak = Cute::TakTuk::TakTuk.new(["aaa"],{:user => "aaa"})
+    expect{ tak.exec!("haha")}.not_to raise_error
+  end
+
+  it "raises er" do
+    tak = Cute::TakTuk::TakTuk.new(["aaa"],{:user => "aaa", :config => "conf_ssh_vagrant"})
+    expect{ tak.exec!("haha")}.not_to raise_error
+  end
+
+end

data/test/test_bash.rb

@@ -0,0 +1,71 @@
+
+require 'test/unit'
+require 'cute/bash'
+
+class TestBash < Test::Unit::TestCase
+
+    def with_bash(cmd = 'bash', &block)
+        return Cute::Bash.bash(cmd, &block)
+    end
+
+    def assert_status_error(&block)
+        throws = false
+        begin
+            with_bash(&block)
+        rescue Cute::Bash::StatusError
+            throws = true
+        end
+        assert_equal throws, true
+    end
+
+    def test_files_dirs
+        with_bash do
+            cd '/'
+            assert pwd == '/'
+            assert dirs.include?('bin')
+            cd 'tmp'
+            assert pwd == '/tmp'
+            run 'rm -rf /tmp/bash_tests'
+            mkdir 'bash_tests'
+            cd 'bash_tests'
+            assert ls == []
+            touch 'file'
+            assert ls == [ 'file' ]
+            assert ls == files
+            mv 'file', 'backup'
+            assert ls == [ 'backup' ]
+            mkdir 'subdir'
+            assert ls.length == 2
+            assert dirs == [ 'subdir' ]
+            cp 'backup', 'subdir/whatever'
+            cd 'subdir'
+            assert ls == [ 'whatever' ]
+            cd '..'
+            assert abspath('subdir/hmmm') == '/tmp/bash_tests/subdir/hmmm'
+
+            f = tmp_file()
+            assert exists(f)
+            assert get_type(f) == :file
+            assert get_type('/var') == :dir
+            append_line f, "1st"
+            append_lines f, [ "2nd", "3rd" ]
+            assert cat(f) == contents(f)
+            lines = cat(f)
+            assert lines == "1st\n2nd\n3rd\n"
+        end
+    end
+
+    def test_utils
+        with_bash do
+            assert (echo 'anybody?') == ("anybody?\n")
+            assert (bc '2 + 2 * 2') == '6'
+        end
+    end
+
+    def test_error
+        assert_status_error do
+            rm '/'
+        end
+    end
+
+end