ganeti_client 0.0.1

data/README

@@ -0,0 +1,75 @@
+== License
+    
+    This Ruby Ganeti Client is release under AGPL licence (http://www.gnu.org/licenses/agpl-3.0.html)
+
+
+== Todo
+
+    1. Manually test the following methods + fix when bugs found
+        1.1.    redistribute_config
+        1.2.    instance_create
+        1.3.    instance_delete
+        1.4.    instance_reboot
+        1.5.    instance_shutdown
+        1.6.    instance_startup
+        1.7.    instance_reinstall
+        1.8.    instance_replace_disks
+        1.9.    instance_activate_disks
+        1.10.   instance_create_tags
+        1.11.   instance_delete_tags
+        1.12.   job_get
+        1.13.   job_delete
+        1.14.   node_evaluate
+        1.15.   node_migrate
+        1.16.   node_change_role
+        1.17.   node_get_storage
+        1.18.   node_modify_storage
+        1.19.   node_repair_storage
+        1.20.   node_get_tags
+        1.21.   node_create_tags
+        1.22.   node_delete_tags
+        1.22.   tags_create
+        1.23.   tags_delete
+    2. Add some error handling
+    3. Make some code improvements
+    4. Add better comments
+    5. Improve this README with better docs 
+    6. Write tests!
+
+
+== About
+
+
+== Installation
+    
+    gem install ganeti_client
+
+
+== Usage
+    
+    # the last parameter is a boolean (true|false) to indicate if you want to display the response.
+    # this might be handy for debugging purposes
+    client = GanetiClient::Client.new("your-host-and-port", "username", "password", boolean)
+
+    # now you should be able to access the api resources by using the client instance. 
+    # example:
+    info = client.get_info
+    => #<GanetiInfo:0x10151bb78>
+
+    # most methods return an object. When you use .to_json on an object, you get the json object returned
+    # then you can see all the attributes available
+    info.name
+    => "hostname"
+
+== Contributing
+
+    1. Fork the project
+    2. Add your changes
+    3. Write tests
+    4. Send a pull request
+
+
+
+
+
+

data/lib/ganeti_client.rb

@@ -0,0 +1,14 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'base64'
+require 'json'
+
+require 'ganeti_client/client'
+require 'ganeti_client/ganeti_object'
+
+
+module GanetiClient
+
+
+end

data/lib/ganeti_client/client.rb

@@ -0,0 +1,562 @@
+module GanetiClient
+    class Client
+
+        attr_accessor :conn, :headers, :version, :show_response
+
+        def initialize(host, username, password, show_response = false)
+            self.show_output = show_output
+            uri = URI.parse(host)
+
+            self.conn = Net::HTTP.new(uri.host, uri.port)
+            self.conn.use_ssl = (uri.scheme == "http")? false : true
+
+            self.headers = authenticate(username, password)
+
+            self.version = self.get_version
+        end
+
+
+        # Cluster information resource
+        # Returns cluster information
+        def info_get
+            url = get_url("info")
+            response_body = JSON.parse(send_request("GET", url))
+
+            create_class("GanetiInfo")
+ 
+            return GanetiInfo.new(response_body)
+        end
+
+        # Redistrite configuration to all nodes
+        # Redistribute configuration to all nodes. The result will be a job id.
+        def redistribute_config
+            url = get_url("redistribute-config")
+            response_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+        # The instance resource
+        # Returns a list of all available instances
+        # If the optional bool bulk argument is provided and set to a true value (i.e ?bulk=1), the output contains detailed information about instances as a list.
+        def instances_get(bulk = 0)
+            url = get_url("instances", {"bulk" => bulk})
+            response_body = JSON.parse(send_request("GET", url))
+
+            create_class("GanetiInstance")
+
+            list = Array.new
+            response_body.each { |item| list << GanetiInstance.new(item) }
+
+            return list
+        end
+
+        # Creates an instance
+        # If the options bool dry-run argument is provided, the job will not be actually executed, only the pre-execution checks will be done. 
+        # Query-ing the job result will return, in boty dry-run and normal case, the list of nodes selected for the instance
+        # Returns: a job ID that can be used later for polling
+        #
+        # Example of instance info:
+        #   
+        def instance_create(info, dry_run = 0)
+            url = get_url("instances", {"dry-run" => dry_run})
+            body = JSON.generate(info)
+            response_body = send_request("POST", url, body)
+
+            return response_body
+        end
+
+        # Instance-specific resource
+        # Returns information about an instance, similar to the bulk output from the instance list
+        def instance_get(name)
+            url = get_url("instances/#{name}")
+            response_body = JSON.parse(send_request("GET", url))
+
+            create_class("GanetiInstance")
+
+            return GanetiInstance.new(response_body)
+        end
+
+        # Instance-specific resource
+        # Deletes an instance
+        # It supports the dry-run argument
+        def instance_delete(name, dry_run)
+            url = get_url("instances/#{name}", {"dry-run" => dry_run})
+            response_body = send_request("DELETE", url)
+
+            return response_body 
+        end
+
+        # Requests detailed information about an instance. 
+        # An optional parameter, static (bool), can be set to return only static information from the configuration without querying the instance's nodes
+        # The result will be a job id
+        def instance_get_info(name, static = 0)
+            url = get_url("instances/#{name}/info", {"static" => static})
+            response_body = send_request("GET", url)
+
+            return response_body
+        end
+
+        # Reboots URI for an instance
+        # Reboots the instance
+        # The URI takes optional type=soft|hard|full and ignore_secondaries=0|1 parameters
+        # 
+        # type defines the reboot type. 
+        #   soft is just a normal reboot, without terminating the hypervisor. 
+        #   hard means full shutdown (including terminating the hypervisor process) and startup again
+        #   full is like hard but also recreates the configuration from ground up as if you would have don a gnt-instance shutdown and gnt-instance start on it
+        #
+        # it supports the dry-run argument
+        def instance_reboot(name, type = "soft", ignore_secondaries = 0, dry_run = 0)
+            url = get_url("instances/#{name}/reboot", {"type" => type, "ignore_secondaries" => ignore_secondaries, "dry_run" => 0})
+            response_body = JSON.parse(send_request("POST", url))
+
+            create_class("GanetiInstanceReboot")
+
+            return GanetiIntanceReboot.new(response_body)
+        end
+
+
+        # Instance shutdown URI
+        # Shutdowns an instance
+        # It supports the dry-run argument
+        def instance_shutdown(name, dry_run = 0)
+            url = get_url("instances/#{name}/shutdown", {"dry-run" => dry_run})
+            response_body = JSON.parse(send_request("PUT", url))
+
+            create_class("GanetiInstanceShutdown")
+
+            return GanetiInstanceShutdown.new(response_body)
+        end      
+
+        # Instance startup URI
+        # Startup an instance
+        # The URI takes an optional force=1|0 parameter to start the instance even if secondary disks are failing
+        # It supports the dry-run argument
+        def instance_startup(name, force = 0, dry_run=0)
+            url = get_url("instances/#{name}/startup", {"force" => force, "dry-run" => dry_run})
+            body = "" # force parameter
+            response_body = send_request("PUT", url, body)
+
+            create_class("GanetiInstanceStartup")
+
+            return GanetiInstanceStartup.new(response_body)
+        end
+
+        # Install the operating system again
+        # Takes the parameters os (OS template name) and nostartup (bool)
+        def instance_reinstall(name, os_name, nostartup)
+            url = get_url("instances/#{name}/reinstall", {"os" => os_name, "nostartup" => nostartup})
+            response_body = send_request("POST", url)
+
+            create_class("GanetiInstanceReinstall")
+
+            return GanetiInstanceReinstall.new(response_body)
+        end
+
+        # Replaces disks on an instance
+        # Takes the parameters mode (one of replace_on_primary, replace_on_secondary or replace_auto), disks (comma seperated list of disk indexes), remote_node and iallocator
+        # Either remote_node or iallocator needs to be defined when using mode=replace_new_secondary
+        # mode is a mandatory parameter. replace_auto tries to determine the broken disk(s) on its own and replacing it
+        def instance_replace_disks(name, mode = "replace_auto", iallocator  = "", remote_node = "", disks = "")
+            url = get_url("instances/#{name}/replace-disks", {"mode" => mode, "iallocator" => iallocator, "remote_node" => remote_node, "disks" => disks})
+            response_body = send_request("POST", url)
+
+            return "?"
+        end
+
+        # Activate disks on an instance
+        # Takes the bool parameter ignore_size. When set ignore the recorded size (useful for forcing activation when recoreded size is wrong)
+        def intance_activate_disks(name, ignore_size = 0)
+            url = get_url("instances/#{name}/activate-disks", {"ignore_size" => ignore_size})
+            response_body = send_request("PUT", url)
+
+            return "?"
+        end
+
+        # Deactivate disks on an instance
+        # Takes no parameters
+        def instance_deactivate_disks(name)
+            url = get_url("instances/#{name}/deactivate-disks")
+            response_body = send_request("PUT", url)
+
+            return "?"
+        end
+
+        # Returns a list of tags
+        #
+        # Example:
+        #   ["tag1", "tag2", "tag3"]
+        def instance_get_tags(name)
+            url = get_url("instances/#{name}/tags")
+            response_body = JSON.parse(send_request("GET", url))
+
+            return response_body
+        end
+       
+        # Add a set of tags
+        # The request as a list of strings shoud be PUT tot this URI. The result will be a job id
+        # It supports the dry-run argument
+        def instance_create_tags(name, dry_run = 0)
+            url = get_url("instances/#{name}/tags", {"dry-run" => dry_run})
+            response_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+        # Delete a tag
+        # In order to delete a set of tags, the DELETE request sould be addressed to URI LIKE:
+        #   /tags?tag=[tag]&tag=[tag]
+        # It supports the dry-run argument
+        def instance_delete_tags(name, dry_run = 0)
+            url = get_url("instances/#{name}/tags", {"dry-run" => dry_run})
+            response_body = send_request("DELETE", url)
+
+            return "?"
+        end
+
+        # Returns a dictionary of jobs
+        # Returns: a dictionary with jobs id and uri
+        def jobs_get
+            url = get_url("jobs")
+            response_body = JSON.parse(send_request("GET", url))
+        
+            create_class("GanetiJob")
+
+            list = Array.new
+            response_body.each { |item| list << GanetiJob.new(item) } 
+            
+            return list
+        end      
+
+        # Individual job URI
+        # Return a job status
+        # Returns: a dictionary with job parameters
+        #
+        # The result includes:
+        #   id: job ID as number
+        #   status: current job status as a string
+        #   ops: involved OpCodes as a list of dictionaries for each opcodes in the job
+        #   opstatus: OpCodes status as a list
+        #   opresult: OpCodes results as a list
+        #
+        # For a successful opcode, the opresult field corresponding to it will contain the raw result from its LogicalUnit. In case an opcode has failed, its element in the opresult list will be a list of two elements:
+        #   first element the error type (the Ganeti internal error name)
+        #   second element a list of either one or two elements:
+        #   the first element is the textual error description
+        #   the second element, if any, will hold an error classification
+        # 
+        # The error classification is most useful for the OpPrereqError error type - these errors happen before the OpCode has started executing, so it’s possible to retry the 
+        # OpCode without side effects. But whether it make sense to retry depends on the error classification:
+        # 
+        #   resolver_error
+        #       Resolver errors. This usually means that a name doesn’t exist in DNS, so if it’s a case of slow DNS propagation the operation can be retried later.
+        #
+        #   insufficient_resources
+        #       Not enough resources (iallocator failure, disk space, memory, etc.). If the resources on the cluster increase, the operation might succeed.
+        #
+        #   wrong_input
+        #       Wrong arguments (at syntax level). The operation will not ever be accepted unless the arguments change.
+        #
+        #   wrong_state
+        #       Wrong entity state. For example, live migration has been requested for a down instance, or instance creation on an offline node. The operation can be retried once the resource has changed state.
+        #   
+        #   unknown_entity
+        #       Entity not found. For example, information has been requested for an unknown instance.
+        #
+        #   already_exists
+        #       Entity already exists. For example, instance creation has been requested for an already-existing instance.
+        #
+        #   resource_not_unique
+        #       Resource not unique (e.g. MAC or IP duplication).
+        #    
+        #   internal_error
+        #       Internal cluster error. For example, a node is unreachable but not set offline, or the ganeti node daemons are not working, etc. A gnt-cluster verify should be run.
+        #    
+        #   environment_error
+        #       Environment error (e.g. node disk error). A gnt-cluster verify should be run.
+        #
+        # Note that in the above list, by entity we refer to a node or instance, while by a resource we refer to an instance’s disk, or NIC, etc.
+        def job_get(job_id)
+            url = get_url("jobs/#{job_id}")
+            response_body = JSON.parse(send_request("GET", url))
+
+            create_class("GanetiJob")
+
+            return GanetiJob.new(response_body)
+        end
+
+        # Cancel a not-yet-started job
+        def job_delete(job_id)
+            url = get_url("jobs/#{job_id}")
+            response = send_request("DELETE", url)
+
+            return "?"
+        end
+
+        # Nodes resource
+        # Returns a list of all nodes
+        # If the optional ‘bulk’ argument is provided and set to ‘true’ value (i.e ‘?bulk=1’).
+        #
+        # Returns detailed information about nodes as a list.
+        def nodes_get(bulk = 0)
+            url = get_url("nodes", {"bulk", bulk})
+            response_body = JSON.parse(send_request("GET", url))
+
+            create_class("GanetiNode")
+
+            list = Array.new
+            response_body.each { |item| list << GanetiNode.new(item) }
+
+            return list 
+        end
+
+        # Returns information about a node
+        def node_get(name)
+            url = get_url("nodes/#{name}")
+            response_body = JSON.parse(send_request("GET", url))
+
+            create_class("GanetiNode")
+
+            return GanetiNode.new(response_body)
+        end
+
+        # Evacuates all secondary instances off a node.
+        # To evacuate a node, either one of the iallocator or remote_node parameters must be passed:
+        #
+        # Example:
+        #   evacuate?iallocator=[iallocator]
+        #   evacuate?remote_node=[nodeX.example.com]
+        def node_evauate(name, iallocator = "", remote_node = "")
+           url = get_url("nodes/#{name}/evacuate", {"iallocator" => iallocator, "remote_node" => remote_node}) 
+           response_body = send_request("POST", url)
+
+           return "?"
+        end
+
+        # Migrates all primary instances of a node
+        # No parameters are required, but the bool parameter live can be set to use live migration (if available)
+        # 
+        # Example:
+        #   migrate?live=[0|1]
+        def node_migrate(name, live = 0)
+            url = get_url("nodes/#{name}/migrate", {"live" => live})
+            response_body = send_request("POST", url)
+
+            return "?"
+        end
+
+        # Get the node role
+        # Returns the current node role
+        #
+        # Example:
+        #   "master-candidate"
+        #
+        # The rol is always one of the following:
+        #   drained
+        #   master
+        #   master-candidate
+        #   offline
+        #   regular
+        def node_get_role(name)
+            url = get_url("nodes/#{name}/role")
+            response_body = send_request("GET", url)
+
+            return response_body
+        end
+
+        # Change the node role
+        # the request is a string which shoud be PUT to this URI. The result will be a job id
+        # It supports the bool force argument
+        #
+        # The rol is always one of the following:
+        #   drained
+        #   master
+        #   master-candidate
+        #   offline
+        #   regular
+        def node_change_role(name, role, force = 0)
+            url = get_url("nodes/#{name}/role", {"role" => role, "force" => foce})
+            response_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+        # Manages storage units on the node
+        # Requests a list of storage units on a node. Requires the parameters storage_type (one of file, lvm-pv or lvm-vg) and output_fields. The result will be a job id, using which the result can be retrieved
+        def node_get_storage(name, storage_type = "", output_fields = "")
+            url = get_url("nodes/#{name}/storage", {"storage_type" => storage_type, "output_fields" => output_fields})
+            response_body = send_request("GET", url)
+
+            return response_body
+        end
+
+        # Modify storage units on the node
+        # Mofifies parameters of storage units on the node. Requires the parameters storage_type (one of file, lvm-pv or lvm-vg) and name (name of the storage unit). 
+        # Parameters can be passed additionally. Currently only allocatable (bool) is supported. 
+        #
+        # The result will be a job id.
+        def node_modify_storage(name, storage_type, allocatable = 0)
+            url = get_url("nodes/#{name}/storage/modify", {"storage_type" => storage_type, "allocatable" => allocatable})
+            response_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+
+        # Repairs a storage unit on the node. Requires the parameters storage_type (currently only lvm-vg can be repaired) and name (name of the storage unit).
+        #
+        # The result will be a job id
+        def node_repair_storage(name, storage_type = "lvm-vg")
+            url = get_url("nodes/#{name}/storage/repair", {"storage_type" => storage_type})
+            reponse_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+
+        # Manages per-node tags
+        # Returns a list of tags
+        #
+        # Example:
+        #   ["tag1","tag2", "tag3"]
+        def node_get_tags(name)
+            url = get_url("nodes/#{name}/tags")
+            response_body = send_request("GET", url)
+
+            return response_body
+        end
+
+        # Add a set of tags
+        # The request as a list of strings should be PUT to this URI.
+        # It supports the dry-run argument
+        #
+        # The result will be a job id
+        def node_create_tags(name, tags, dry_run = 0)
+            url = get_url("nodes/#{name}/tags", {"tags" => tags, "dry-run" => dry_run})
+            response_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+        # Deletes tags
+        # In order to delete a set of tags, the DELETE request should be addressed to URI like:
+        #   /tags?tag=[tag]&tag=[tag]
+        #
+        # It supports the dry-run argument
+        def node_delete_tags(name, tags, dry_run = 0)
+            url = get_url("nodes/#{name}/tags", {"tags" => targs, "dry-run" => dry_run})
+            response_body = send_request("DELETE", url)
+
+            return response_body
+        end
+
+        # OS resource
+        # Returns a list of all OSes
+        # 
+        # Can return error 500 in case of a problem. Since this is a costly operation for Ganeti 2.0, it is not recommented to execute it too often
+        #
+        # Example:
+        #   ["debian-etch"]
+        def os_list_get
+            url = get_url("os")
+            response_body = JSON.parse(send_request("GET", url))
+
+            return response_body
+        end
+
+        # Manages cluster tags
+        # Returns the cluster tags
+        #
+        # Example:
+        #   ["tag1", "tag2", "tag3"]
+        def tags_get
+            url = get_url("tags")
+            response_body = JSON.parse(send_request("GET", url))
+
+            return response_body
+        end
+
+        # Adds a set of tags
+        # The request as a list of strings should be PUT to this URI. The result will be a job id
+        #
+        # It supports the dry-run argument
+        def tags_create(tags, dry_run = 0)
+            url = get_url("tags", {"tags" => tags, "dry-run" => dry_run})
+            response_body = send_request("PUT", url)
+
+            return response_body
+        end
+
+        # Deletes tags
+        # In order to delete a set of tags, the DELETE request should be addressed to URI like:
+        #   /tags?tag=[tag]&tag=[tag]
+        #
+        # It supports the dry-run argument
+        def tags_delete(tags, dry_run = 0)
+            url = get_url("tags", {"tags" => tags, "dry-run" => dry_run})
+            response_body = send_request("DELETE", url)
+
+            return response_body
+        end
+
+
+        # The version resource
+        # This resource should be used to determine the remote API version and to adapt client accordingly
+        # Returns the remote API version. Ganeti 1.2 returns 1 and Ganeti 2.0 returns 2
+        def version_get
+            url = get_url("version")
+            response_body = send_request("GET", url)
+            
+            return response_body
+        end
+
+
+        private
+
+        def authenticate(username, password)
+            basic = Base64.b64encode("#{username}:#{password}") 
+            headers = {'Authorization' => "Basic #{basic}"}
+        
+            return headers         
+        end
+    
+        def get_url(path, params = nil)
+            param_string = ""
+
+            if params
+                params.each do |key, value|
+                    if value.kind_of?(Array)
+                        value.each do |svalue|
+                            param_string += "#{key}=#{svalue}"
+                        end
+                    else
+                        param_string += "#{key}=#{value}&"
+                    end
+                end
+            end
+            return (self.version)? "/#{self.version}/#{path}?#{param_string}" : "/#{path}?#{param_string}"
+        end
+
+        def send_request(method, url, body = nil)
+            response = self.conn.send_request(method, url, body)
+
+            puts "Response #{response.code} #{response.message}: #{response.body}" if self.show_reponse
+            return response.body.strip
+        end
+
+        def create_class(class_name)
+            unless(class_exists?(class_name))
+                klass = Class.new GanetiClient::GanetiObject
+                Object.const_set(class_name, klass)
+            end
+        end
+
+        def class_exists?(class_name)
+            klass = Module.const_get(class_name)
+            return klass.is_a?(Class)
+        rescue NameError
+            return false
+        end
+    end
+end

data/lib/ganeti_client/ganeti_object.rb

@@ -0,0 +1,16 @@
+module GanetiClient
+    class GanetiObject
+    
+        attr_accessor :json_object
+
+        def initialize(json = {})
+            self.json_object = json
+            
+            json.each { |attr_name, attr_value| self.class.send(:define_method, attr_name.to_sym){ return attr_value } }
+        end
+
+        def to_json
+            return self.json_object
+        end
+    end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: ganeti_client
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Micha\xC3\xABl Rigart"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-15 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Google Ganeti RAPI client for Ruby
+email: michael@netronix.be
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- lib/ganeti_client.rb
+- lib/ganeti_client/client.rb
+- lib/ganeti_client/ganeti_object.rb
+has_rdoc: true
+homepage: http://www.netronix.be
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: nowarning
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Google Ganeti Client
+test_files: []
+