fog-sakuracloud 0.0.1

data/lib/fog/sakuracloud/models/compute/server.rb

@@ -0,0 +1,40 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Server < Fog::Model
+        identity :id, :aliases => 'ID'
+        attribute :name, :aliases => 'Name'
+        attribute :server_plan, :aliases => 'ServerPlan'
+        attribute :instance, :aliases => 'Instance'
+        attribute :disks, :aliases => 'Disks'
+        attribute :interfaces, :aliases => 'Interfaces'
+
+        def save
+          requires :name, :server_plan
+          data = service.create_server(@attributes[:name], @attributes[:server_plan]).body["Server"]
+          merge_attributes(data)
+          true
+        end
+
+        def boot
+          requires :id
+          service.boot_server(@attributes[:id])
+        end
+
+        def stop(force = false)
+          requires :id
+          service.stop_server(@attributes[:id], force)
+        end
+
+        def delete(disks = [])
+          requires :id
+          service.delete_server(@attributes[:id], disks)
+          true
+        end
+        alias_method :destroy, :delete
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/compute/servers.rb

@@ -0,0 +1,63 @@
+require 'fog/core/collection'
+require 'fog/sakuracloud/models/compute/server'
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Servers < Fog::Collection
+        model Fog::Compute::SakuraCloud::Server
+
+        def all
+          load service.list_servers.body['Servers']
+        end
+
+        def get(id)
+          all.find { |f| f.id == id }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def create(options = {})
+          user = options[:user] || 'root'
+          Fog::Logger.warning("Create Server")
+          data = service.create_server(Fog::UUID.uuid, options[:serverplan]).body["Server"]
+          server = service.servers.new
+          server.merge_attributes(data)
+
+          if options[:volume]
+            disk = create_and_attach_volume(server, options)
+            server.reload
+          end
+          server.boot if options[:boot]
+          server
+        end
+
+        private
+        def create_and_attach_volume(server, options)
+            Fog::Logger.warning("Create Volume")
+            sakuracloud_api_token        = options[:sakuracloud_api_token] || Fog.credentials[:sakuracloud_api_token]
+            sakuracloud_api_token_secret = options[:sakuracloud_api_token_secret] || Fog.credentials[:sakuracloud_api_token_secret]
+            volume = Fog::Volume::SakuraCloud.new(:sakuracloud_api_token => sakuracloud_api_token, :sakuracloud_api_token_secret => sakuracloud_api_token_secret)
+            disk = volume.disks.create :name => Fog::UUID.uuid,
+                                :plan  => options[:volume][:diskplan].to_i,
+                                :source_archive => options[:volume][:sourcearchive].to_s
+            Fog::Logger.warning("Waiting disk until available")
+            disk.wait_for { availability == 'available' }
+            volume.attach_disk(disk.id, server.id)
+            disk_attached?(server, disk.id)
+            Fog::Logger.warning("Modifing disk")
+            volume.configure_disk(disk.id, options[:sshkey])
+            disk
+        end
+
+        def disk_attached?(server, disk_id)
+          until server.disks.find {|s| disk_id.to_s}
+            print '.'
+            sleep 2
+            server.reload
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/compute/ssh_key.rb

@@ -0,0 +1,13 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class SshKey < Fog::Model
+        identity :id, :aliases => 'ID'
+        attribute :name, :aliases => 'Name'
+        attribute :public_key, :aliases => 'PublicKey'
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/compute/ssh_keys.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/sakuracloud/models/compute/ssh_key'
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class SshKeys < Fog::Collection
+        model Fog::Compute::SakuraCloud::SshKey
+
+        def all
+          load service.list_ssh_keys.body['SSHKeys']
+        end
+
+        def get(id)
+          all.find { |f| f.id == id }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/compute/zone.rb

@@ -0,0 +1,13 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Zone < Fog::Model
+        identity :id, :aliases => 'ID'
+        attribute :name, :aliases => 'Name'
+        attribute :description, :aliases => 'Description'
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/compute/zones.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/sakuracloud/models/compute/zone'
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Zones < Fog::Collection
+        model Fog::Compute::SakuraCloud::Zone
+
+        def all
+          load service.list_zones.body['Zones']
+        end
+
+        def get(id)
+          all.find { |f| f.id == id }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/volume/archive.rb

@@ -0,0 +1,14 @@
+require 'fog/core/model'
+
+module Fog
+  module Volume
+    class SakuraCloud
+      class Archive < Fog::Model
+        identity :id, :aliases => 'ID'
+        attribute :name, :aliases => 'Name'
+        attribute :size_mb, :aliases => 'SizeMB'
+        attribute :plan, :aliases => 'Plan'
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/volume/archives.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/sakuracloud/models/volume/archive'
+
+module Fog
+  module Volume
+    class SakuraCloud
+      class Archives < Fog::Collection
+        model Fog::Volume::SakuraCloud::Archive
+
+        def all
+          load service.list_archives.body['Archives']
+        end
+
+        def get(id)
+          all.find { |f| f.id == id }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/volume/disk.rb

@@ -0,0 +1,37 @@
+require 'fog/core/model'
+
+module Fog
+  module Volume
+    class SakuraCloud
+      class Disk < Fog::Model
+        identity :id, :aliases => 'ID'
+        attribute :name, :aliases => 'Name'
+        attribute :connection, :aliases => 'Connection'
+        attribute :availability, :aliases => 'Availability'
+        attribute :plan, :aliases => 'Plan'
+        attribute :size_mb, :aliases => 'SizeMB'
+        attribute :source_disk, :aliases => 'SourceDisk'
+        attribute :source_archive, :aliases => 'SourceArchive'
+
+        def delete
+          service.delete_disk(identity)
+          true
+        end
+        alias_method :destroy, :delete
+
+        def save
+          requires :name, :plan, :source_archive
+          data = service.create_disk(@attributes[:name], @attributes[:plan], @attributes[:source_archive]).body["Disk"]
+          merge_attributes(data)
+          true
+        end
+
+        def configure(sshkey_id)
+          requires :id
+          service.configure_disk(@attributes[:id], sshkey_id )
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/volume/disks.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/sakuracloud/models/volume/disk'
+
+module Fog
+  module Volume
+    class SakuraCloud
+      class Disks < Fog::Collection
+        model Fog::Volume::SakuraCloud::Disk
+
+        def all
+          load service.list_disks.body['Disks']
+        end
+
+        def get(id)
+          all.find { |f| f.id == id }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+
+        def delete(id)
+          service.delete_disk(id)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/volume/plan.rb

@@ -0,0 +1,12 @@
+require 'fog/core/model'
+
+module Fog
+  module Volume
+    class SakuraCloud
+      class Plan < Fog::Model
+        identity :id, :aliases => 'ID'
+        attribute :name, :aliases => 'Name'
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/models/volume/plans.rb

@@ -0,0 +1,22 @@
+require 'fog/core/collection'
+require 'fog/sakuracloud/models/volume/plan'
+
+module Fog
+  module Volume
+    class SakuraCloud
+      class Plans < Fog::Collection
+        model Fog::Volume::SakuraCloud::Plan
+
+        def all
+          load service.list_plans.body['DiskPlans']
+        end
+
+        def get(id)
+          all.find { |f| f.id == id }
+        rescue Fog::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/sakuracloud/requests/compute/boot_server.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Real
+        def boot_server( id )
+          request(
+            :headers => {
+              'Authorization' => "Basic #{@auth_encord}"
+            },
+            :expects  => [200],
+            :method => 'PUT',
+            :path => "#{Fog::SakuraCloud::SAKURACLOUD_API_ENDPOINT}/server/#{id}/power"
+          )
+          true
+        end
+      end # Real
+
+      class Mock
+        def boot_server( id )
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+          }
+          response
+        end
+      end
+    end # SakuraCloud
+  end # Volume
+end # Fog

data/lib/fog/sakuracloud/requests/compute/create_server.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Real
+        def create_server( name, serverplan )
+          body = {
+            "Server" => {
+              "Name" => name,
+              "ServerPlan" => {
+                "ID" => serverplan.to_i
+              },
+              "ConnectedSwitches"=>[{"Scope"=>"shared", "BandWidthMbps"=>100}]
+            }
+          }
+
+          request(
+            :headers => {
+              'Authorization' => "Basic #{@auth_encord}"
+            },
+            :expects  => [201],
+            :method => 'POST',
+            :path => "#{Fog::SakuraCloud::SAKURACLOUD_API_ENDPOINT}/server",
+            :body => Fog::JSON.encode(body)
+          )
+        end
+      end # Real
+
+      class Mock
+        def create_server( name, serverplan )
+          response = Excon::Response.new
+          response.status = 201
+          response.body = {
+          }
+          response
+        end
+      end
+    end # SakuraCloud
+  end # Volume
+end # Fog

data/lib/fog/sakuracloud/requests/compute/delete_server.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Real
+        def delete_server( id, force = false, disks = [] )
+          body = { "Force" => force, 'WithDisk' => disks }
+
+          request(
+            :headers => {
+              'Authorization' => "Basic #{@auth_encord}"
+            },
+            :expects  => [200],
+            :method => 'DELETE',
+            :path => "#{Fog::SakuraCloud::SAKURACLOUD_API_ENDPOINT}/server/#{id}",
+            :body => Fog::JSON.encode(body)
+          )
+        end
+      end # Real
+
+      class Mock
+        def delete_server( id, force = false, disks = [] )
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+          }
+          response
+        end
+      end
+    end # SakuraCloud
+  end # Volume
+end # Fog

data/lib/fog/sakuracloud/requests/compute/list_plans.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+module Fog
+  module Compute
+    class SakuraCloud
+      class Real
+        def list_plans(options = {})
+          request(
+            :headers => {
+              'Authorization' => "Basic #{@auth_encord}"
+            },
+            :method => 'GET',
+            :path => "#{Fog::SakuraCloud::SAKURACLOUD_API_ENDPOINT}/product/server"
+          )
+        end
+      end
+
+      class Mock
+        def list_plans(options = {})
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+          "ServerPlans" =>
+            [
+            {"Index"=>0,
+              "ID"=>1001,
+              "Name"=>"プラン/1Core-1GB",
+              "CPU"=>1,
+              "MemoryMB"=>1024,
+              "ServiceClass"=>"cloud/plan/1core-1gb",
+              "Availability"=>"available"},
+            {"Index"=>1,
+              "ID"=>2001,
+              "Name"=>"プラン/1Core-2GB",
+              "CPU"=>1,
+              "MemoryMB"=>2048,
+              "ServiceClass"=>"cloud/plan/1core-2gb",
+              "Availability"=>"available"}
+            ]
+          }
+          response
+        end
+      end
+    end
+  end
+end