studio_api 2.3.0

data/lib/studio_api/file.rb

@@ -0,0 +1,70 @@
+require "studio_api/studio_resource"
+require "cgi"
+module StudioApi
+  # Represents overlay files which can be loaded to appliance.
+  # 
+  # Supports finding files for appliance, updating metadata, deleting, uploading and downloading.
+  # 
+  # @example Find files for appliance
+  # StudioApi::File.find :all, :params => { :appliance_id => 1234 }
+  #
+  # @example Upload file Xorg.conf
+  #   File.open ("/tmp/xorg.conf) { |file|
+  #     StudioApi::File.upload file, 1234, :path => "/etc/X11", 
+  #                         :filename => "Xorg.conf", :permissions => "0755",
+  #                         :owner => "root"
+  #   }
+  #
+  # @example Update metadata
+  # file = StudioApi::File.find 1234
+  # file.owner = "root"
+  # file.path = "/etc"
+  # file.filename = "pg.conf"
+  # file.save
+
+  class File < ActiveResource::Base
+    extend StudioResource
+    self.element_name = "file"
+
+    # Downloads file to output. Allow downloading to stream or to path.
+    # @return [String] content of file
+    def content
+      rq = GenericRequest.new self.class.studio_connection
+      rq.get "/files/#{id.to_i}/data"
+    end
+
+    # Overwritte file content and keep metadata ( of course without such things like size )
+    # Immediatelly store new content
+    # @param (File,#to_s) input new content for file as String or open file
+    # @return [StudioApi::File] self with updated metadata
+    def overwrite ( content )
+      request_str = "/files/#{id.to_i}/data"
+      rq = GenericRequest.new self.class.studio_connection
+      response = rq.put request_str, :file => content
+      load Hash.from_xml(response)["file"]
+    end
+
+    # Uploads file to appliance
+    # @param (String,File) content as String or as opened File 
+    #   ( in this case its name is used as default for uploaded file name)
+    # @param (#to_i) appliance_id id of appliance where to upload
+    # @param (Hash<#to_s,#to_s>) options optional parameters, see API documentation
+    # @return [StudioApi::File] metadata of uploaded file
+    def self.upload ( content, appliance_id, options = {})
+      request_str = "files?appliance_id=#{appliance_id.to_i}"
+      options.each do |k,v|
+        request_str << "&#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+      end
+      rq = GenericRequest.new studio_connection
+      response = rq.post request_str, :file => content
+      File.new Hash.from_xml(response)["file"]
+    end
+
+private 
+    # file uses for update parameter put
+    # @private
+    def new?
+      false
+    end
+  end
+end

data/lib/studio_api/generic_request.rb

@@ -0,0 +1,160 @@
+#
+#  Copyright (c) 2010 Novell, Inc.
+#  All Rights Reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public License as
+#  published by the Free Software Foundation; version 2.1 of the license.
+#
+#  This library 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 Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this library; if not, contact Novell, Inc.
+#
+#  To contact Novell about this file by physical or electronic mail,
+#  you may find current contact information at www.novell.com
+
+require 'xmlsimple'
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'net/https'
+require 'active_support'
+require 'active_resource/formats'
+require 'active_resource/connection'
+
+require 'studio_api/util'
+
+module StudioApi
+  # Class which use itself direct connection to studio for tasks where
+  # ActiveResource is not enough. For consistent api is all network exceptions
+  # mapped to ones used in ActiveResource.
+  #
+  # @example
+  #   rq = StudioApi::GenericRequest.new @connection
+  #   rq.get "/appliances"
+  #   rq.post "/file", :file => "/etc/config"
+  class GenericRequest
+    # Creates new instance of request for given connection
+    # @param (StudioApi::Connection) connection information about connection
+    def initialize(connection)
+      @connection = connection
+      if connection.proxy
+        proxy = connection.proxy
+        @http = Net::HTTP.new(connection.uri.host, connection.uri.port,
+            proxy.host, proxy.port, proxy.user, proxy.password)
+      else
+        @http = Net::HTTP.new(connection.uri.host, connection.uri.port)
+      end
+      @http.read_timeout = connection.timeout
+      if connection.uri.scheme == "https"
+        @http.use_ssl = true
+        Connection::SSL_ATTRIBUTES.each do |attr|
+          @http.send :"#{attr}=", connection.ssl[attr.to_sym] if connection.ssl[attr.to_sym]
+        end
+      end
+    end
+
+    # sends get request
+    # @param (String) path relative path from api root
+    # @return (String) response body from studio
+    # @raise [ActiveResource::ConnectionError] when problem occur during connection
+    def get(path)
+      do_request Net::HTTP::Get.new Util.join_relative_url @connection.uri.request_uri,path
+    end
+
+    # sends delete request
+    # @param (String) path relative path from api root
+    # @return (String) response body from studio
+    # @raise [ActiveResource::ConnectionError] when problem occur during connection
+    def delete(path)
+      #Even it is not dry I want to avoid meta programming with dynamic code evaluation so code is clear
+      do_request Net::HTTP::Delete.new Util.join_relative_url @connection.uri.request_uri,path
+    end
+
+    # sends post request
+    # @param (String) path relative path from api root
+    # @param (Hash<#to_s,#to_s>,Hash<#to_s,#path>) data hash containing data to attach to body
+    # @return (String) response body from studio
+    # @raise [ActiveResource::ConnectionError] when problem occur during connection
+    def post(path,data={})
+      request = Net::HTTP::Post.new Util.join_relative_url @connection.uri.request_uri,path
+      set_data(request,data) unless data.empty?
+      do_request request
+    end
+
+    # sends post request
+    # @param (String) path relative path from api root
+    # @param (Hash<#to_s,#to_s>,Hash<#to_s,#path>) data hash containing data to attach to body
+    # @return (String) response body from studio
+    # @raise [ActiveResource::ConnectionError] when problem occur during connection
+    def put(path,data={})
+      request = Net::HTTP::Put.new Util.join_relative_url @connection.uri.request_uri,path
+      set_data(request,data) unless data.empty?
+      do_request request
+    end
+
+  private
+    def do_request(request)
+      request.basic_auth @connection.user, @connection.password
+      @http.start() do
+        response = @http.request request
+        unless response.kind_of? Net::HTTPSuccess
+          msg = error_message response
+          create_active_resource_exception response,msg
+        end
+        response.body
+      end
+    end
+
+      #XXX not so nice to use internal method, but better to be DRY and proper test if it works with supported rails
+    def create_active_resource_exception response,msg
+      response.instance_variable_set "@message",msg
+      ActiveResource::Connection.new('').send :handle_response, response
+    end
+
+    def error_message response
+      xml_parsed = XmlSimple.xml_in(response.body, {'KeepRoot' => true})
+      raise "Unknown error response from Studio: #{response.body}" unless xml_parsed['error']
+      msg = ""
+      xml_parsed['error'].each() {|error| msg << error['message'][0]+"\n" }
+      return msg
+    rescue RuntimeError
+      return response.message+"\n"+response.body
+    end
+
+    def set_data(request,data)
+      boundary = Time.now.to_i.to_s(16)
+      request["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+      body = ""
+      data.each do |key,value|
+        esc_key = CGI.escape(key.to_s)
+        body << "--#{boundary}\r\n"
+        if value.respond_to?(:read) && value.respond_to?(:path)
+          # ::File is needed to use "Ruby" file instead this one
+          body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{::File.basename(value.path)}\"\r\n"
+          body << "Content-Type: #{mime_type(value.path)}\r\n\r\n"
+          body << value.read
+        else
+          body << "Content-Disposition: form-data; name=\"#{esc_key}\"\r\n\r\n#{value}"
+        end
+        body << "\r\n"
+      end
+      body << "--#{boundary}--\r\n\r\n"
+      request.body = body
+      request["Content-Length"] = request.body.size
+    end
+
+    def mime_type(file)
+      case
+        when file =~ /\.jpe?g\z/i then 'image/jpg'
+        when file =~ /\.gif\z/i then 'image/gif'
+        when file =~ /\.png\z/i then 'image/png'
+        else 'application/octet-stream'
+      end
+    end
+  end
+end

data/lib/studio_api/package.rb

@@ -0,0 +1,12 @@
+module StudioApi
+  # Represents package in appliance. Used mainly as data storage.
+  class Package
+    attr_accessor :name, :version, :repository_id, :arch, :checksum, :checksum_type
+    def initialize name, attributes = {}
+      @name = name
+      attributes.each do |k,v|
+        instance_variable_set "@#{k}", v
+      end
+    end
+  end
+end

data/lib/studio_api/pattern.rb

@@ -0,0 +1,12 @@
+module StudioApi
+  # Represents pattern in appliance. Used mainly as data storage.
+  class Pattern
+    attr_accessor :name, :version, :repository_id, :arch
+    def initialize name, attributes = {}
+      @name = name
+      attributes.each do |k,v|
+        instance_variable_set "@#{k}", v
+      end
+    end
+  end
+end

data/lib/studio_api/repository.rb

@@ -0,0 +1,35 @@
+require "studio_api/studio_resource"
+module StudioApi
+  # Represents available repositories for appliance.
+  #
+  # Allows finding and importing repositories.
+  # When using find :all then there is optional parameters for base_system and filter
+  # 
+  # @example Find repository with kde for SLE11
+  #   StudioApi::Repository.find :all, :params => { :base_system => "sle11", :filter => "kde" }
+
+  class Repository < ActiveResource::Base
+    extend StudioResource
+
+    undef_method :save #save is useless there
+    undef_method :destroy #not allowed
+
+    # Import new repository to Studio 
+    #
+    # note: Repository will be available to everyone
+    # @param (#to_s) url to repository
+    # @param (#to_s) name of created repository
+    # @return [StudioApi::Repository] imported repository
+    def self.import (url, name)
+      response = post '',:url => url, :name => name
+      attrs = Hash.from_xml response.body
+      Repository.new attrs["repository"]
+    end
+private
+#handle special studio collection method for import
+    def self.custom_method_collection_url(method_name, options = {})
+      prefix_options, query_options = split_options(options)
+      "#{prefix(prefix_options)}#{collection_name}#{query_string(query_options)}"
+    end
+  end
+end

data/lib/studio_api/rpm.rb

@@ -0,0 +1,33 @@
+require "studio_api/studio_resource"
+require 'cgi'
+
+module StudioApi
+  # Represents Additional rpms which can user upload to studio.
+  # 
+  # Allows uploading, downloading, listing (via find) and deleting
+  # 
+  # @example Delete own rpm
+  #   rpms = StudioApi::Rpm.find :all, :params => { :base_system => "SLE11" }
+  #   my_pac = rpms.find {|r| r.filename =~ /my_pac/ }
+  #   my_pac.delete
+  class Rpm < ActiveResource::Base
+    extend StudioResource
+    undef_method :save
+
+    self.element_name = "rpm"
+    # Upload file to studio account (user repository)
+    # @param (String,File) content of rpm as String or as opened file, in which case name is used as name
+    # @param (#to_s) base_system for which is rpm compiled
+    # @return [StudioApi::Rpm] uploaded RPM
+    def self.upload content, base_system
+      response = GenericRequest.new(studio_connection).post "/rpms?base_system=#{CGI.escape base_system.to_s}", :file => content
+      self.new Hash.from_xml(response)["rpm"]
+    end
+
+    # Downloads file to specified path.
+    # @return [String] content of rpm
+    def content
+      GenericRequest.new(self.class.studio_connection).get "/rpms/#{id.to_i}/data"
+    end
+  end
+end

data/lib/studio_api/running_build.rb

@@ -0,0 +1,35 @@
+require "studio_api/studio_resource"
+
+require "cgi"
+
+module StudioApi
+  # Represents running build in studio.
+  #
+  # Provide finding builds, canceling build process or running new build
+  # For parameters see API documentation
+  # @example Run new build and then cancel it
+  #   rb = StudioApi::RunningBuild.new(:appliance_id => 1234, :force => "true", :multi => "true")
+  #   rb.save!
+  #   sleep 5
+  #   rb.cancel
+  class RunningBuild < ActiveResource::Base
+    extend StudioResource
+
+    self.element_name = "running_build"
+
+    alias_method :cancel, :destroy
+
+private
+    #overwrite create as studio doesn't interact well with enclosed parameters
+    def create
+      request_str = collection_path
+      request_str << "?appliance_id=#{attributes.delete("appliance_id").to_i}"
+      attributes.each do |k,v|
+        request_str << "&#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+      end
+      connection.post(request_str,"",self.class.headers).tap do |response|
+        load_attributes_from_response response
+      end
+    end
+  end
+end

data/lib/studio_api/studio_resource.rb

@@ -0,0 +1,70 @@
+require "rubygems"
+require 'active_resource'
+require "studio_api/util"
+require "studio_api/studio_resource"
+
+module StudioApi
+  # Adds ability to ActiveResource::Base (short as ARes) to easy set connection to studio in 
+  # dynamic way, which is not so easy as ARes is designed for static values.
+  # Also modify a few expectation of ActiveResource to fit studio API ( like
+  # missing xml suffix in calls ).
+  # 
+  # @example Add new Studio Resource
+  #   # enclose it in module allows to automatic settings with Util
+  #   module StudioApi
+  #     class NewCoolResource < ActiveResource::Base
+  #       extend StudioResource
+  #     end
+  #   end
+
+  module StudioResource
+    # Gets studio connection. Mostly useful internally.
+    # @return (StudioApi::Connection,nil) object of studio connection or nil if not
+    # yet set
+    def studio_connection
+      @studio_connection
+    end
+
+    # Takes information from connection and sets it to ActiveResource::Base.
+    # Also take care properly of prefix as it need to join path from site with
+    # api prefix like appliance/:appliance_id .
+    # @param (StudioApi::Connection) connection source for connection in
+    #   activeResource
+    # @return (StudioApi::Connection) unmodified parameter
+    def studio_connection= connection
+      self.site = connection.uri.to_s
+      # there is general problem, that when specified prefix in model, it doesn't
+      # contain uri.path as it is not know and uri is set during runtime, so we
+      # must add here manually adapt prefix otherwise site.path is ommitted in
+      # models which has own prefix in API
+      unless @original_prefix
+        if self.prefix_source == Util.join_relative_url(connection.uri.path,'/')
+          @original_prefix = "/"
+        else
+          @original_prefix = self.prefix_source
+        end
+      end
+      self.prefix = Util.join_relative_url connection.uri.path, @original_prefix
+      self.user = connection.user
+      self.password = connection.password
+      self.timeout = connection.timeout
+      self.proxy = connection.proxy.to_s if connection.proxy
+      self.ssl_options = connection.ssl
+      @studio_connection = connection
+    end
+
+    # We need to overwrite the paths methods because susestudio doesn't use the
+    # standard .xml filename extension which is expected by ActiveResource.
+    def element_path(id, prefix_options = {}, query_options = nil)
+      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+      "#{prefix(prefix_options)}#{collection_name}/#{id}#{query_string(query_options)}"
+    end
+
+    # We need to overwrite the paths methods because susestudio doesn't use the
+    # standard .xml filename extension which is expected by ActiveResource.
+    def collection_path(prefix_options = {}, query_options = nil)
+      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+      "#{prefix(prefix_options)}#{collection_name}#{query_string(query_options)}"
+    end
+  end
+end

data/lib/studio_api/template_set.rb

@@ -0,0 +1,12 @@
+require "studio_api/studio_resource"
+
+module StudioApi
+  # Represents template sets. It is usefull when clone appliance.
+  # allows only reading
+  class TemplateSet < ActiveResource::Base
+    extend StudioResource
+    undef_method :save
+    undef_method :destroy
+    element_name = "template_set"
+  end
+end

data/lib/studio_api/util.rb

@@ -0,0 +1,38 @@
+module StudioApi
+  # Utility class for handling whole stack of Studio Api
+  class Util
+    # Set connection for all StudioApi class, so then you can use it without explicit settings
+    # It is useful when program use only one studio credentials
+    # @example
+    #   connection = StudioApi::Connection.new ( "user", "password", "http://localhost/api")
+    #   StudioApi::Util.configure_studio_connection connection
+    #   appliances = StudioApi::Appliance.find :all
+    # @param [StudioApi::Connection] connection which is used for communication with studio
+    # @return [Array<Class>] return set of classes which is set
+
+    def self.configure_studio_connection connection
+      classes = get_all_usable_class StudioApi
+      classes.each {|c| c.studio_connection = connection}
+    end
+
+    # joins relative url for unix servers as URI.join require at least one
+    # absolute adress. Especially take care about only one slash otherwise studio
+    # returns 404.
+    # @param (Array<String>) args list of Strings to join
+    # @return (String) joined String
+    def self.join_relative_url(*args)
+      args.reduce do |base, append|
+        base= base[0..-2] if base.end_with? "/" #remove ending slash in base
+        append = append[1..-1] if append.start_with? "/" #remove leading slash in append
+        "#{base}/#{append}"
+      end
+    end
+private
+    def self.get_all_usable_class (modul)
+      classes = modul.constants.collect{ |c| modul.const_get(c) }
+      classes = classes.select { |c| c.class == Class && c.respond_to?(:studio_connection=) }
+      inner_classes = classes.collect { |c| get_all_usable_class(c) }.flatten
+      classes + inner_classes
+    end
+  end
+end

data/lib/studio_api.rb

@@ -0,0 +1,31 @@
+#
+#  Copyright (c) 2009 Novell, Inc.
+#  All Rights Reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public License as
+#  published by the Free Software Foundation; version 2.1 of the license.
+#
+#  This library 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 Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this library; if not, contact Novell, Inc.
+#
+#  To contact Novell about this file by physical or electronic mail,
+#  you may find current contact information at www.novell.com
+
+require 'studio_api/appliance'
+require 'studio_api/build'
+require 'studio_api/connection'
+require 'studio_api/file'
+require 'studio_api/generic_request'
+require 'studio_api/package'
+require 'studio_api/pattern'
+require 'studio_api/repository'
+require 'studio_api/rpm'
+require 'studio_api/running_build'
+require 'studio_api/studio_resource'
+require 'studio_api/template_set'