ocs 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8c215e6924e10df79b386df078dc3d8a29b4674
-  data.tar.gz: afef6522a19430d1311ef964dd5abb24fbb6268a
+  metadata.gz: 0c4206748407fad21d3dbacc44d8423e227f84f8
+  data.tar.gz: 38af688e8939ca50ee13c94ad9fbfdd04db2bee6
 SHA512:
-  metadata.gz: 5bd0b3b9d4bc4ce58a8fba98faa8f15fbad18caa8a22f302b290c49b4f6ab05bae9aa948262130b02b30f917b2abcb380b984739acd035a45f8014caf1a972a6
-  data.tar.gz: dfda45f337a17f60d9011c155023f4ebffbb5cf2ce2e2786ee60074f84f4d0869551c8ddd9b8cfd50d064b13d2786bff3e20af82d0ba495d61db049eb9919861
+  metadata.gz: 0aadd1303c2f8edb858d65e3ab034799b3b2def746a9133f0b57a31685eb94811b197dc49805f5bdce48f70187c4c001c2b10a44e3561d3872bcc6cb09ec74dc
+  data.tar.gz: 74b6f561ec1342187b3c69fb153f4ad8616687a473ba831260639be08bac2da06de9508526370ab5e732baa59743e5e5ed01ce702a607af1445086211840f969

data/lib/ocs.rb

@@ -2,6 +2,7 @@ require "base64"
 require "openssl"
 require "uri"
 
+require "active_support/concern"
 require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/hash/indifferent_access"
 require "active_support/core_ext/object/blank"

data/lib/ocs/resources/base.rb

@@ -1,14 +1,14 @@
 module Ocs
   module Resources
     class Base
+      include DynamicDefiners
+
       BOOLEAN = [TrueClass, FalseClass].freeze
 
       class_attribute :delegations, instance_writer: false
       self.delegations = {}
 
       class << self
-        include DynamicDefiners
-
         def all(client)
           list(client)
         end
@@ -85,28 +85,6 @@ module Ocs
 
       private
 
-      def action_parameters(required_keys, optional_keys)
-        check_required_keys(required_keys)
-        parameters(required_keys + optional_keys)
-      end
-
-      def check_required_keys(required_keys)
-        required_keys.each do |key|
-          key = key[:attribute] if key.is_a?(Hash)
-          raise MissingKeyError.new("#{key} key is required") if public_send(key).nil?
-        end
-      end
-
-      def parameters(keys)
-        keys.inject({}) do |params, key|
-          attribute_name = key.is_a?(Hash) ? key[:attribute] : key
-          request_key = key.is_a?(Hash) ? key[:as].to_s : key.to_s.delete("_")
-          value = public_send(attribute_name)
-          params[request_key] = value if value
-          params
-        end
-      end
-
       def resource_class(class_name)
         "ocs/resources/#{class_name}".camelize.constantize
       end

data/lib/ocs/resources/dynamic_definers.rb

@@ -1,93 +1,120 @@
 module Ocs
   module Resources
     module DynamicDefiners
-      def alias_attribute(alias_name, original_name)
-        alias_method alias_name, original_name
-        alias_method :"#{alias_name}=", :"#{original_name}="
-      end
+      extend ActiveSupport::Concern
 
-      def define_action(action_name, required: [], optional: [], api_name: nil)
-        define_method(action_name) do |special_parameters = {}|
-          api = api_name || "#{action_name}#{self.class.name}"
-          parameters = action_parameters(required, optional).merge(special_parameters)
-          send_and_update(api, parameters)
+      module ClassMethods
+        def alias_attribute(alias_name, original_name)
+          alias_method alias_name, original_name
+          alias_method :"#{alias_name}=", :"#{original_name}="
         end
 
-        define_method(:"#{action_name}!") do |special_parameters = {}|
-          send(action_name) || fail(@error)
-        end
-      end
+        def define_action(action_name, required: [], optional: [], api_name: nil)
+          define_method(action_name) do |special_parameters = {}|
+            api = api_name || "#{action_name}#{self.class.name}"
+            parameters = action_parameters(required, optional).merge(special_parameters)
+            send_and_update(api, parameters)
+          end
 
-      def define_attribute(attribute_name, type:)
-        define_method(:"#{attribute_name}=") do |value|
-          unless [*type].any? { |t| value.is_a?(t) }
-            fail AttributeTypeMismatch.new(
-              "#{attribute_name} needs to be a #{[*type].join(" or ")}"
-            )
+          define_method(:"#{action_name}!") do |special_parameters = {}|
+            send(action_name) || fail(@error)
           end
-          instance_variable_set(:"@#{attribute_name}", value)
         end
 
-        attr_reader attribute_name
-      end
-
-      def delegate_attribute(attribute_name, to:, as:)
-        writer_method_name = :"#{to}_#{as}="
-        define_method(writer_method_name) do |value|
-          instance =
-            public_send(to) ||
-            public_send(:"#{to}=", resource_class(to).new(client))
-          instance.public_send(:"#{as}=", value)
-        end
-        delegations[attribute_name] = writer_method_name
+        def define_attribute(attribute_name, type:)
+          define_method(:"#{attribute_name}=") do |value|
+            unless [*type].any? { |t| value.is_a?(t) }
+              fail AttributeTypeMismatch.new(
+                "#{attribute_name} needs to be a #{[*type].join(" or ")}"
+              )
+            end
+            instance_variable_set(:"@#{attribute_name}", value)
+          end
 
-        define_method(:"#{to}_#{as}") do
-          instance = public_send(to)
-          instance && instance.public_send(as)
+          attr_reader attribute_name
         end
-      end
 
-      def delegate_attributes(attribute_name, to:)
-        delegations[attribute_name] = :"#{to}="
-      end
+        def delegate_attribute(attribute_name, to:, as:)
+          writer_method_name = :"#{to}_#{as}="
+          define_method(writer_method_name) do |value|
+            instance =
+              public_send(to) ||
+              public_send(:"#{to}=", resource_class(to).new(client))
+            instance.public_send(:"#{as}=", value)
+          end
+          delegations[attribute_name] = writer_method_name
 
-      def has_one(attribute_name)
-        define_method(:"#{attribute_name}=") do |value|
-          klass = resource_class(attribute_name)
-          unless value.instance_of?(klass)
-            fail AttributeClassMismatch.new(
-              "#{attribute_name} needs to be an instance of #{klass}"
-            )
+          define_method(:"#{to}_#{as}") do
+            instance = public_send(to)
+            instance && instance.public_send(as)
           end
-          instance_variable_set(:"@#{attribute_name}", value)
         end
 
-        attr_reader attribute_name
-      end
-
-      def has_many(attribute_name)
-        define_method(:"#{attribute_name}=") do |values|
-          unless values.is_a?(Array)
-            fail AttributeTypeMismatch.new("#{attribute_name} needs to be an Array")
-          end
+        def delegate_attributes(attribute_name, to:)
+          delegations[attribute_name] = :"#{to}="
+        end
 
-          klass = resource_class(attribute_name.to_s.singularize)
-          instances = values.map do |value|
-            case value
-            when klass
-              value
-            when Hash
-              klass.new(client, value)
-            else
+        def has_one(attribute_name)
+          define_method(:"#{attribute_name}=") do |value|
+            klass = resource_class(attribute_name)
+            unless value.instance_of?(klass)
               fail AttributeClassMismatch.new(
-                "Elements of #{attribute_name} need to be instances of #{klass} or Hash"
+                "#{attribute_name} needs to be an instance of #{klass}"
               )
             end
+            instance_variable_set(:"@#{attribute_name}", value)
           end
-          instance_variable_set(:"@#{attribute_name}", instances)
+
+          attr_reader attribute_name
+        end
+
+        def has_many(attribute_name)
+          define_method(:"#{attribute_name}=") do |values|
+            unless values.is_a?(Array)
+              fail AttributeTypeMismatch.new("#{attribute_name} needs to be an Array")
+            end
+
+            klass = resource_class(attribute_name.to_s.singularize)
+            instances = values.map do |value|
+              case value
+              when klass
+                value
+              when Hash
+                klass.new(client, value)
+              else
+                fail AttributeClassMismatch.new(
+                  "Elements of #{attribute_name} need to be instances of #{klass} or Hash"
+                )
+              end
+            end
+            instance_variable_set(:"@#{attribute_name}", instances)
+          end
+
+          attr_reader attribute_name
         end
+      end
+
+      private
+
+      def action_parameters(required_keys, optional_keys)
+        check_required_keys(required_keys)
+        parameters(required_keys + optional_keys)
+      end
 
-        attr_reader attribute_name
+      def check_required_keys(required_keys)
+        required_keys.each do |key|
+          key = key[:attribute] if key.is_a?(Hash)
+          raise MissingKeyError.new("#{key} key is required") if public_send(key).nil?
+        end
+      end
+
+      def parameters(keys)
+        keys.each_with_object({}) do |key, params|
+          attribute_name = key.is_a?(Hash) ? key[:attribute] : key
+          request_key = key.is_a?(Hash) ? key[:as].to_s : key.to_s.delete("_")
+          value = public_send(attribute_name)
+          params[request_key] = value if value
+        end
       end
     end
   end

data/lib/ocs/resources/virtual_machine.rb

@@ -47,6 +47,7 @@ module Ocs
       define_attribute :rootdevicetype, type: String
       #define_attribute :servicestate
       define_attribute :state, type: String
+      define_attribute :userdata, type: String
       #define_attribute :vgpu
 
       delegate_attribute :account, to: :account, as: :name
@@ -85,7 +86,7 @@ module Ocs
 
       define_action :deploy,
         required: %i(service_offering_id template_id zone_id),
-        optional: %i(displayname name displayvm) + [
+        optional: %i(displayname name displayvm userdata) + [
           {attribute: :group_name, as: :group},
           {attribute: :ssh_key_pair_name, as: :keypair}
         ]
@@ -119,6 +120,14 @@ module Ocs
         parameters = {nicid: nic.id, virtualmachineid: id}
         send_and_update("removeNicFromVirtualMachine", parameters)
       end
+
+      attr_reader :raw_userdata
+
+      def raw_userdata=(raw_userdata)
+        @raw_userdata = raw_userdata
+        raw_userdata << "\n" until raw_userdata.bytesize % 3 == 0
+        self.userdata = Base64.strict_encode64(raw_userdata)
+      end
     end
   end
 end

data/lib/ocs/response.rb

@@ -21,7 +21,7 @@ module Ocs
     end
 
     def success?
-      !content.has_key?("cserrorcode")
+      !content.has_key?("errorcode")
     end
   end
 end

data/lib/ocs/version.rb

@@ -1,3 +1,3 @@
 module Ocs
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocs
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - nownabe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-21 00:00:00.000000000 Z
+date: 2015-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -199,4 +199,3 @@ signing_key:
 specification_version: 4
 summary: Ocs is an objective CloudStack API client.
 test_files: []
-has_rdoc: