deltacloud-client 1.1.2 → 1.1.3

data/lib/deltacloud/client/methods/blob.rb

@@ -0,0 +1,91 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Blob
+
+      # Retrieve a list of all blob entities from given bucket
+      #
+      def blobs(bucket_id=nil)
+        raise error.new("The :bucket_id cannot be nil.") if bucket_id.nil?
+        bucket(bucket_id).blob_ids.map { |blob_id| blob(bucket_id, blob_id) }
+      end
+
+      # Retrieve the single blob entity
+      #
+      # - blob_id -> Blob entity to retrieve
+      #
+      def blob(bucket_id, blob_id)
+        model(:blob).convert(
+          self,
+          connection.get(api_uri("buckets/#{bucket_id}/#{blob_id}"))
+        )
+      end
+
+      # Create a new blob
+      #
+      # - bucket_id -> A bucket ID that new blob should belong to
+      # - blob_name -> A name for new blob
+      # - blob_data -> Data stored in this blob
+      # - create_opts
+      #   - :user_metadata -> A Ruby +Hash+ with key => value metadata
+      #
+      def create_blob(bucket_id, blob_name, blob_data, create_opts={})
+        must_support! :buckets
+        create_opts.merge!(convert_meta_params(create_opts.delete(:user_metadata)))
+        response = connection.post(api_uri("buckets/#{bucket_id}")) do |request|
+          request.params = create_opts.merge(
+            :blob_id => blob_name,
+            :blob_data => blob_data
+        )
+        end
+        model(:blob).convert(self, response.body)
+      end
+
+      # Destroy given bucket blob
+      #
+      def destroy_blob(bucket_id, blob_id)
+        must_support! :buckets
+        r = connection.delete(api_uri("buckets/#{bucket_id}/#{blob_id}"))
+        r.status == 204
+      end
+
+      private
+
+      # Convert the user_metadata into POST params compatible with
+      # blob creation
+      #
+      # - params -> Simple Ruby +Hash+
+      #
+      # @return { :meta_params => COUNTER, :meta_name1 => '', :meta_value1 => ''}
+      #
+      def convert_meta_params(params)
+        meta_params = {}
+        counter = 0
+        (params || {}).each do |key, value|
+          counter += 1
+          meta_params["meta_name#{counter}"] = key
+          meta_params["meta_value#{counter}"] = value
+        end
+        if counter >= 1
+          meta_params.merge!(:meta_params => counter.to_s)
+        end
+        meta_params
+      end
+
+    end
+  end
+end

data/lib/deltacloud/client/methods/bucket.rb

@@ -0,0 +1,55 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Bucket
+
+      # Retrieve list of all bucket entities
+      #
+      # - filter_opts:
+      #   - :id -> Filter entities using 'id' attribute
+      #
+      def buckets(filter_opts={})
+        from_collection :buckets,
+          connection.get(api_uri('buckets'), filter_opts)
+      end
+
+      # Retrieve the single bucket entity
+      #
+      # - bucket_id -> Bucket entity to retrieve
+      #
+      def bucket(bucket_id)
+        from_resource :bucket,
+          connection.get(api_uri("buckets/#{bucket_id}"))
+      end
+
+      # Create a new bucket
+      #
+      # - name: Bucket name
+      #
+      def create_bucket(name)
+        create_resource :bucket, :name => name
+      end
+
+      # Destroy given bucket
+      #
+      def destroy_bucket(bucket_id)
+        destroy_resource :bucket, bucket_id
+      end
+
+    end
+  end
+end

data/lib/deltacloud/client/methods/common.rb

@@ -0,0 +1,46 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Common
+
+      # A generic method for creating a new resources
+      #
+      # - resource_name -> A resource name to create (eg. :image)
+      # - create_opts -> HTTP options to pass into the create operation
+      #
+      def create_resource(resource_name, create_opts={})
+        no_convert_model = create_opts.delete(:no_convert_model)
+        must_support! resource_name.to_s.pluralize
+        response = connection.post(api_uri(resource_name.to_s.pluralize)) do |request|
+          request.params = create_opts
+        end
+        no_convert_model ? response : model(resource_name).convert(self, response.body)
+      end
+
+      # A generic method for destroying resources
+      #
+      def destroy_resource(resource_name, resource_id)
+        must_support! resource_name.to_s.pluralize
+        result = connection.delete(
+          api_uri([resource_name.to_s.pluralize, resource_id].join('/'))
+        )
+        result.status.is_no_content?
+      end
+
+    end
+  end
+end

data/lib/deltacloud/client/methods/driver.rb

@@ -0,0 +1,53 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Driver
+
+      # Retrieve list of all drivers
+      #
+      # - filter_opt:
+      #   - :id -> Filter drivers using their 'id'
+      #   - :state -> Filter drivers  by their 'state'
+      #
+      def drivers(filter_opts={})
+        from_collection(
+          :drivers,
+          connection.get(api_uri('drivers'), filter_opts)
+        )
+      end
+
+      # Retrieve the given driver
+      #
+      # - driver_id -> Driver to retrieve
+      #
+      def driver(driver_id)
+        from_resource(
+          :driver,
+          connection.get(api_uri("drivers/#{driver_id}"))
+        )
+      end
+
+      # List of the current driver providers
+      #
+      def providers
+        driver(current_driver).providers
+      end
+
+    end
+
+  end
+end

data/lib/deltacloud/client/methods/firewall.rb

@@ -0,0 +1,67 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Firewall
+
+      # Retrieve list of all firewall entities
+      #
+      # - filter_opts:
+      #   - :id -> Filter entities using 'id' attribute
+      #
+      def firewalls(filter_opts={})
+        from_collection :firewalls,
+        connection.get(api_uri('firewalls'), filter_opts)
+      end
+
+      # Retrieve the single firewall entity
+      #
+      # - firewall_id -> Firewall entity to retrieve
+      #
+      def firewall(firewall_id)
+        from_resource :firewall,
+          connection.get(api_uri("firewalls/#{firewall_id}"))
+      end
+
+      # Create a new firewall
+      #
+      # - name - Name to associate with new firewall
+      # - create_opts
+      #   :name -> Name of firewall
+      #
+      def create_firewall(name, create_opts={})
+        create_resource :firewall, { :name => name }.merge(create_opts)
+      end
+
+      def destroy_firewall(firewall_id)
+        destroy_resource :firewall, firewall_id
+      end
+
+      def add_firewall_rule(firewall_id, protocol, port_from, port_to, opts={})
+        r = connection.post(api_uri("firewalls/#{firewall_id}/rules")) do |request|
+          request.params = {
+            :protocol => protocol,
+            :port_from => port_from,
+            :port_to => port_to
+          }
+          # TODO: Add support for sources
+        end
+        model(:firewall).convert(self, r.body)
+      end
+
+    end
+  end
+end

data/lib/deltacloud/client/methods/hardware_profile.rb

@@ -0,0 +1,41 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module HardwareProfile
+
+      # Retrieve list of all hardware_profiles
+      #
+      # - filter_opts:
+      #   - :id -> Filter hardware_profiles using their 'id'
+      #
+      def hardware_profiles(filter_opts={})
+        from_collection :hardware_profiles,
+          connection.get(api_uri('hardware_profiles'), filter_opts)
+      end
+
+      # Retrieve the given hardware_profile
+      #
+      # - hwp_id -> hardware_profile to retrieve
+      #
+      def hardware_profile(hwp_id)
+        from_resource :hardware_profile,
+          connection.get(api_uri("hardware_profiles/#{hwp_id}"))
+      end
+
+    end
+  end
+end

data/lib/deltacloud/client/methods/image.rb

@@ -0,0 +1,61 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Image
+
+      # Retrieve list of all images
+      #
+      # - filter_opts:
+      #   - :id -> Filter images using their 'id'
+      #   - :state -> Filter images  by their 'state'
+      #   - :architecture -> Filter images  by their 'architecture'
+      #
+      def images(filter_opts={})
+        from_collection :images,
+          connection.get(api_uri('images'), filter_opts)
+      end
+
+      # Retrieve the given image
+      #
+      # - image_id -> Image to retrieve
+      #
+      def image(image_id)
+        from_resource :image,
+          connection.get(api_uri("images/#{image_id}"))
+      end
+
+      # Create a new image from instance
+      #
+      # - instance_id -> The stopped instance used for creation
+      # - create_opts
+      #   - :name     -> Name of the new image
+      #   - :description -> Description of the new image
+      #
+      def create_image(instance_id, create_opts={})
+        create_resource :image, { :instance_id => instance_id }.merge(create_opts)
+      end
+
+      # Destroy given image
+      # NOTE: This operation might not be supported for all drivers.
+      #
+      def destroy_image(image_id)
+        destroy_resource :image, image_id
+      end
+
+    end
+  end
+end

data/lib/deltacloud/client/methods/instance.rb

@@ -0,0 +1,141 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you 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 Deltacloud::Client
+  module Methods
+    module Instance
+
+      # Retrieve list of all instances
+      #
+      # - filter_opts:
+      #   - :id -> Filter instances using their 'id'
+      #   - :state -> Filter instances by their 'state'
+      #   - :realm_id -> Filter instances based on their 'realm_id'
+      #
+      def instances(filter_opts={})
+        from_collection(
+          :instances,
+          connection.get(api_uri('/instances'), filter_opts)
+        )
+      end
+
+      # Retrieve the given instance
+      #
+      # - instance_id -> Instance to retrieve
+      #
+      def instance(instance_id)
+        from_resource(
+          :instance,
+          connection.get(api_uri("instances/#{instance_id}"))
+        )
+      end
+
+      # Create a new instance
+      #
+      # - image_id ->    Image to use for instance creation
+      #                  (img1, ami-12345, etc...)
+      # - create_opts -> Various options that DC support for the current
+      #                  provider.
+      #
+      # Returns created instance, or list of created instances or all instances.
+      #
+      def create_instance(image_id, create_opts={})
+        create_opts[:user_data] = Base64::encode64(create_opts[:user_data]) if create_opts[:user_data]
+        r = create_resource :instance, create_opts.merge(
+          :image_id => image_id,
+          :no_convert_model => true
+        )
+        parse_create_instance(r)
+      end
+
+      # Destroy the current +Instance+
+      # Returns 'true' if the response was 204 No Content
+      #
+      # - instance_id -> The 'id' of the Instance to destroy
+      #
+      def destroy_instance(instance_id)
+        destroy_resource :instance, instance_id
+      end
+
+      # Attempt to change the +Instance+ state to STOPPED
+      #
+      # - instance_id -> The 'id' of the Instance to stop
+      #
+      def stop_instance(instance_id)
+        instance_action :stop, instance_id
+      end
+
+      # Attempt to change the +Instance+ state to STARTED
+      #
+      # - instance_id -> The 'id' of the Instance to start
+      #
+      def start_instance(instance_id)
+        instance_action :start, instance_id
+      end
+
+      # Attempt to reboot the +Instance+
+      #
+      # - instance_id -> The 'id' of the Instance to reboot
+      #
+      def reboot_instance(instance_id)
+        instance_action :reboot, instance_id
+      end
+
+      private
+
+      # Avoid codu duplication ;-)
+      #
+      def instance_action(action, instance_id)
+        result = connection.post(
+          api_uri("/instances/#{instance_id}/#{action}")
+        )
+        if result.status.is_ok?
+          from_resource(:instance, result)
+        else
+          instance(instance_id)
+        end
+      end
+
+      # Handles parsing of +create_instance+ method
+      #
+      # - response -> +create_instance+ HTTP response body
+      #
+      def parse_create_instance(response)
+        # If Deltacloud API return only Location (30x), follow it and
+        # retrieve created instance from there.
+        #
+        if response.status.is_redirect?
+          # If Deltacloud API redirect to list of instances
+          # then return list of **all** instances, otherwise
+          # grab the instance_id from Location header
+          #
+          redirect_instance = response.headers['Location'].split('/').last
+          if redirect_instance == 'instances'
+            instances
+          else
+            instance(redirect_instance)
+          end
+        elsif response.body.to_xml.root.name == 'instances'
+          # If more than 1 instance was created, return list
+          #
+          from_collection(:instances, response.body)
+        else
+          from_resource(:instance, response)
+        end
+      end
+
+    end
+  end
+end