aeolus-image 0.0.1 → 0.4.0

data/lib/aeolus_image/model/warehouse/target_image.rb

@@ -0,0 +1,53 @@
+#   Copyright 2011 Red Hat, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module Aeolus
+  module Image
+    module Warehouse
+      class TargetImage < WarehouseModel
+        @bucket_name = 'target_images'
+
+        def build
+          ImageBuild.find(@build) if @build
+        end
+
+        def provider_images
+          ProviderImage.where("($target_image == \"" + @uuid.to_s + "\")")
+        end
+
+        def target_template
+          Template.find(@template) if @template
+        end
+
+        # Deletes this targetimage and all child objects
+        def delete!
+          begin
+            provider_images.each do |pi|
+              pi.delete!
+            end
+          rescue NoMethodError
+          end
+          TargetImage.delete(@uuid)
+        end
+
+        def find_provider_image_by_provider_and_account(provider, provider_account)
+          conditions = ["$target_image == \"#{@uuid}\""]
+          conditions << "$provider == \"#{provider}\"" if provider
+          conditions << "$provider_account_identifier == \"#{provider_account}\"" if provider_account
+          ProviderImage.where('(' + conditions.join(' && ') + ')')
+        end
+      end
+    end
+  end
+end

data/lib/aeolus_image/model/warehouse/template.rb

@@ -0,0 +1,35 @@
+#   Copyright 2011 Red Hat, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module Aeolus
+  module Image
+    module Warehouse
+      class Template < WarehouseModel
+        attr_reader :xml_body
+
+        @bucket_name = 'templates'
+
+        def initialize(obj)
+          super
+          @body = obj.body
+          @xml_body = Nokogiri::XML @body
+        end
+
+        def name
+          @name ||= @xml_body.xpath("/template/name").text
+        end
+      end
+    end
+  end
+end

data/lib/aeolus_image/model/warehouse/warehouse_client.rb

@@ -0,0 +1,201 @@
+#   Copyright 2011 Red Hat, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+require 'rubygems'
+
+require 'rest-client'
+require 'nokogiri'
+require 'oauth'
+
+#TODO: perform iwhd version-dependent URI mapping
+module Aeolus
+  module Image
+    module Warehouse
+      class BucketObject
+        attr_reader :key
+
+        def initialize(connection, key, bucket)
+          @connection = connection
+          @key = key
+          @bucket = bucket
+          @path = "/#{@bucket.name}/#{@key}"
+        end
+
+        def self.create(connection, key, bucket, body, attrs = {})
+          obj = new(connection, key, bucket)
+          obj.set_body(body)
+          obj.set_attrs(attrs)
+          obj
+        end
+
+        def body
+          @connection.do_request @path, :plain => true
+        end
+
+        def set_body(body)
+          @connection.do_request @path, :content => body, :method => :put
+        end
+
+        def attr_list
+          result = @connection.do_request @path, :content => 'op=parts', :method => :post
+          return result.xpath('/object/object_attr/@name').to_a.map {|item| item.value}
+        end
+
+        def attrs(list)
+          attrs = {}
+          list.each do |att|
+            next if att.match('-')
+            attrs[att] = (@connection.do_request("#{@path}/#{att}", :plain => true) rescue nil)
+          end
+          attrs
+        end
+
+        def attr(name)
+          attrs([name])[name]
+        end
+
+        def set_attrs(hash)
+          hash.each do |name, content|
+            set_attr(name, content)
+          end
+        end
+
+        def set_attr(name, content)
+          path = "#{@path}/#{name}"
+          @connection.do_request path, :content => content, :method => :put
+        end
+
+        def delete!
+          @connection.do_request @path, :method => :delete
+          true
+        end
+
+      end
+
+      class Bucket
+        attr_accessor :name
+
+        def initialize(name, connection)
+          @name = name
+          @connection = connection
+        end
+
+        def to_s
+          "Bucket: #{@name}"
+        end
+
+        def object_names
+          result = @connection.do_request "/#{@name}"
+          result.xpath('/objects/object').map do |obj|
+            obj.at_xpath('./key/text()').to_s
+          end
+        end
+
+        def objects
+          object_names.map do |name|
+            object(name)
+          end
+        end
+
+        def object(key)
+          BucketObject.new @connection, key, self
+        end
+
+        def create_object(key, body, attrs)
+          BucketObject.create(@connection, key, self, body, attrs)
+        end
+
+        def include?(key)
+          object_names.include?(key)
+        end
+      end
+
+      class Connection
+        attr_accessor :uri
+
+        def initialize(uri)
+          @uri = uri
+          if WarehouseModel.use_oauth? && WarehouseModel.iwhd_url && uri.match(WarehouseModel.iwhd_url)
+            @consumer = OAuth::Consumer.new(
+              WarehouseModel.oauth_consumer_key,
+              WarehouseModel.oauth_consumer_secret,
+              :site => WarehouseModel.iwhd_url
+            )
+            @token = OAuth::AccessToken.new(@consumer)
+          end
+        end
+
+        def do_request(path = '/', opts={})
+          opts[:method]  ||= :get
+          opts[:content] ||= ''
+          opts[:plain]   ||= false
+          opts[:headers] ||= {}
+
+          # Using restclient seems to break OAuth POSTs, so use the oauth gem directly if we're using OAuth:
+          if @token
+            # TODO - I'm not sure how to pass :headers through here, but we don't actually use them anywhere
+            response = @token.request(opts[:method], (@uri + path).to_s, opts[:content].to_s)
+            # Errors don't cause exceptions like they do with RestClient, so detect and raise them:
+            if response.is_a?(Net::HTTPSuccess)
+              result = response.body
+            # Translate a few common errors to their RestClient counterparts that we're used to checking for:
+            elsif response.is_a?(Net::HTTPNotFound)
+              raise RestClient::ResourceNotFound
+            elsif response.is_a?(Net::HTTPInternalServerError)
+              raise RestClient::InternalServerError
+            # Otherwise, raise the error:
+            else
+              response.error!
+            end
+          else # no @token -- use RestClient
+            result = RestClient::Request.execute(:method => opts[:method], :url => @uri + path, :payload => opts[:content], :headers => opts[:headers])
+          end
+          return opts[:plain] ? result : Nokogiri::XML(result)
+        end
+      end
+
+      class Client
+
+        def initialize(uri)
+          @connection = Connection.new(uri)
+        end
+
+        def create_bucket(bucket)
+          @connection.do_request("/#{bucket}", :method => :put) rescue RestClient::InternalServerError
+          Bucket.new(bucket, @connection)
+        end
+
+        def bucket(bucket)
+          Bucket.new bucket, @connection
+        end
+
+        def buckets
+          @connection.do_request.xpath('/api/link[@rel="bucket"]').map do |obj|
+            obj.at_xpath('./@href').to_s.gsub(/.*\//, '')
+          end
+        end
+
+        def get_iwhd_version
+          result = @connection.do_request.at_xpath('/api[@service="image_warehouse"]/@version')
+          raise "Response does not contain <api> tag or version information" if result == nil
+          return result.value
+        end
+
+        def query(bucket_name, query_string)
+          @connection.do_request "/#{bucket_name}/_query", {:method => :post, :content => query_string}
+        end
+      end
+    end
+  end
+end

data/lib/aeolus_image/model/warehouse/warehouse_model.rb

@@ -0,0 +1,236 @@
+#   Copyright 2011 Red Hat, Inc.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+module Aeolus
+  module Image
+    module Warehouse
+      class BucketObjectNotFound < Exception;end
+      class BucketNotFound < Exception;end
+
+      class WarehouseModel
+        attr_writer :body
+
+        def initialize(obj)
+          @obj = obj
+          @attrs = obj.attrs(obj.attr_list)
+          @attrs.each do |k,v|
+            self.class.send(:attr_writer, k.to_sym) unless respond_to?(:"#{k}=")
+            self.class.send(:attr_reader, k.to_sym) unless respond_to?(k.to_sym)
+            send(:"#{k}=", v)
+          end
+        end
+
+        def body
+          @obj.body
+        end
+
+        def ==(other_obj)
+          # If the objects have different instance variables defined, they're definitely not ==
+          return false unless instance_variables.sort == other_obj.instance_variables.sort
+          # Otherwise, ensure that they're all the same
+          instance_variables.each do |iv|
+            next if iv == "@obj" || iv == :@obj
+            return false unless other_obj.instance_variable_get(iv) == instance_variable_get(iv)
+            return false unless other_obj.body == body
+          end
+          # They have the same instance variables and values, so they're equal
+          true
+        end
+
+        def id
+          uuid
+        end
+
+        # Returns the bucket object represending this object
+        def bucket_object
+          @obj
+        end
+
+        # Set (and immediately update) an attribute on the object
+        # TODO: It might be nicer to offer a .save! that iterates over each attribute
+        # and calls this, to better match ActiveResource
+        def set_attr(key, value)
+          bucket_object.set_attr(key, value)
+        end
+
+
+        class << self
+          attr_accessor :warehouse, :bucket, :bucket_name
+
+          def set_warehouse_and_bucket
+            begin
+              @@config ||= load_config
+              self.warehouse = Warehouse::Client.new(@@config[:iwhd][:url])
+              self.bucket = self.warehouse.bucket(@bucket_name)
+            rescue
+              raise BucketNotFound
+            end
+          end
+
+          def bucket_objects
+            self.set_warehouse_and_bucket if self.bucket.nil?
+
+            begin
+              self.bucket.objects
+            rescue RestClient::ResourceNotFound
+              []
+            end
+          end
+
+          def first
+            obj = bucket_objects.first
+            obj ? self.new(obj) : nil
+          end
+
+          def last
+            obj = bucket_objects.last
+            obj ? self.new(obj) : nil
+          end
+
+          def all
+            bucket_objects.map do |wh_object|
+                self.new(wh_object)
+            end
+          end
+
+          def find(uuid)
+            self.set_warehouse_and_bucket if self.bucket.nil?
+            begin
+              if self.bucket.include?(uuid)
+                self.new(self.bucket.object(uuid))
+              else
+                nil
+              end
+            rescue RestClient::ResourceNotFound
+              nil
+            end
+          end
+
+          def where(query_string)
+            begin
+              self.set_warehouse_and_bucket if self.bucket.nil?
+              self.warehouse.query(@bucket_name, query_string).xpath('/objects/object').map do |obj|
+                self.new(self.bucket.object(obj.at_xpath('./key/text()').to_s))
+              end
+            rescue RestClient::ResourceNotFound
+              []
+            end
+          end
+
+          def delete(uuid)
+            self.set_warehouse_and_bucket if self.bucket.nil?
+            begin
+              if self.bucket.include?(uuid)
+                self.bucket.object(uuid).delete!
+              else
+                false
+              end
+            rescue RestClient::ResourceNotFound
+              false
+            end
+          end
+
+          def config
+            defined?(@@config) ? @@config : nil
+          end
+
+          def config=(conf)
+            @@config = conf
+          end
+
+          def use_oauth?
+            !!oauth_consumer_key && !!oauth_consumer_secret
+          end
+
+          def oauth_consumer_key
+            config[:iwhd][:oauth][:consumer_key] rescue nil
+          end
+
+          def oauth_consumer_secret
+            config[:iwhd][:oauth][:consumer_secret] rescue nil
+          end
+
+          def iwhd_url
+            config[:iwhd][:url]
+          end
+
+          def create!(key, body, attributes)
+            self.set_warehouse_and_bucket if self.bucket.nil?
+            unless self.warehouse.buckets.include?(self.bucket.name)
+              self.bucket = self.warehouse.create_bucket(self.bucket.name)
+            end
+            obj = self.bucket.create_object(key, body, attributes)
+            self.new(obj)
+          end
+
+          protected
+
+          # Copy over entirely too much code to load the config file
+          def load_config
+            # TODO - Is this always the case? We should probably have /etc/aeolus-cli or something too?
+            # Or allow Rails to override this
+            @config_location ||= "~/.aeolus-cli"
+            begin
+              file_str = read_file(@config_location)
+              if is_file?(@config_location) && !file_str.include?(":url")
+                lines = File.readlines(File.expand_path(@config_location)).map do |line|
+                  "#" + line
+                end
+                File.open(File.expand_path(@config_location), 'w') do |file|
+                  file.puts lines
+                end
+                write_file
+              end
+              write_file unless is_file?(@config_location)
+              YAML::load(File.open(File.expand_path(@config_location)))
+            rescue Errno::ENOENT
+              #TODO: Create a custom exception to wrap CLI Exceptions
+              raise "Unable to locate or write configuration file: \"" + @config_location + "\""
+            end
+          end
+
+          def write_file
+            example = File.read(File.expand_path(File.dirname(__FILE__) + "/../../examples/aeolus-cli"))
+            File.open(File.expand_path(@config_location), 'a+') do |f|
+              f.write(example)
+            end
+          end
+
+          def read_file(path)
+            begin
+              full_path = File.expand_path(path)
+              if is_file?(path)
+                File.read(full_path)
+              else
+                return nil
+              end
+            rescue
+              nil
+            end
+          end
+
+          def is_file?(path)
+            full_path = File.expand_path(path)
+            if File.exist?(full_path) && !File.directory?(full_path)
+              return true
+            end
+            false
+          end
+
+        end
+
+      end
+    end
+  end
+end