phpfog-fog 0.4.1

data/lib/fog/compute/requests/go_grid/grid_image_list.rb

@@ -0,0 +1,44 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # List images
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'datacenter'<~String> - datacenter to limit results to
+        #   * 'isPublic'<~String>   - If true only returns public images, in ['false', 'true']
+        #   * 'num_items'<~Integer> - Number of items to return
+        #   * 'page'<~Integer>      - Page index for paginated results
+        #   * 'state'<~String>      - state to limit results to, in ['Saving', 'Available']
+        #   * 'type'<~String>       - image type to limit results to
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_image_list(options={})
+          request(
+            :path     => 'grid/image/list',
+            :query    => options
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_image_list(options={})
+          #response = Excon::Response.new
+
+          #images = @data[:list].values
+          #for image in images
+          #  case image['state']
+          #  when 'Available'
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_ip_list.rb

@@ -0,0 +1,38 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # List ips
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'datacenter'<~String> - datacenter to limit results to
+        #   * 'ip.state'<~String>      - state to limit results to in ip.state
+        #   * 'ip.type'<~String>       - type to limit results to in ip.type
+        #   * 'num_items'<~Integer> - Number of items to return
+        #   * 'page'<~Integer>      - Page index for paginated results
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_ip_list(options={})
+          request(
+            :path     => 'grid/ip/list',
+            :query    => options
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_ip_list(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_loadbalancer_list.rb

@@ -0,0 +1,36 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # List load balancers
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'datacenter'<~String> - datacenter to limit results to
+        #   * 'num_items'<~Integer> - Number of items to return
+        #   * 'page'<~Integer> - Page index for paginated results
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_loadbalancer_list(options={})
+          request(
+            :path     => 'grid/loadbalancer/list',
+            :query    => options
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_loadbalancer_list(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_server_add.rb

@@ -0,0 +1,44 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # Create a new server
+        #
+        # ==== Parameters
+        # * 'image'<~String>  - image to use, in grid_image_list
+        # * 'ip'<~String> - initial public ip for this server
+        # * 'name'<~String>   - name of the server, 20 or fewer characters
+        # * 'server_ram'<~String> - flavor to use, in common_lookup_list('server.ram')
+        # * 'options'<~Hash>:
+        #   * 'description'<~String>  - description of this server
+        #   * 'isSandbox'<~String>    - treat this server as image sandbox? in ['true', 'false']
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_server_add(image, ip, name, server_ram, options={})
+          request(
+            :path     => 'grid/server/add',
+            :query    => {
+              'image'       => image,
+              'ip'          => ip,
+              'name'        => name,
+              'server.ram'  => server_ram
+            }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_server_add(image, ip, name, server_ram, options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_server_delete.rb

@@ -0,0 +1,33 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # Delete a server
+        #
+        # ==== Parameters
+        # * 'server'<~String> - id or name of server to delete
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_server_delete(server)
+          request(
+            :path     => 'grid/server/delete',
+            :query    => {'server' => server}
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_server_delete(server)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_server_get.rb

@@ -0,0 +1,33 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # Get one or more servers by name
+        #
+        # ==== Parameters
+        # * 'server'<~String> - id or name of server(s) to lookup
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_server_get(servers)
+          request(
+            :path     => 'grid/server/get',
+            :query    => {'server' => [*servers]}
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_server_get(servers)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_server_list.rb

@@ -0,0 +1,38 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # List servers
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'datacenter'<~String> - datacenter to limit results to
+        #   * 'isSandbox'<~String> - If true only  returns Image Sandbox servers, in ['false', 'true']
+        #   * 'num_items'<~Integer> - Number of items to return
+        #   * 'page'<~Integer> - Page index for paginated results
+        #   * 'server.type'<~String> - server type to limit results to
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_server_list(options={})
+          request(
+            :path     => 'grid/server/list',
+            :query    => options
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_server_list(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/go_grid/grid_server_power.rb

@@ -0,0 +1,34 @@
+module Fog
+  module GoGrid
+    class Compute
+      class Real
+
+        # Start, Stop or Restart a server
+        #
+        # ==== Parameters
+        # * 'server'<~String> - id or name of server to power
+        # * 'power'<~String>  - power operation, in ['restart', 'start', 'stop']
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def grid_server_power(server, power)
+          request(
+            :path     => 'grid/server/power',
+            :query    => {'server' => server}
+          )
+        end
+
+      end
+
+      class Mock
+
+        def grid_server_power(server)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/avail_datacenters.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Get available data centers
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def avail_datacenters
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'avail.datacenters' }
+          )
+        end
+
+      end
+
+      class Mock
+
+        def avail_datacenters
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/avail_distributions.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Get available distributions
+        #
+        # ==== Parameters
+        # * distributionId<~Integer>: id to limit results to
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def avail_distributions(distribution_id=nil)
+          options = {}
+          if distribution_id
+            options.merge!(:distributionId => distribution_id)
+          end
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'avail.distributions' }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def avail_distributions(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/avail_kernels.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Get available kernels
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * kernelId<~Integer>: id to limit results to
+        #   * isXen<~Integer>: if 1 limits results to only zen
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def avail_kernels(options={})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'avail.kernels' }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def avail_kernels(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/avail_linodeplans.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Get available plans
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def avail_linodeplans(linodeplan_id = nil)
+          options = {}
+          if linodeplan_id
+            options.merge!(:planId => linodeplan_id)
+          end
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'avail.linodeplans' }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def avail_linodeplans(linodeplan_id = nil)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/avail_stackscripts.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Get available stack scripts
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * distributionId<~Integer>: Limit the results to Stackscripts that can be applied to this distribution id
+        #   * distributionVendor<~String>: Debian, Ubuntu, Fedora, etc.
+        #   * keywords<~String>: Search terms
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def avail_stackscripts(options={})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'avail.stackscripts' }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def avail_stackscripts(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/linode_create.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Creates a linode and assigns you full privileges
+        #
+        # ==== Parameters
+        # * datacenter_id<~Integer>: id of datacenter to place new linode in
+        # * payment_term<~Integer>: Subscription term in months, in [1, 12, 24]
+        # * plan_id<~Integer>: id of plan to boot new linode with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def linode_create(datacenter_id, payment_term, plan_id)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action   => 'linode.create',
+              :datacenterId => datacenter_id,
+              :paymentTerm  => payment_term,
+              :planId       => plan_id
+            }
+          )
+        end
+
+      end
+
+      class Mock
+
+        def linode_create(datacenter_id, payment_term, plan_id)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/linode_delete.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # List all linodes user has access or delete to
+        #
+        # ==== Parameters
+        # * linode_id<~Integer>: id of linode to delete
+        # * options<~Hash>:
+        #   * skipChecks<~Boolean>: skips safety checks and always deletes
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def linode_delete(linode_id, options={})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.delete', :linodeId => linode_id }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def linode_delete(linode_id, options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/linode_list.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # List all linodes user has access or delete to
+        #
+        # ==== Parameters
+        # * linodeId<~Integer>: Limit the list to the specified LinodeID
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def linode_list(linode_id=nil)
+          options = {}
+          if linode_id
+            options.merge!(:linodeId => linode_id)
+          end
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.list' }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def linode_list(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/linode/linode_reboot.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Issues a shutdown, and then a boot job for a given linode
+        #
+        # ==== Parameters
+        # * linode_id<~Integer>: id of linode to reboot
+        # * options<~Hash>:
+        #   * configId<~Boolean>: id of config to boot server with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs
+        def linode_reboot(linode_id, options={})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.reboot', :linodeId => linode_id }.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def linode_reboot(linode_id, options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/new_servers/add_server.rb

@@ -0,0 +1,41 @@
+module Fog
+  module NewServers
+    class Compute
+      class Real
+
+        # Boot a new server
+        #
+        # ==== Parameters
+        # * planId<~String> - The id of the plan to boot the server with
+        # * options<~Hash>: optional extra arguments
+        #   * imageId<~String>  - Optional image to boot server from
+        #   * name<~String>     - Name to boot new server with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'server'<~Hash>:
+        #       * 'id'<~String> - Id of the image
+        #
+        def add_server(plan_id, options = {})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :parser   => Fog::ToHashDocument.new,
+            :path     => 'api/addServer',
+            :query    => {'planId' => plan_id}.merge!(options)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def add_server(server_id)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end