addax 0.10.0

data/Rakefile

@@ -0,0 +1,16 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "addax"
+    gemspec.summary = "Command-line tool for accessing TIMA-SLS's ADDAX webservice."
+    gemspec.email = "guillaume.godetbar@gmail.com"
+    gemspec.homepage = "http://tima-sls.imag.fr/addax"
+    gemspec.authors = ["Guillaume Godet-Bar"]
+    gemspec.files = FileList["lib/**/*", "bin/*", "Rakefile", "VERSION"]
+    gemspec.executables = ['addax']
+    gemspec.add_dependency 'rest-client'
+    gemspec.add_dependency 'json'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.10.0

data/bin/addax

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '../lib')
+require 'addax'
+
+opts = Addax::Exec.new(ARGV)
+opts.parse!

data/lib/addax.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'rest_client'
+require 'json'
+require 'readline'
+require 'base64'
+require 'tempfile'
+require 'pp'
+
+require File.join(File.dirname(__FILE__), 'addax/commands')
+
+module Addax
+  USAGE = <<END
+Addax, a command line tool for connecting with the Addax Webservice.
+
+Usage
+
+  addax <Action>
+
+Actions
+          
+  [list | l] <object_type>                - lists all available objects, which should be either 'oses|operating_systems', 'drivers', 'platforms'
+  <object_type> <id>                      - displays the data associated with the object instance, e.g. 'addax driver 1'
+  [fetch | f] <object_type> <id> <path>   - returns the file associated with a driver or a platform
+  [generate | g] <id> <path>              - downloads the generated sources for the driver associated with <id> into <path>
+  [create | c] <object_type> <param>=<value> [<param>=<value>]*
+                                          - creates a new instance of the object type, with the list of parameters provided.
+  [update | u] <object_type> <id> <param>=<value> [<param>=<value>]*
+                                          - modifies the object identified by <id> with the list of parameters provided.
+  [destroy | d] [-f] <object_type> <id>   - destroys the object identified by <id>. -f to destroy without asking for confirmation.
+
+END
+
+  SERVER_URL = 'http://tima-sls.imag.fr/addax'
+
+  class Exec
+
+    def initialize(args)
+      @args = args
+    end
+
+    def parse!
+      begin
+        parse
+      rescue ArgumentError
+        $stderr.puts USAGE
+      end
+    end
+
+    def parse
+      if ARGV.size == 2 && %w(l list).include?(ARGV[0]) && %w(operating_systems oses platforms drivers strategies).include?(ARGV[1])
+        Addax::Commands.list(ARGV[1])
+      elsif ARGV.size == 2 && %w(operating_system os driver platform).include?(ARGV[0])
+        Addax::Commands.show(ARGV[0], ARGV[1])
+      elsif ARGV.size == 3 && %w(g generate).include?(ARGV[0])
+        Addax::Commands.generate(ARGV[1], ARGV[2])
+      elsif ARGV.size > 2 && %w(c create).include?(ARGV[0]) && %w(operating_system os platform driver).include?(ARGV[1])
+        Addax::Commands.send("create_#{ARGV[1]}".to_sym, ARGV[2..-1])
+      elsif ARGV.size == 4 && %w(f fetch).include?(ARGV[0]) && %w(driver platform).include?(ARGV[1])
+        Addax::Commands.send("fetch_#{ARGV[1]}".to_sym, ARGV[2], ARGV[3])
+      elsif ARGV.size > 3 && %w(u update).include?(ARGV[0]) && %w(operating_system os platform driver).include?(ARGV[1])
+        Addax::Commands.update(ARGV[1], ARGV[2], ARGV[3..-1])
+      elsif ARGV.size >= 3 && %w(d destroy).include?(ARGV[0])
+        if ARGV[1] == '-f'
+          Addax::Commands.destroy(ARGV[2], ARGV[3])
+        else
+          begin
+            puts "Please confirm that you wish to destroy this resource (Y/n)"
+            line = Readline.readline()
+          end while !%w(Y n).include?(line)
+          if line == 'Y'
+            Addax::Commands.destroy(ARGV[1], ARGV[2])
+          end
+        end
+      else
+        raise ArgumentError
+      end
+    end
+  end
+end

data/lib/addax/commands.rb

@@ -0,0 +1,236 @@
+module Addax
+  module Commands
+
+    OUTPUTS = {
+      :generic_error          => "ERROR. Something went wrong with the server.",
+      :not_found              => "ERROR. Resource not found.",
+      :platform_data_missing  => "ERROR. Platform data file (format: zip) is missing.",
+      :created_resource       => "Successfully created resource.",
+      :updated_resource       => "Successfully updated resource.",
+      :destroyed_resource     => "Successfully destroyed resource.",
+      :security_tokens_error  => "ERROR. Could not fetch security tokens from the server."
+    }
+
+    def self.list(type)
+      type = type == 'oses' ? 'operating_systems' : type
+      begin
+        response = RestClient.get "#{SERVER_URL}/#{type}.json"
+      rescue => e
+        abort OUTPUTS[:generic_error]
+      else
+        format(response.body)
+      end
+    end
+
+    def self.show(model, id)
+      type = type == 'os' ? 'operating_system' : type
+      begin
+        response = RestClient.get "#{SERVER_URL}/#{model}s/#{id}.json"
+      rescue => e
+        case e.response.code
+          when 404 then
+            abort OUTPUTS[:not_found]
+          else
+            abort OUTPUTS[:generic_error]
+        end
+      else
+        format(response.body)
+      end
+    end
+
+    def self.generate(driver_id, file_path)
+      begin
+        response = RestClient.post "#{SERVER_URL}/drivers/#{driver_id}/generate_sources", {}
+      rescue => e
+        case e.response.code
+          when 404 then
+            abort OUTPUTS[:not_found]
+          else
+            abort OUTPUTS[:generic_error]
+        end
+      else
+        file_name = response.headers[:content_disposition].scan(/filename="(.+)"/)[0][0] + ".zip"
+        File.open File.join(file_path, file_name), "w" do |f|
+          f.write(response.body)
+        end
+        puts "File was written to #{File.join(file_path, file_name)}"
+      end
+    end
+
+    def self.fetch_driver(object_id, file_path)
+      begin
+        response = RestClient.get "#{SERVER_URL}/drivers/#{object_id}/show_attachment"
+      rescue => e
+        case e.response.code
+          when 404 then
+            abort OUTPUTS[:not_found]
+          else
+            abort OUTPUTS[:generic_error]
+        end
+      else
+        file_name = response.headers[:content_disposition].scan(/filename="(.+)"/)[0][0] + ".xml"
+        File.open File.join(file_path, file_name), "w" do |f|
+          f.write(response.body)
+        end
+        puts "File was written to #{File.join file_path, file_name}"
+      end
+    end
+
+    def self.fetch_platform(object_id, file_path)
+      abort "ERROR: Platform data fetch not implemented yet!"
+    end
+
+    def self.create_platform(params)
+      param_hash = normalize_params(params)
+
+      authenticity_token, cookie = security_tokens
+
+      # The params should at least have a platform_data param
+      platform_data = param_hash.delete(:platform_data)
+      unless platform_data
+        abort OUTPUTS[:platform_data_missing]
+      end
+
+      begin
+        load_platform_data_response = RestClient.post "#{SERVER_URL}/platforms/load_file.json",
+                                                      {:platform_data => File.new(platform_data, 'rb'), :authenticity_token => authenticity_token},
+                                                      {:cookies => cookie}
+      rescue => e
+        abort OUTPUTS[:generic_error] + '\n' + format_error(e.response.body)
+      end
+
+      encoded_cache_name = load_platform_data_response.body
+
+      if param_hash[:root_component]
+        begin
+          create_platform_response = RestClient.post "#{SERVER_URL}/platforms.json?cache=#{encoded_cache_name}",
+                                                     {:platform => param_hash, :authenticity_token => authenticity_token},
+                                                     {:cookies => cookie}
+        rescue => e
+          abort OUTPUTS[:generic_error] + '\n' + format_error(e.response.body)
+        else
+          puts OUTPUTS[:created_resource]
+          format(create_platform_response.body)
+        end
+      else
+        abort "ERROR: Root component choice not yet implemented!"
+      end
+    end
+
+    def self.create_driver(params)
+      param_hash = normalize_params(params)
+
+      authenticity_token, cookie = security_tokens
+
+      begin
+        response = RestClient.post "#{SERVER_URL}/drivers.json",
+                                   {:driver => param_hash, :authenticity_token => authenticity_token},
+                                   {:cookies => cookie}
+      rescue => e
+        abort OUTPUTS[:generic_error] + '\n' + format_error(e.response.body)
+      else
+        puts OUTPUTS[:updated_resource]
+        format(response.body)
+      end
+    end
+
+    def self.create_operating_system(params)
+      param_hash = normalize_params(params)
+
+      authenticity_token, cookie = security_tokens
+
+      begin
+        response = RestClient.post "#{SERVER_URL}/operating_systems.json",
+                                   {:operating_system => param_hash,:authenticity_token => authenticity_token},
+                                   {:cookies => cookie}
+      rescue => e
+        abort OUTPUTS[:generic_error] + '\n' + format_error(e.response.body)
+      else
+        puts OUTPUTS[:created_resource]
+        format(response.body)
+      end
+    end
+
+    def self.update(object_type, object_id, params)
+      object_type = object_type == "os" ? "operating_system" : object_type
+      param_hash = normalize_params(params)
+
+      begin
+        response = RestClient.put "#{SERVER_URL}/#{object_type}s/#{object_id}.json",
+                                  {object_type.to_sym => param_hash}
+      rescue => e
+        abort OUTPUTS[:generic_error] + '\n' + format_error(e.response.body)
+      else
+        puts OUTPUTS[:updated_resource]
+        format(response.body)
+      end
+    end
+
+    def self.destroy(object_type, object_id)
+      authenticity_token, cookie = security_tokens
+      begin
+        response = RestClient.delete "#{SERVER_URL}/#{object_type}s/#{object_id}.json", {:cookies => cookie}
+      rescue => e
+        case e.response.code
+          when 404 then
+            abort OUTPUTS[:not_found]
+          else
+            abort OUTPUTS[:generic_error]
+          end
+      else
+        puts OUTPUTS[:destroyed_resource]
+      end
+    end
+
+    class << self
+      alias :create_os :create_operating_system
+    end
+
+private
+    def self.security_tokens
+      begin
+        new_response = RestClient.get "#{SERVER_URL}/drivers/new.html" # Any form would do
+      rescue => e
+        abort OUTPUTS[:security_tokens_error]
+      else
+        authenticity_token = new_response.body.scan(/<meta name="csrf-token" content="(.*)"\/>/)[0][0]
+        cookie = new_response.cookies
+        [authenticity_token, cookie]
+      end
+    end
+
+    def self.normalize_params(param_array)
+      param_hash = param_array.inject({}){|acc, p| pieces = p.split('='); acc[pieces[0].to_sym] = pieces[1]; acc}
+      param_hash.delete(:id)
+      param_hash.delete(:created_at)
+      param_hash.delete(:updated_at)
+
+      param_hash
+    end
+
+    def self.format(json)
+      content = json.is_a?(String) ? JSON::parse(json) : json
+      if content.is_a?(Array)
+        content.each do |el|
+          format(el)
+        end
+      else
+        puts content.values[0].delete('name') + ":"
+        data = content.values[0]
+        data.each do |k, v|
+          puts "\t" + k + ": " + v.to_s #.gsub('_', ' ').capitalize + ": " + v.to_s
+        end
+
+      end
+    end
+
+    def self.format_error(json)
+      content = json.is_a?(String) ? JSON::parse(json) : json
+      if content.is_a?(Hash)
+        content.collect do |k, v|
+          "\t" + k + ' ' + v
+        end.join('\n')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: addax
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 10
+  - 0
+  version: 0.10.0
+platform: ruby
+authors: 
+- Guillaume Godet-Bar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 +01:00
+default_executable: addax
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+description: 
+email: guillaume.godetbar@gmail.com
+executables: 
+- addax
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- VERSION
+- bin/addax
+- lib/addax.rb
+- lib/addax/commands.rb
+has_rdoc: true
+homepage: http://tima-sls.imag.fr/addax
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Command-line tool for accessing TIMA-SLS's ADDAX webservice.
+test_files: []
+