fog-oneandone 1.0

data/lib/oneandone/core.rb

@@ -0,0 +1,11 @@
+require "fog/core"
+require "fog/json"
+
+module Fog
+  module OneAndOne
+    extend Fog::Provider
+
+    service(:compute, 'Compute')
+
+  end # OneAndOne
+end # Fog

data/lib/oneandone/models/compute/firewall.rb

@@ -0,0 +1,128 @@
+module Fog
+  module Compute
+    class OneAndOne
+      class Firewall < Fog::Model
+
+        # Declare Model Attributes
+        identity  :id
+
+        attribute :name
+        attribute :description
+        attribute :state
+        attribute :creation_date
+        attribute :rules
+        attribute :server_ips
+        
+        
+        def save
+
+          requires :name, :rules
+
+          # Perform Request
+          response = service.create_firewall(name: name, rules: rules,
+            description: description)
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def update(options = {})
+
+          requires :id
+
+          response = service.update_firewall(firewall_id: id, name: options[:name],
+            description: options[:description])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_ips(options = {})
+
+          requires :id
+
+          response = service.add_firewall_ips(firewall_id: id,
+            ips: options[:ips])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def remove_ip(options = {})
+
+          requires :id
+
+          response = service.remove_firewall_ip(firewall_id: id,
+            ip_id: options[:ip_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_rules(options = {})
+
+          requires :id
+
+          response = service.add_firewall_rules(firewall_id: id,
+            rules: options[:rules])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def delete_rule(options = {})
+
+          requires :id
+
+          response = service.delete_firewall_rule(firewall_id: id,
+            rule_id: options[:rule_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def destroy
+
+          requires :id
+
+          service.delete_firewall(id)
+          
+          true
+
+        end
+
+
+        def ready?
+
+          state == 'ACTIVE'
+
+        end
+
+      end # Firewall
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/firewalls.rb

@@ -0,0 +1,24 @@
+require_relative 'firewall'
+
+module Fog
+  module Compute
+    class OneAndOne
+      class Firewalls < Fog::Collection
+        model Fog::Compute::OneAndOne::Firewall
+
+        def all
+          response = service.list_firewalls
+          load(response.body)
+        end
+
+        def get(id)
+          response = service.get_firewall(id)
+          new(response.body)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end # Firewalls
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/image.rb

@@ -0,0 +1,72 @@
+module Fog
+  module Compute
+    class OneAndOne
+      class Image < Fog::Model
+
+        # Declare Model Attributes
+        identity  :id
+
+        attribute :name
+        attribute :description
+        attribute :datacenter
+        attribute :min_hdd_size
+        attribute :state
+        attribute :hdds
+        attribute :server_id
+        attribute :frequency
+        attribute :num_images
+        attribute :creation_date
+        
+        
+        def save
+
+          requires :name, :server_id, :frequency, :num_images
+
+          # Perform Request
+          response = service.create_image(name: name, description: description,
+            server_id: server_id, frequency: frequency, num_images: num_images)
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def update(options = {})
+
+          requires :id
+
+          response = service.update_image(image_id: id, name: options[:name],
+            description: options[:description], frequency: options[:frequency])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def destroy
+
+          requires :id
+
+          service.delete_image(id)
+          
+          true
+
+        end
+
+
+        def ready?
+
+          state == 'ENABLED'
+
+        end
+
+      end # Image
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/images.rb

@@ -0,0 +1,24 @@
+require_relative 'image'
+
+module Fog
+  module Compute
+    class OneAndOne
+      class Images < Fog::Collection
+        model Fog::Compute::OneAndOne::Image
+
+        def all
+          response = service.list_images
+          load(response.body)
+        end
+
+        def get(id)
+          response = service.get_image(id)
+          new(response.body)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end # Images
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/load_balancer.rb

@@ -0,0 +1,149 @@
+module Fog
+  module Compute
+    class OneAndOne
+      class LoadBalancer < Fog::Model
+
+        # Declare Model Attributes
+        identity  :id
+
+        attribute :name
+        attribute :description
+        attribute :state
+        attribute :rules
+        attribute :datacenter
+        attribute :datacenter_id
+        attribute :health_check_test
+        attribute :health_check_interval
+        attribute :persistence
+        attribute :persistence_time
+        attribute :method
+        attribute :health_check_path
+        attribute :health_check_parse
+        attribute :creation_date
+        attribute :server_ips
+        
+        
+        def save
+
+          requires :name, :rules, :health_check_test, :health_check_interval,
+            :persistence, :persistence_time, :method
+
+          # Perform Request
+          response = service.create_load_balancer(name: name,
+            description: description, health_check_test: health_check_test,
+            health_check_interval: health_check_interval,
+            persistence: persistence, persistence_time: persistence_time,
+            method: method, rules: rules, health_check_path: health_check_path,
+            health_check_parse: health_check_parse, datacenter_id: datacenter_id)
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def update(options = {})
+
+          requires :id
+
+          response = service.update_load_balancer(load_balancer_id: id,
+            name: options[:name], description: options[:description],
+            health_check_test: options[:health_check_test],
+            health_check_interval: options[:health_check_interval],
+            persistence: options[:persistence],
+            persistence_time: options[:persistence_time],
+            method: options[:method],
+            health_check_path: options[:health_check_path],
+            health_check_parse: options[:health_check_parse])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_ips(options = {})
+
+          requires :id
+
+          response = service.add_load_balancer_ips(load_balancer_id: id,
+            ips: options[:ips])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def remove_ip(options = {})
+
+          requires :id
+
+          response = service.remove_load_balancer_ip(load_balancer_id: id,
+            ip_id: options[:ip_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_rules(options = {})
+
+          requires :id
+
+          response = service.add_load_balancer_rules(load_balancer_id: id,
+            rules: options[:rules])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def delete_rule(options = {})
+
+          requires :id
+
+          response = service.delete_load_balancer_rule(load_balancer_id: id,
+            rule_id: options[:rule_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def destroy
+
+          requires :id
+
+          service.delete_load_balancer(id)
+          
+          true
+
+        end
+
+
+        def ready?
+
+          state == 'ACTIVE'
+
+        end
+
+      end # LoadBalancer
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/load_balancers.rb

@@ -0,0 +1,24 @@
+require_relative 'load_balancer'
+
+module Fog
+  module Compute
+    class OneAndOne
+      class LoadBalancers < Fog::Collection
+        model Fog::Compute::OneAndOne::LoadBalancer
+
+        def all
+          response = service.list_load_balancers
+          load(response.body)
+        end
+
+        def get(id)
+          response = service.get_load_balancer(id)
+          new(response.body)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end # LoadBalancers
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/monitoring_policies.rb

@@ -0,0 +1,24 @@
+require_relative 'monitoring_policy'
+
+module Fog
+  module Compute
+    class OneAndOne
+      class MonitoringPolicies < Fog::Collection
+        model Fog::Compute::OneAndOne::MonitoringPolicy
+
+        def all
+          response = service.list_monitoring_policies
+          load(response.body)
+        end
+
+        def get(id)
+          response = service.get_monitoring_policy(id)
+          new(response.body)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end # MonitoringPolicies
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/models/compute/monitoring_policy.rb

@@ -0,0 +1,196 @@
+module Fog
+  module Compute
+    class OneAndOne
+      class MonitoringPolicy < Fog::Model
+
+        # Declare Model Attributes
+        identity  :id
+
+        attribute :name
+        attribute :description
+        attribute :email
+        attribute :agent
+        attribute :thresholds
+        attribute :ports
+        attribute :processes
+        
+        attribute :state
+        attribute :creation_date
+        attribute :servers
+        
+        
+        def save
+
+          requires :name, :agent, :email, :thresholds, :ports, :processes
+
+          # Perform Request
+          response = service.create_monitoring_policy(name: name,
+            description: description, email: email, agent: agent,
+            thresholds: thresholds, ports: ports, processes: processes)
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def update(options = {})
+
+          requires :id
+
+          response = service.update_monitoring_policy(monitoring_policy_id: id,
+            name: options[:name], description: options[:description],
+            email: options[:email], thresholds: options[:thresholds])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_ports(options = {})
+
+          requires :id
+
+          response = service.add_ports(monitoring_policy_id: id,
+            ports: options[:ports])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def delete_port(options = {})
+
+          requires :id
+
+          response = service.delete_port(monitoring_policy_id: id,
+            port_id: options[:port_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def update_port(options = {})
+
+          requires :id
+
+          response = service.update_port(monitoring_policy_id: id,
+            port_id: options[:port_id], new_port: options[:new_port])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_processes(options = {})
+
+          requires :id
+
+          response = service.add_processes(monitoring_policy_id: id,
+            processes: options[:processes])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def delete_process(options = {})
+
+          requires :id
+
+          response = service.delete_process(monitoring_policy_id: id,
+            process_id: options[:process_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def update_process(options = {})
+
+          requires :id
+
+          response = service.update_process(monitoring_policy_id: id,
+            process_id: options[:process_id],
+            new_process: options[:new_process])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def add_servers(options = {})
+
+          requires :id
+
+          response = service.add_mp_servers(monitoring_policy_id: id,
+            servers: options[:servers])
+
+          # Decode and Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def remove_server(options = {})
+
+          requires :id
+
+          response = service.remove_mp_server(monitoring_policy_id: id,
+            server_id: options[:server_id])
+
+          # Merge Attributes
+          merge_attributes(response.body)
+
+          true
+
+        end
+
+
+        def destroy
+
+          requires :id
+
+          service.delete_monitoring_policy(id)
+          
+          true
+
+        end
+
+
+        def ready?
+
+          state == 'ACTIVE'
+
+        end
+
+      end # MonitoringPolicy
+    end # OneAndOne
+  end # Compute
+end # Fog