fog 1.19.0 → 1.20.0

data/lib/fog/rackspace/requests/monitoring/get_filesystems_info.rb

@@ -0,0 +1,64 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+
+        def get_filesystems_info(agent_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents/#{agent_id}/host_info/filesystems"
+          )
+        end
+      end
+
+      class Mock
+        def get_filesystems_info(agent_id)
+
+          if agent_id == -1
+            raise Fog::Rackspace::Monitoring::BadRequest
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "info"  => [
+              {
+                "dir_name"        => "/",
+                "dev_name"        => "/dev/xvda1",
+                "sys_type_name"   => "ext4",
+                "options"         => "rw,noatime,acl,errors=remount-ro,barrier=0",
+                "free"            => Fog::Mock.random_numbers(8).to_i,
+                "used"            => Fog::Mock.random_numbers(5).to_i,
+                "avail"           => Fog::Mock.random_numbers(7).to_i,
+                "total"           => Fog::Mock.random_numbers(9).to_i,
+                "files"           => Fog::Mock.random_numbers(6).to_i,
+                "free_files"      => Fog::Mock.random_numbers(6).to_i,
+              },
+              {
+                "dir_name"        => "/proc",
+                "dev_name"        => "proc",
+                "sys_type_name"    => "ext4",
+                "options"         => "rw",
+              }
+            ]
+          }
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/monitoring/get_logged_in_user_info.rb

@@ -0,0 +1,58 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+
+        def get_logged_in_user_info(agent_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents/#{agent_id}/host_info/who"
+          )
+        end
+      end
+
+      class Mock
+        def get_logged_in_user_info(agent_id)
+
+          if agent_id == -1
+            raise Fog::Rackspace::Monitoring::BadRequest
+          end
+          
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "info"  => [
+              {
+                "user"      => "root",
+                "device"    => "pts/1",
+                "time"      => Time.now.to_i - 100,
+                "host"      => "somehost1.company.local"
+              },
+              {
+                "user"      => "user123",
+                "device"    => "pts/2",
+                "time"      => Time.now.to_i - 50,
+                "host"      => "somehost2.company.local"
+              }              
+            ]
+          }
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/monitoring/get_memory_info.rb

@@ -0,0 +1,59 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+
+        def get_memory_info(agent_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents/#{agent_id}/host_info/memory"
+          )
+        end
+      end
+
+      class Mock
+        def get_memory_info(agent_id)
+
+          if agent_id == -1
+            raise Fog::Rackspace::Monitoring::BadRequest
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "info"  => [
+              {
+                "actual_free"     => Fog::Mock.random_numbers(9).to_i,
+                "actual_used"     => Fog::Mock.random_numbers(8).to_i,
+                "free"            => Fog::Mock.random_numbers(7).to_i,
+                "used"            => Fog::Mock.random_numbers(9).to_i,
+                "total"           => Fog::Mock.random_numbers(10).to_i,
+                "ram"           => Fog::Mock.random_numbers(4).to_i,
+                "swap_total"      => Fog::Mock.random_numbers(10).to_i,
+                "swap_used"       => Fog::Mock.random_numbers(8).to_i,
+                "swap_free"       => Fog::Mock.random_numbers(10).to_i,                
+                "swap_page_in"    => Fog::Mock.random_numbers(3).to_i,
+                "swap_page_out"   => Fog::Mock.random_numbers(3).to_i,
+              }
+            ]
+          }
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/monitoring/get_network_interfaces_info.rb

@@ -0,0 +1,91 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+
+        def get_network_interfaces_info(agent_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents/#{agent_id}/host_info/network_interfaces"
+          )
+        end
+      end
+
+      class Mock
+        def get_network_interfaces_info(agent_id)
+
+          if agent_id == -1
+            raise Fog::Rackspace::Monitoring::BadRequest
+          end
+          
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "info"  => [
+              {
+                "name"        => "lo",
+                "type"        => "Local Loopback",
+                "address"     => Fog::Mock.random_ip({:version => :v4}),
+                "netmask"     => "255.0.0.0",
+                "address6"    => "::1",
+                "broadcast"   => "0.0.0.0.0",
+                "hwaddr"      => "00:00:00:00:00:00",
+                "mtu"         => Fog::Mock.random_numbers(4).to_i,
+                "rx_packets"  => Fog::Mock.random_numbers(3).to_i,
+                "rx_bytes"    => Fog::Mock.random_numbers(4).to_i,
+                "tx_packets"  => Fog::Mock.random_numbers(3).to_i,
+                "tx_bytes"    => Fog::Mock.random_numbers(4).to_i,
+                "flags"       => Fog::Mock.random_numbers(2).to_i,
+              },
+              {
+                "name"        => "eth0",
+                "type"        => "Ethernet",
+                "address"     => Fog::Mock.random_ip({:version => :v4}),
+                "netmask"     => "255.255.255.0",
+                "address6"    => Fog::Mock.random_ip({:version => :v6}),
+                "broadcast"   => Fog::Mock.random_ip({:version => :v4}),
+                "hwaddr"      => "A1:B2:C3:D4:E5:F6",
+                "mtu"         => "1500",
+                "rx_packets"  => Fog::Mock.random_numbers(7).to_i,
+                "rx_bytes"    => Fog::Mock.random_numbers(9).to_i,
+                "tx_packets"  => Fog::Mock.random_numbers(7).to_i,
+                "tx_bytes"    => Fog::Mock.random_numbers(9).to_i,
+                "flags"       => Fog::Mock.random_numbers(4).to_i,
+              },
+              {
+                "name"        => "eth1",
+                "type"        => "Ethernet",
+                "address"     => Fog::Mock.random_ip({:version => :v4}),
+                "netmask"     => "255.255.128.0",
+                "address6"    => Fog::Mock.random_ip({:version => :v6}),
+                "broadcast"   => Fog::Mock.random_ip({:version => :v4}),
+                "hwaddr"      => "A2:B3:C4:D5:E6:F7",
+                "mtu"         => "1500",
+                "rx_packets"  => Fog::Mock.random_numbers(7).to_i,
+                "rx_bytes"    => Fog::Mock.random_numbers(9).to_i,
+                "tx_packets"  => Fog::Mock.random_numbers(7).to_i,
+                "tx_bytes"    => Fog::Mock.random_numbers(9).to_i,
+                "flags"       => Fog::Mock.random_numbers(4).to_i,
+              }              
+            ]
+          }
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/monitoring/get_processes_info.rb

@@ -0,0 +1,72 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+
+        def get_processes_info(agent_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents/#{agent_id}/host_info/processes"
+          )
+        end
+      end
+
+      class Mock
+        def get_processes_info(agent_id)
+
+          memory_major_faults = Fog::Mock.random_numbers(1).to_i
+          memory_minor_faults = Fog::Mock.random_numbers(3).to_i
+          memory_page_faults = memory_major_faults+memory_minor_faults
+
+          if agent_id == -1
+            raise Fog::Rackspace::Monitoring::BadRequest
+          end
+          
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "info"  => [
+              {
+                "pid"             => Fog::Mock.random_numbers(4).to_i,
+                "exe_name"        => "/usr/share/nova-agent/0.0.1.38/sbin/nova-agent",
+                "exe_cwd"         => "/",
+                "exe_root"        => "/",
+                "time_total"      => Fog::Mock.random_numbers(3).to_i,
+                "time_sys"        => Fog::Mock.random_numbers(2).to_i,
+                "time_user"       => Fog::Mock.random_numbers(2).to_i,
+                "time_start_time" => Time.now.utc.to_i - 10000,
+                "state_name"      => "nova-agent",
+                "state_ppid"      => Fog::Mock.random_numbers(3).to_i,
+                "state_priority"  => "15",
+                "state_threads"   => Fog::Mock.random_numbers(1).to_i,
+                "memory_size"     => Fog::Mock.random_numbers(9).to_i,
+                "memory_resident" => Fog::Mock.random_numbers(7).to_i,
+                "memory_share"    => Fog::Mock.random_numbers(6).to_i,
+                "memory_major_faults"    => memory_major_faults.to_i,
+                "memory_minor_faults"    => memory_minor_faults.to_i,
+                "memory_page_faults"     => memory_page_faults.to_i,
+                "cred_user"       => "root",
+                "cred_group"      => "root"
+              }
+            ]
+          }
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/monitoring/get_system_info.rb

@@ -0,0 +1,53 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+
+        def get_system_info(agent_id)
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents/#{agent_id}/host_info/system"
+          )
+        end
+      end
+
+      class Mock
+        def get_system_info(agent_id)
+
+          if agent_id == -1
+            raise Fog::Rackspace::Monitoring::BadRequest
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "info"  => [
+              {
+                "name"            => "Linux",
+                "arch"            => "x86_64",
+                "version"         => "2.6.18-308.el5xen",
+                "vendor"          => "CentOS",
+                "vendor_version"  => "5.10"
+              }
+            ]
+          }
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/monitoring/list_agents.rb

@@ -0,0 +1,62 @@
+module Fog
+  module Rackspace
+    class Monitoring
+      class Real
+        def list_agents
+          request(
+            :expects  => [200, 203],
+            :method   => 'GET',
+            :path     => "agents"
+          )
+        end
+      end
+
+      class Mock
+        def list_agents
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+          "values"=>[
+          {
+          	"id"		=> Fog::Rackspace::MockData.uuid,
+          	"last_connected"  => Time.now.to_i - 100
+          },
+          {
+          	"id"		=> Fog::Rackspace::MockData.uuid,
+          	"last_connected"  => Time.now.to_i - 110
+          },
+          {
+          	"id"		=> Fog::Rackspace::MockData.uuid,
+          	"last_connected"  => Time.now.to_i - 120
+          }
+        ],
+                    
+           "metadata" => {
+             "count"       => 1,
+             "limit"       => 100,
+             "marker"      => nil,
+             "next_marker" => nil,
+             "next_href"   => nil
+            }
+          }          
+          
+          response.headers = {
+            "Date"                  => Time.now.utc.to_s,
+            "Content-Type"          => "application/json; charset=UTF-8",
+            "X-RateLimit-Limit"     => "50000",
+            "X-RateLimit-Remaining" => "49627",
+            "X-RateLimit-Window"    => "24 hours",
+            "X-RateLimit-Type"      => "global",
+            "X-Response-Id"         => "j23jlk234jl2j34j",
+            "X-LB"                  => "dfw1-maas-prod-api0",
+            "Vary"                  => "Accept-Encoding",
+            "Transfer-Encoding"     => "chunked"
+          }
+          response.remote_ip = Fog::Mock.random_ip({:version => :v4})
+          response
+        end
+      end
+    end
+  end
+end