class Fog::Rackspace::Monitoring::Mock

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/rackspace/monitoring.rb, line 112
def initialize(options={})
end

Public Instance Methods

create_agent_token(options = {}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/create_agent_token.rb, line 17
def create_agent_token(options = {})
  account_id = Fog::Mock.random_numbers(6).to_s
  token = Fog::Mock.random_letters(50).to_s

  if options == -1
    raise TypeError
  end

  response = Excon::Response.new
  response.status = 201
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/agent_tokens/" + token,
    "X-Object-ID"           => token,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "49627",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "oknwowevown9330wneviniv",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain",
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
create_alarm(entity_id, options = {}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/create_alarm.rb, line 17
def create_alarm(entity_id, options = {})
  alarm_id = Fog::Mock.random_letters(10)
  account_id = Fog::Mock.random_numbers(6).to_s

  if options[:type]
    raise Fog::Rackspace::Monitoring::BadRequest
  end

  response = Excon::Response.new
  response.status = 201
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id.to_s + "/alarms/" + alarm_id,
    "X-Object-ID"           => alarm_id,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "47877",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "laolsgggopnnsv",
    "X-LB"                  => "dfw1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
create_check(entity_id, options = {}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/create_check.rb, line 17
def create_check(entity_id, options = {})
  account_id = Fog::Mock.random_numbers(6).to_s
  mock_id = Fog::Mock.random_letters(10).to_s

  if options[:type] == ""
    raise Fog::Rackspace::Monitoring::BadRequest
  end

  response = Excon::Response.new
  response.status = 201
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/" + entity_id + "/checks/" + mock_id,
    "X-Object-ID"           => mock_id,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "49627",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "knvlknvosnd20038hgouwvn9nv",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain",
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
create_entity(options = {}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/create_entity.rb, line 17
def create_entity(options = {})
  account_id = Fog::Mock.random_numbers(6).to_s
  entity_id = Fog::Mock.random_letters(10)

  if options[:label] == ""
    raise Fog::Rackspace::Monitoring::BadRequest
  end

  response = Excon::Response.new
  response.status = 201
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id,
    "X-Object-ID"           => entity_id,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "47877",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "lakbngf9bgewkgb39sobnsv",
    "X-LB"                  => "dfw1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
delete_agent_token(options = {}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/delete_agent_token.rb, line 15
def delete_agent_token(options = {})
  account_id = Fog::Mock.random_numbers(6).to_s
  token = Fog::Mock.random_letters(50).to_s

  if options == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 201
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/agent_tokens/" + token,
    "X-Object-ID"           => token,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "49627",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "lsknvnslnv2083ovnsdbno00",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain",
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
delete_alarm(entity_id, alarm_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/delete_alarm.rb, line 15
def delete_alarm(entity_id, alarm_id)
  if entity_id == -1 || alarm_id == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 204
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Content-Type"          => "application/json; charset=UTF-8",
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "38687",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "pomsbnio93gm3030fm303.mmowd",
    "X-LB"                  => "ord1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Content-Length"        => "0"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
delete_check(entity_id, check_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/delete_check.rb, line 15
def delete_check(entity_id, check_id)
  if entity_id == -1 || check_id == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 204
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "49627",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => ".rh-lHJL.h-ord1-maas-prod-api1.r-AGRIH406.c-4085336.ts-1377785008661.v-e602877",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain",
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
delete_entity(entity_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/delete_entity.rb, line 15
def delete_entity(entity_id)
  if entity_id == -1
   raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 204
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "47877",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "lakgnnnf9bgewkgb39sobnsv",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
get_agent(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_agent.rb, line 15
def get_agent(agent_id)
  if agent_id == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
        "id"              => Fog::Rackspace::MockData.uuid,
        "last_connected"  => Time.now.to_i - 100,
  }
  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
get_agent_token(id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_agent_token.rb, line 15
def get_agent_token(id)
  token = Fog::Mock.random_letters(50).to_s

  if id == -1
    raise TypeError
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "id"      => token,
    "token"   => token,
    "label"   => "mock_token"
  }
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Content-Type"          => "application/json; charset=UTF-8",
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "47903",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "kvnsdonvosnv92989vbvbob",
    "X-LB"                  => "ord1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
get_alarm(entity_id, alarm_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_alarm.rb, line 15
def get_alarm(entity_id, alarm_id)
  if entity_id == -1 || alarm_id == -1
   raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "id"                    => alarm_id,
    "label"                 => nil,
    "check_id"              => Fog::Mock.random_letters(10),
    "criteria"              => nil,
    "disabled"              => false,
    "notification_plan_id"  => "npTechnicalContactsEmail",
    "metadata"              => nil,
    "created_at"            => Time.now.to_i - 1,
    "updated_at"            => Time.now.to_i
  }
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Content-Type"          => "application/json; charset=UTF-8",
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "38687",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "pomkondbno93gm3030fm303.mmowd",
    "X-LB"                  => "ord1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
get_check(entity_id, check_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_check.rb, line 15
def get_check(entity_id, check_id)
  if entity_id == -1 || check_id == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "id"                    => check_id,
    "label"                 => nil,
    "type"                  => "remote.ping",
    "details"               => {"count"=>5},
    "monitoring_zones_poll" => ["mzord", "mzdfw", "mziad"],
    "timeout"               => 10,
    "period"                => 30,
    "target_alias"          => nil,
    "target_hostname"       => "1.1.1.1",
    "target_resolver"       => "IPv4",
    "disabled"              => false,
    "metadata"              => nil,
    "created_at"            => Time.now.to_i - 1,
    "updated_at"            => Time.now.to_i
  },
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Content-Type"          => "application/json; charset=UTF-8",
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "44676",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "jdnbono34090934nggn",
    "X-LB"                  => "ord1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
get_cpus_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_cpus_info.rb, line 15
def get_cpus_info(agent_id)
  if agent_id == -1
    raise Fog::Rackspace::Monitoring::BadRequest
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "info"  => [
      {
        "name"            => "cpu.0",
        "vendor"          => "AMD",
        "model"           => "Opteron",
        "mhz"             => Fog::Mock.random_numbers(4).to_i,
        "idle"            => Fog::Mock.random_numbers(10).to_i,
        "irq"             => Fog::Mock.random_numbers(5).to_i,
        "soft_irq"        => Fog::Mock.random_numbers(7).to_i,
        "nice"            => Fog::Mock.random_numbers(9).to_i,
        "stolen"          => Fog::Mock.random_numbers(7).to_i,
        "sys"             => Fog::Mock.random_numbers(7).to_i,
        "user"            => Fog::Mock.random_numbers(9).to_i,
        "wait"            => Fog::Mock.random_numbers(7).to_i,
        "total"           => Fog::Mock.random_numbers(11).to_i,
        "total_cores"     => 1,
        "total_sockets"   => 1
      }
    ]
  }
  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
get_disks_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_disks_info.rb, line 15
def get_disks_info(agent_id)
  if agent_id == -1
    raise Fog::Rackspace::Monitoring::BadRequest
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "info"  => [
      {
        "read_bytes"      => Fog::Mock.random_numbers(10).to_i,
        "reads"           => Fog::Mock.random_numbers(6).to_i,
        "rtime"           => Fog::Mock.random_numbers(6).to_i,
        "write_bytes"     => Fog::Mock.random_numbers(10).to_i,
        "writes"          => Fog::Mock.random_numbers(8).to_i,
        "wtime"           => Fog::Mock.random_numbers(9).to_i,
        "time"            => Fog::Mock.random_numbers(7).to_i,
        "name"            => "/dev/xvda1"
      }
    ]
  }
  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
get_entity(entity_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_entity.rb, line 15
def get_entity(entity_id)
  account_id = Fog::Mock.random_numbers(6).to_s
  server_id = Fog::Rackspace::MockData.uuid
  entity_label = Fog::Mock.random_letters(10)

  if entity_id == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "id"            => entity_id,
    "label"         => entity_label,
     "metadata"     => nil,
     "managed"      => false,
     "uri"          => "https://ord.servers.api.rackspacecloud.com/" + account_id + "/servers/" + server_id,
     "agent_id"     => nil,
     "created_at"   => Time.now.to_i - 1,
     "updated_at"   => Time.now.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"         => "j23jlkgmngjl2j34j",
    "X-LB"                  => "dfw1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
get_filesystems_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_filesystems_info.rb, line 15
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
get_logged_in_user_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_logged_in_user_info.rb, line 15
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
get_memory_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_memory_info.rb, line 15
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
get_network_interfaces_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_network_interfaces_info.rb, line 15
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
get_notification(notification_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_notification.rb, line 15
def get_notification(notification_id)
  response = Excon::Response.new
  response.status = 200
  response.body = {
      "created_at" => 1378783452067,
      "details" => {
          "address" => "test@test.com"
      },
      "id" => "ntnJN3MQrA",
      "label" => "my email update test",
      "type" => "email",
      "updated_at" => 1378784136307
  }

  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
end
get_processes_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_processes_info.rb, line 15
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
get_system_info(agent_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/get_system_info.rb, line 15
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
list_agent_tokens(options={}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_agent_tokens.rb, line 16
def list_agent_tokens(options={})
  token = Fog::Mock.random_letters(50).to_s

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values"=> [
      {
        "id"      => token,
        "token"   => token,
        "label"   => "mock_token"
      }
    ],
    "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::Rackspace::MockData.ipv4_address
  response
end
list_agents() click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_agents.rb, line 15
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
list_alarms(entity_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_alarms.rb, line 16
def list_alarms(entity_id)
  if entity_id == -1
   raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values" => [
     {
      "id"                    => Fog::Mock.random_letters(10),
      "label"                 => nil,
      "check_id"              => Fog::Mock.random_letters(10),
      "criteria"              => nil,
      "disabled"              => false,
      "notification_plan_id"  => "npTechnicalContactsEmail",
      "metadata"              => nil,
      "created_at"            => Time.now.to_i - 1,
      "updated_at"            => Time.now.to_i
     }
    ],
      "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" => "38687",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "pomegmgm3030fm303.mmowd",
    "X-LB"                  => "ord1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
list_check_types() click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_check_types.rb, line 15
def list_check_types
  response = Excon::Response.new
  response.status = 200
  response.body = {

    "values" => [
      {
        "type"   => "remote",
        "id"     => "remote.dns",
        "channel"=> "stable",
        "fields" => [
          {
            "name"       => "port",
            "description"=> "Port number (default: 53)",
            "optional"   => true
          },
          {
            "name"       => "query",
            "description"=> "DNS Query",
            "optional"   => false
          },
          {
            "name"        => "record_type",
            "description" => "DNS Record Type",
            "optional"    => false
          }
        ],
        "category" => "remote"
      },

      {
        "type"    => "agent",
        "id"      => "agent.memory",
        "channel" =>"stable",
        "fields"  => [],
        "supported_platforms" => [
          "Linux",
          "Windows"
        ],
        "category" => "agent_system"
      }
    ],

    "metadata" => {
      "count"       => 2,
      "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"         => "zsdvasdtrq345",
    "X-LB"                  => "dfw1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
response.remote_ip = Fog::Rackspace::MockData.ipv4_address
response
end
list_checks(entity_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_checks.rb, line 16
def list_checks(entity_id)
  check_id = Fog::Mock.random_letters(10)

  if entity_id == -1
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values"  => [
      {
        "id"              => check_id,
        "label"           => "load",
        "type"            => "agent.load_average",
        "details"         => {},
        "monitoring_zones_poll" => nil,
        "timeout"         => 10,
        "period"          => 30,
        "target_alias"    => nil,
        "target_hostname" => nil,
        "target_resolver" => nil,
        "disabled"        => false,
        "metadata"        => nil,
        "created_at"      => Time.now.to_i - 1,
        "updated_at"      => Time.now.to_i
      }
    ],
    "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::Rackspace::MockData.ipv4_address
  response
end
list_data_points(entity_id, check_id, metric_name, options) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_data_points.rb, line 16
def list_data_points(entity_id, check_id, metric_name, options)
  if entity_id == -1 || check_id == -1 || metric_name == -1 || options == -1
    raise Fog::Rackspace::Monitoring::BadRequest
  end

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values"  => [],
    "metadata"=> {
      "count"       =>0,
      "limit"       =>nil,
      "marker"      =>nil,
      "next_marker" =>nil,
      "next_href"   =>nil
    }
  }
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "49627",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "slknbnsodb9830unvnve",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Type"          => "application/json; charset=UTF-8",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
list_entities(options={}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_entities.rb, line 16
def list_entities(options={})
  account_id = Fog::Mock.random_numbers(6).to_s
  server_id = Fog::Rackspace::MockData.uuid
  entity_id = Fog::Mock.random_letters(10)
  entity_label = Fog::Mock.random_letters(10)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values"=> [
      {
        "id"           => entity_id,
        "label"        => entity_label,
        "ip_addresses" => {
          "access_ip0_v6" => Fog::Rackspace::MockData.ipv6_address,
          "public0_v4"    => Fog::Rackspace::MockData.ipv4_address,
          "public1_v6"    => Fog::Rackspace::MockData.ipv6_address,
          "access_ip1_v4" => Fog::Rackspace::MockData.ipv4_address,
          "private0_v4"   => Fog::Rackspace::MockData.ipv4_address
        },
        "metadata"     => nil,
        "managed"      => false,
        "uri"          => "https://ord.servers.api.rackspacecloud.com/" + account_id + "/servers/" + server_id,
        "agent_id"     => nil,
        "created_at"   => Time.now.to_i - 1,
        "updated_at"   => Time.now.to_i
      }
  ],
    "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::Rackspace::MockData.ipv4_address
  response
end
list_metrics(entity_id, check_id) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_metrics.rb, line 15
def list_metrics(entity_id, check_id)
    response = Excon::Response.new
    response.status = 200
    response.body = {
      "values" => [
        {
          "name" => "idle_percent_average",
          "unit" => "percent"
        },
        { "name" => "irq_percent_average",
          "unit" => "percent"
        },
        { "name" => "max_cpu_usage",
          "unit" => "percent"
        },
        { "name" => "min_cpu_usage",
          "unit" => "percent"
        },
        { "name" => "stolen_percent_average",
          "unit" => "percent"
        },
        { "name" => "sys_percent_average",
          "unit" => "percent"
        },
        {
          "name" => "usage_average",
          "unit" => "percent"
        },
        { "name" => "user_percent_average",
          "unit" => "percent"
        },
        { "name" => "wait_percent_average",
          "unit" => "percent"
        }
      ],

      "metadata" => {
        "count"       => 9,
        "limit"       => nil,
        "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"         => "zsdvasdtrq345",
    "X-LB"                  => "dfw1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }

  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
  end
list_notification_plans() click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_notification_plans.rb, line 15
def list_notification_plans
  notification_id   = Fog::Mock.random_letters(10)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values" => [
      {
        "id"    => "npTechnicalContactsEmail",
        "label" => "Technical Contacts - Email",
        "critical_state" => [],
        "warning_state"  => [],
        "ok_state" => []
      },

      {
        "id"             => "notification_id",
        "label"          => "mock_label",
        "critical_state" => nil,
        "warning_state"  => nil,
        "ok_state"       => nil,
        "created_at"     => Time.now.to_i - 2,
        "updated_at"     => Time.now.to_i - 1
      }
    ],

    "metadata" => {
      "count"       => 2,
      "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"         =>" zsdvasdtrq345",
    "X-LB"                  => "dfw1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }

  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
list_notifications(options={}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_notifications.rb, line 16
def list_notifications(options={})
  account_id = Fog::Mock.random_numbers(6).to_s
  server_id = Fog::Rackspace::MockData.uuid
  entity_id = Fog::Mock.random_letters(10)
  entity_label = Fog::Mock.random_letters(10)

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values"=> [
      {
          "created_at"=>1378783452067,
          "details"=>{
              "address"=>"test@test.com"
          },
          "id"=>"ntnJN3MQrA",
          "label"=>"my email update test",
          "type"=>"email",
          "updated_at"=>1378784136307
      }
  ],
    "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::Rackspace::MockData.ipv4_address
  response
end
list_overview(options={}) click to toggle source
# File lib/fog/rackspace/requests/monitoring/list_overview.rb, line 16
def list_overview(options={})
  alarm_id   = Fog::Mock.random_letters(10)
  check_id   = Fog::Mock.random_letters(10)
  entity_id  = Fog::Mock.random_letters(10)
  account_id = Fog::Mock.random_numbers(6).to_s
  server_id  = Fog::Rackspace::MockData.uuid

  response = Excon::Response.new
  response.status = 200
  response.body = {
    "values" => [
      {
        "entity" => {
          "id"           => entity_id,
          "label"        => "mock_entity",
          "ip_addresses" => {
            "access_ip0_v6" => Fog::Rackspace::MockData.ipv6_address,
            "public0_v4"    => Fog::Rackspace::MockData.ipv4_address,
            "public1_v6"    => Fog::Rackspace::MockData.ipv6_address,
            "access_ip1_v4" => Fog::Rackspace::MockData.ipv4_address,
            "private0_v4"   => Fog::Rackspace::MockData.ipv4_address
          },
          "metadata" => {
            "testing" => "Bar"
          },
          "managed"    => false,
          "uri"        => "https://ord.servers.api.rackspacecloud.com/" + account_id + "/servers/" + server_id,
          "agent_id"   => nil,
          "created_at" => Time.now.to_i - 1,
          "updated_at" => Time.now.to_i
        },
        "checks"              => [
          {
            "id"              => check_id,
            "label"           => "mock",
            "type"            => "remote.mock",
            "details"         => {},
            "monitoring_zones_poll" => nil,
            "timeout"         => 10,
            "period"          => 30,
            "target_alias"    => nil,
            "target_hostname" => nil,
            "target_resolver" => nil,
            "disabled       " => false,
            "metadata"        => nil,
            "created_at"      => Time.now.to_i - 1,
            "updated_at"      => Time.now.to_i
          }
        ],
        "alarms" => [
          {
            "id"         => alarm_id,
            "label"      => nil,
            "check_id"   => check_id,
            "criteria"   => nil,
            "disabled"   => false,
            "notification_plan_id" => "npTechnicalContactsEmail",
            "metadata"   => nil,
            "created_at" => Time.now.to_i - 1,
            "updated_at" => Time.now.to_i
          }
        ],
        "latest_alarm_states" => []
      }
    ],

    "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"         =>" zsdvasdtrq345",
    "X-LB"                  => "dfw1-maas-prod-api0",
    "Vary"                  => "Accept-Encoding",
    "Transfer-Encoding"     => "chunked"
  }

  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
request(params) click to toggle source
# File lib/fog/rackspace/monitoring.rb, line 115
def request(params)
  Fog::Mock.not_implemented
end
update_alarm(entity_id, alarm_id, options) click to toggle source
# File lib/fog/rackspace/requests/monitoring/update_alarm.rb, line 16
def update_alarm(entity_id, alarm_id, options)
  account_id = Fog::Mock.random_numbers(6).to_s

  if entity_id == -1 || alarm_id == -1 || options[:testing]
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 204
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id.to_s + "/alarms/" + alarm_id,
    "X-Object-ID"           => alarm_id,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "47877",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "laolsgggopsnfksdovnsv",
    "X-LB"                  => "dfw1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
update_check(entity_id, check_id, options) click to toggle source
# File lib/fog/rackspace/requests/monitoring/update_check.rb, line 16
def update_check(entity_id, check_id, options)
   account_id = Fog::Mock.random_numbers(6).to_s

  if entity_id == -1 || check_id == -1 || options[:testing]
    raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 204
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id + "/checks/" + check_id,
    "X-Object-ID"           => check_id,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "49627",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "owbgowb989wno73ubgvw89",
    "X-LB"                  => "ord1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain",
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end
update_entity(entity_id, options) click to toggle source
# File lib/fog/rackspace/requests/monitoring/update_entity.rb, line 16
def update_entity(entity_id, options)
  account_id = Fog::Mock.random_numbers(6).to_s

  if entity_id == -1
   raise Fog::Rackspace::Monitoring::NotFound
  end

  response = Excon::Response.new
  response.status = 204
  response.body = ""
  response.headers = {
    "Date"                  => Time.now.utc.to_s,
    "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id.to_s,
    "X-Object-ID"           => entity_id.to_s,
    "X-RateLimit-Limit"     => "50000",
    "X-RateLimit-Remaining" => "47877",
    "X-RateLimit-Window"    => "24 hours",
    "X-RateLimit-Type"      => "global",
    "X-Response-Id"         => "lakbngf9bsgkn69gb39sobnsv",
    "X-LB"                  => "dfw1-maas-prod-api1",
    "Content-Length"        => "0",
    "Content-Type"          => "text/plain"
  }
  response.remote_ip = Fog::Rackspace::MockData.ipv4_address
  response
end