squall 0.0.3 → 1.0.0

data/lib/squall/statistic.rb

@@ -0,0 +1,10 @@
+module Squall
+  # OnApp Statistic
+  class Statistic < Base
+    # Returns statitics for a given VirtualMachine
+    def daily_stats(id)
+      response = request(:get, "/usage_statistics.json")
+      response.first['vm_hourly_stat']
+    end
+  end
+end

data/lib/squall/template.rb

@@ -0,0 +1,22 @@
+module Squall
+  # OnApp Template
+  class Template < Base
+    # Return a list of available Templates
+    def list
+      response = request(:get, '/templates.json')
+      response.collect { |temp| temp['image_template'] }
+    end
+
+    # Make a Template public so that it can be downloaded
+    # via a HTTP url
+    def make_public(id)
+      response = request(:post, "/templates/#{id}/make_public.json")
+      response.first[1]
+    end
+
+    # Download a Template image
+    def download(id)
+      response = request(:get, "/templates.json?remote_template_id=#{id}")
+    end
+  end
+end

data/lib/squall/transaction.rb

@@ -0,0 +1,16 @@
+module Squall
+  # OnApp Transaction
+  class Transaction < Base
+    # Returns a list of all Transactions.
+    def list
+      response = request :get, '/transactions.json'
+      response.collect { |t| t['transaction'] }
+    end
+
+    # Return a Hash for the given Transaction
+    def show(id)
+      response = request :get, "/transactions/#{id}.json"
+      response['transaction']
+    end
+  end
+end

data/lib/squall/user.rb

@@ -0,0 +1,87 @@
+module Squall
+  # OnApp User
+  class User < Base
+    # Return a list of all users
+    def list
+      response = request(:get, '/users.json')
+      response.collect { |user| user['user']}
+    end
+
+
+    # Create a new User
+    #
+    # ==== Options
+    #
+    # * +options+ - Params for creating the User
+    #
+    # ==== Example
+    #
+    #   create :login      => 'bob',
+    #          :email      => 'something@example.com',
+    #          :password   => 'secret',
+    #          :first_name => 'Bob',
+    #          :last_name  => 'Smith',
+    #          :group_id   => 1
+    def create(options = {})
+      params.required(:login, :email, :password).accepts(:first_name, :last_name, :group_id).validate!(options)
+      request(:post, '/users.json', default_params(options))
+    end
+
+    # Return a Hash of the given User
+    def show(id)
+      response = request(:get, "/users/#{id}.json")
+      response.first[1]
+    end
+
+    # Create a new API Key for a User
+    def generate_api_key(id)
+      request(:post, "/users/#{id}/make_new_api_key.json")
+    end
+
+    # Suspend a User
+    def suspend(id)
+      response = request(:get, "/users/#{id}/suspend.json")
+      response.first[1]
+    end
+
+    # Activate a user
+    def activate(id)
+      response = request(:get, "/users/#{id}/activate_user.json")
+      response.first[1]
+    end
+    alias_method :unsuspend, :activate
+
+    # Delete a user
+    def delete(id)
+      response = request(:delete, "/users/#{id}.json")
+      success
+    end
+
+    # Get the stats for a User
+    def stats(id)
+      response = request(:get, "/users/#{id}/vm_stats.json")
+      response.first['vm_stats']
+    end
+
+    # Return a list of VirtualMachines for a User
+    def virtual_machines(id)
+      response = request(:get, "/users/#{id}/virtual_machines.json")
+      response.collect { |vm| vm['virtual_machine']}
+    end
+
+    # Edit a role for a user
+    #
+    # ==== Options
+    #
+    # * +id+ - id of the User
+    # * +roles+ - A single Role id or Array of Roles
+    #
+    # ==== Example
+    #
+    #   edit_role 1, 2 # Role 2
+    #   edit_role 1, [1,2] # Role 1 & 2
+    def edit_role(id, *roles)
+      request(:put, "/users/#{id}.json", default_params(:role_ids => roles))
+    end
+  end
+end

data/lib/squall/version.rb

@@ -0,0 +1,3 @@
+module Squall
+  VERSION = '1.0.0'
+end

data/lib/squall/virtual_machine.rb

@@ -1,59 +1,187 @@
 module Squall
-  class VirtualMachine < Client
-
-    URI_PREFIX   = 'virtual_machines'
-    VALID_PARAMS = [:primary_network_id, 
-                    :cpus, 
-                    :label, 
-                    :cpu_shares, 
-                    :template_id, 
-                    :swap_disk_size,
-                    :memory, 
-                    :required_virtual_machine_build, 
-                    :hypervisor_id, 
-                    :required_ip_address_assignment,
-                    :rate_limit, 
-                    :primary_disk_size,
-                    :hostname,
-                    :initial_root_password ]
-
+  # OnApp VirtualMachine
+  class VirtualMachine < Base
+    # Return a list of VirtualMachines
     def list
-      if get(URI_PREFIX)
-        @message.collect { |res| res['virtual_machine'] }
-      else
-        []
-      end
+      response = request(:get, '/virtual_machines.json')
+      response.collect { |v| v['virtual_machine'] }
     end
 
+    # Return a Hash for the given VirtualMachine
     def show(id)
-      get("#{URI_PREFIX}/#{id}") ? @message['virtual_machine'] : false
+      response = request(:get, "/virtual_machines/#{id}.json")
+      response.first[1]
     end
 
-    def edit(id, params = {})
-      valid_options!(VALID_PARAMS, params)
-      put("#{URI_PREFIX}/#{id}", { :virtual_machine => params }) 
+    # Create a new VirtualMachine
+    #
+    # ==== Options
+    #
+    # * +options+ - Params for creating the VirtualMachine
+    #
+    # ==== Example
+    #
+    #  params = {
+    #    :label => 'testmachine', 
+    #    :hypervisor_id => 5,
+    #    :hostname => 'testmachine', 
+    #    :memory => 512, 
+    #    :cpus => 1,
+    #    :cpu_shares => 10, 
+    #    :primary_disk_size => 10
+    #  }
+    #
+    #  create params
+    def create(options = {})
+      required = [:label, :hypervisor_id, :hostname, :memory, :cpus, :cpu_shares, :primary_disk_size]
+      optional = [:cpu_shares,
+                  :swap_disk_size,
+                  :primary_network_id,
+                  :required_automatic_backup,
+                  :rate_limit,
+                  :required_ip_address_assignment,
+                  :required_virtual_machine_build,
+                  :admin_note,
+                  :note,
+                  :allowed_hot_migrate,
+                  :template_id,
+                  :initial_root_password
+      ]
+      params.required(required).accepts(optional).validate! options
+      response = request(:post, '/virtual_machines.json', default_params(options))
+      response['virtual_machine']
     end
 
-    def create(params = {})
-      required = [ :memory, :cpus, :label, :template_id, :hypervisor_id, :initial_root_password ]
-      required_options!(required, params)
-      post(URI_PREFIX, { :virtual_machine => params })
+    # Build a VirtualMachine
+    #
+    # ==== Options
+    #
+    # * +id+
+    # * +options+ - :template_id, :required_startup
+    def build(id, options = {})
+      params.accepts(:template_id, :required_startup).validate! options
+      response = request(:post, "/virtual_machines/#{id}/build.json", default_params(options))
+      response.first[1]
     end
 
-    def destroy(id)
-      delete("#{URI_PREFIX}/#{id}")
+    # Edit a new VirtualMachine
+    #
+    # ==== Options
+    #
+    # * +options+ - Params for editing the VirtualMachine
+    #
+    # ==== Example
+    #
+    #  params = {
+    #    :label => 'testmachine', 
+    #    :hypervisor_id => 5,
+    #    :hostname => 'testmachine', 
+    #    :memory => 512, 
+    #    :cpus => 1,
+    #    :cpu_shares => 10, 
+    #    :primary_disk_size => 10
+    #  }
+    #
+    #  edit params
+    def edit(id, options = {})
+      optional = [:label,
+                  :hypervisor_id,
+                  :hostname,
+                  :memory,
+                  :cpus,
+                  :cpu_shares,
+                  :primary_disk_size,
+                  :cpu_shares,
+                  :swap_disk_size,
+                  :primary_network_id,
+                  :required_automatic_backup,
+                  :rate_limit,
+                  :required_ip_address_assignment,
+                  :required_virtual_machine_build,
+                  :admin_note,
+                  :note,
+                  :allowed_hot_migrate,
+                  :template_id,
+                  :initial_root_password
+      ]
+      params.accepts(optional).validate! options
+      request(:put, "/virtual_machines/#{id}.json", default_params(options))
     end
 
-    def reboot(id)
-      post("#{URI_PREFIX}/#{id}/reboot")
+    # Change the owner of a VirtualMachine
+    #
+    # ==== Options
+    # * +id+ - id of the VirtualMachine
+    # * +user_id+ - id of the target User
+    def change_owner(id, user_id)
+      response = request(:post, "/virtual_machines/#{id}/change_owner.json", :query => { :user_id => user_id })
+      response['virtual_machine']
+    end
+
+    # Change the password
+    def change_password(id, password)
+      response = request(:post, "/virtual_machines/#{id}/reset_password.json", :query => { :new_password => password })
+      response['virtual_machine']
+    end
+
+    # Migrate a VirtualMachine to a new Hypervisor
+    #
+    # ==== Options
+    #
+    # * +id+
+    # * +options+ - :destination, :cold_migrate_on_rollback
+    def migrate(id, options = {})
+      params.required(:destination).accepts(:cold_migrate_on_rollback).validate! options 
+      response = request(:post, "/virtual_machines/#{id}/migrate.json", :query => options )
     end
 
-    def search(pattern, *fields)
-      fields = [:label] if fields.empty?
-      valid_options!(VALID_PARAMS, fields)
-      list.select do |vm| 
-        fields.detect { |field| vm.has_key?(field.to_s) && vm[field.to_s].to_s.match(/#{pattern}/) }
-      end
+    # Delete a VirtualMachine
+    def delete(id)
+      request(:delete, "/virtual_machines/#{id}.json")
+    end
+
+    # Resize a VirtualMachine's memory
+    def resize(id, options = {})
+      params.required(:memory).accepts(:allow_migration).validate! options
+      response = request(:post, "/virtual_machines/#{id}/resize.json", default_params(options))
+      response['virtual_machine']
+    end
+
+    # Suspend/Unsuspend a VirtualMachine
+    def suspend(id)
+      response = request(:post, "/virtual_machines/#{id}/suspend.json")
+      response['virtual_machine']
+    end
+    alias_method :unsuspend, :suspend
+
+    # Unlock a VirtualMachine
+    def unlock(id)
+      response = request(:post, "/virtual_machines/#{id}/unlock.json")
+      response['virtual_machine']
+    end
+
+    # Boot a VirtualMachine
+    def startup(id)
+      response = request(:post, "/virtual_machines/#{id}/startup.json")
+      response['virtual_machine']
+    end
+
+    # Shutdown a VirtualMachine
+    def shutdown(id)
+      response = request(:post, "/virtual_machines/#{id}/shutdown.json")
+      response['virtual_machine']
+    end
+
+    # Stop a VirtualMachine
+    def stop(id)
+      response = request(:post, "/virtual_machines/#{id}/stop.json")
+      response['virtual_machine']
+    end
+
+    # Reboot a VirtualMachine
+    def reboot(id)
+      response = request(:post, "/virtual_machines/#{id}/reboot.json")
+      response['virtual_machine']
     end
   end
 end

data/lib/squall.rb

@@ -1,26 +1,82 @@
-require 'rubygems'
-require 'json'
-require 'rest_client'
-require 'open-uri'
+require 'httparty'
 
-[:client, :virtual_machine, :hypervisor].each do |f|
-  require File.join(File.dirname(__FILE__), 'squall', f.to_s)
-end
+require 'squall/version'
+require 'squall/exception'
 
 module Squall
- class << self
-
-    # Sepcifies the login and url for making requests
-    #
-    # example:
-    #
-    #   Squall.config(api_user, api_password, api_url)
-    #
-    attr_accessor :api_endpoint, :api_user, :api_password
-    def config(api_user, api_password, api_url)
-      @api_user     = api_user
-      @api_password = api_password
-      @api_endpoint = URI.parse(api_url)
+  autoload :Params,         'squall/params'
+  autoload :Hypervisor,     'squall/hypervisor'
+  autoload :Config,         'squall/config'
+  autoload :Base,           'squall/base'
+  autoload :User,           'squall/user'
+  autoload :Role,           'squall/role'
+  autoload :Network,        'squall/network'
+  autoload :IpAddress,      'squall/ip_address'
+  autoload :Template,       'squall/template'
+  autoload :VirtualMachine, 'squall/virtual_machine'
+  autoload :Statistic,      'squall/statistic'
+  autoload :Transaction,    'squall/transaction'
+
+  extend self
+
+  # Config
+  attr_accessor :configuration
+
+  # Config 
+  attr_accessor :configuration_file
+
+  # The path to your squall.yml
+  self.configuration ||= Squall::Config.new
+
+  # Specificy the config via block
+  # 
+  # ==== Attributes
+  #
+  # * +base_uri+ - URL of your OnApp instance
+  # * +username+ - API username
+  # * +password+ - API Password
+  #
+  # ==== Example
+  #
+  #   Squall.config do |c|
+  #     c.base_uri 'http://onapp.myserver.com'
+  #     c.username 'myuser'
+  #     c.password 'mypass'
+  #   end
+  def config
+    yield self.configuration if block_given?
+    self.configuration.config
+  end
+
+  # Load the config from a YAML file
+  #
+  # ==== Options
+  #
+  # * +file+ - Path to the YAML file (default is ~/.squall.yml)
+  #
+  # ==== Example
+  #
+  #   Squall.config_file # (loads ~/.squall.yml)
+  #
+  #   Squall.config_file '/path/to/squall.yml'
+  #
+  def config_file(file = nil)
+    file = File.expand_path(File.expand_path(File.join(ENV['HOME'], '.squall.yml'))) if file.nil?
+    if File.exists?(file)
+      self.configuration_file = file
+    else
+      raise ArgumentError, "Config file doesn't exist '#{file}'"
+    end
+    config do |c|
+      conf = YAML::load_file(file)
+      c.base_uri  conf['base_uri']
+      c.username  conf['username']
+      c.password  conf['password']
     end
   end
+
+  # Reset the config (aka, clear it)
+  def reset_config
+    self.configuration = Squall::Config.new
+  end
 end

data/spec/params_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Squall::Params do
+  before(:each) do 
+    @params = Squall::Params.new
+  end
+
+  describe "#new" do
+    it "sets @valid to {}" do
+      @params.valid.should be_empty
+    end
+
+    it "sets @optional to {}" do
+      @params.optional.should be_empty
+    end
+  end
+
+  describe "#required" do
+    it "stores keys in @valid with an Array" do
+      params = [:one, :two]
+      @params.required params
+      @params.valid.size.should == 2
+      @params.valid.should include(:one, :two)
+    end
+
+    it "stores uniq keys only" do
+      @params.required :one, :one
+      @params.valid.size.should == 1
+      @params.valid.should include(:one)
+    end
+
+    it "adds @valid to @optional" do
+      params = [:one, :two]
+      @params.required params
+      @params.valid.size.should == 2
+      @params.optional.size.should == 2
+
+      @params.valid.should include(:one, :two)
+      @params.optional.should include(:one, :two)
+    end
+
+    it "returns self" do
+      @params.required([:one, :two]).should be_a(Squall::Params)
+    end
+
+    it "resets @valid" do
+      params = [:one, :two]
+      @params.required params
+      @params.valid.size.should == 2
+      @params.valid.should include(:one, :two)
+
+      params = [:three, :four]
+      @params.required params
+      @params.valid.size.should == 2
+      @params.valid.should include(:three, :four)
+    end
+  end
+
+  describe "#accepts" do
+    it "stores keys in @optional with an Array" do
+      params = [:one, :two]
+      @params.accepts params
+      @params.optional.size.should == 2
+      @params.optional.should include(:one, :two)
+    end
+
+    it "stores uniq keys only" do
+      @params.accepts :one, :one
+      @params.optional.size.should == 1
+      @params.optional.should include(:one)
+    end
+
+    it "doesn't reset @valid" do
+      @params.required(:two)
+      @params.accepts(:one)
+
+      @params.optional.uniq.size.should be(2)
+      @params.optional.uniq.should include(:one, :two)
+    end
+
+
+    it "returns self" do
+      @params.accepts([:one, :two]).should be_a(Squall::Params)
+    end
+
+    it "resets @optional" do
+      params = [:one, :two]
+      @params.accepts params
+      @params.optional.size.should == 2
+      @params.optional.should include(:one, :two)
+
+      params = [:three, :four]
+      @params.accepts params
+      @params.optional.size.should == 4
+      @params.optional.should include(:three, :four)
+    end
+  end
+
+  describe "#validate_required!" do
+    describe "Array param input" do
+      it "raises an error with missing options" do
+        params = [:one, :two]
+        @params.required params
+        expect { @params.validate_required!(:three) }.to raise_error(ArgumentError)
+      end
+
+      it "does not raise an error with valid" do
+        params = [:one, :two]
+        @params.required params
+        @params.validate_required!(:one, :two)
+      end
+
+      it "does not raise an error when empty" do
+        @params.required []
+        @params.validate_required! :whatever
+      end
+    end
+
+    describe "Hash param input" do
+      it "raises an error with missing options" do
+        params = [:one, :two]
+        @params.required params
+        expect { @params.validate_required!({:three => 'three'}) }.to raise_error(ArgumentError)
+      end
+
+      it "does not raise an error with valid" do
+        params = [:one, :two]
+        @params.required params
+        @params.validate_required!(:one => 1, :two => 2)
+      end
+    end
+
+    describe "String param input" do
+      it "raises an error with missing options" do
+        params = [:one, :two]
+        @params.required params
+        expect { @params.validate_required!({'three' => 'three'}) }.to raise_error(ArgumentError)
+      end
+
+      it "does not raise an error with valid" do
+        params = [:one, :two]
+        @params.required params
+        @params.validate_required!('one' => 1, 'two' => 2)
+      end
+    end
+
+    describe "Chained execution" do
+      it "raises an error with missing options" do
+        params = [:one, :two]
+        expect { @params.required(params).validate_required!({'three' => 'three'}) }.to raise_error(ArgumentError)
+      end
+
+      it "does not raise an error with valid" do
+        params = [:one, :two]
+        @params.required(params).validate_required!('one' => 1, 'two' => 2)
+      end
+    end
+  end
+
+  describe "#validate_optionals!" do
+    it "raises an error with unknown params" do
+      @params.accepts :one, :two
+      expect { @params.validate_optionals!({:three => 3}) }.to raise_error(ArgumentError)
+    end
+
+    it "allows a known param" do
+      @params.accepts :one
+      @params.validate_optionals!({:one => 1}).should be_true
+    end
+
+    it "allows multiple known param" do
+      @params.accepts :one, :two
+      @params.validate_optionals!({:one => 1, :two => 2}).should be_true
+    end
+
+    it "allows 2 of 3 known param" do
+      @params.accepts :one, :two, :three
+      @params.validate_optionals!({:one => 1, :two => 2}).should be_true
+    end
+  end
+
+  describe "#validate!" do
+    it "calls #validate_required!" do
+      @params.valid = [:one, :two]
+      @params.should_receive(:validate_required!).with(:one, :two)
+      @params.validate!(:one, :two) 
+    end
+
+    it "calls #validate_optionals!" do
+      @params.optional = [:one, :two]
+      @params.should_receive(:validate_optionals!).with(:one, :two)
+      @params.validate!(:one, :two) 
+    end
+  end
+end