class Fog::Compute::ProfitBricks::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/compute/profit_bricks.rb, line 109
def self.data
  @data ||= Hash.new do |hash, key|
    hash[key] = {
      :servers     => [],
      :datacenters => [],
      :regions     =>
      [
        {
          'locationId'   => 'c0420cc0-90e8-4f4b-8860-df0a07d18047',
          'locationName' => 'de/fkb',
          'country'      => 'DEU'
        },
        {
          'locationId'   => '68c4099a-d9d8-4683-bdc2-12789aacfa2a',
          'locationName' => 'de/fra',
          'country'      => 'DEU'
        },
        {
          'locationId'   => 'e102ba74-6764-47f3-8896-246141da8ada',
          'locationName' => 'us/las',
          'country'      => 'USA'
        }
      ],
      :images =>
      [
        {
          'imageId'         => 'ece948c0-14f8-4d49-8bdc-b966b746b6f9',
          'imageName'       => 'CentOS-6.5-x86_64-netinstall.iso',
          'imageType'       => 'CDROM',
          'imageSize'       => 244,
          'bootable'        => 'true',
          'cpuHotPlug'      => 'false',
          'cpuHotUnPlug'    => 'false',
          'ramHotPlug'      => 'false',
          'ramHotUnPlug'    => 'false',
          'discVirtioHotPlug'   => 'false',
          'discVirtioHotUnPlug' => 'false',
          'nicHotPlug'      => 'false',
          'nicHotUnPlug'    => 'false',
          'osType'          => 'LINUX',
          'serverIds'       => nil,
          'writeable'       => 'true',
          'location'        => 'us/las',
          'public'          => 'true'
        },
        {
          'imageId'         => 'cc43d811-c423-402c-8bd0-6a04073a65ca',
          'imageName'       => 'CentOS-6-server',
          'imageType'       => 'HDD',
          'imageSize'       => 11264,
          'bootable'        => 'true',
          'cpuHotPlug'      => 'false',
          'cpuHotUnPlug'    => 'false',
          'ramHotPlug'      => 'false',
          'ramHotUnPlug'    => 'false',
          'discVirtioHotPlug'   => 'false',
          'discVirtioHotUnPlug' => 'false',
          'nicHotPlug'      => 'false',
          'nicHotUnPlug'    => 'false',
          'osType'          => 'LINUX',
          'serverIds'       => nil,
          'writeable'       => 'true',
          'location'        => 'us/las',
          'public'          => 'true'
        }
      ],
      :flavors =>
      [
        {
           'flavorId'   => Fog::UUID.uuid,
           'flavorName' => 'Micro',
           'ram'        => 1024,
           'disk'       => 50,
           'cores'      => 1
        },
        {
           'flavorId'   => Fog::UUID.uuid,
           'flavorName' => 'Small',
           'ram'        => 2048,
           'disk'       => 50,
           'cores'      => 1
        }
      ],
      :volumes => [],
      :interfaces => []
    }
  end
end
new(options={}) click to toggle source
# File lib/fog/compute/profit_bricks.rb, line 202
def initialize(options={})
  @profitbricks_username = options[:profitbricks_username]
  @profitbricks_password = options[:profitbricks_password]
end
reset() click to toggle source
# File lib/fog/compute/profit_bricks.rb, line 198
def self.reset
  @data = nil
end

Public Instance Methods

clear_data_center(data_center_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/clear_data_center.rb, line 36
def clear_data_center(data_center_id)
  response        = Excon::Response.new
  response.status = 200
  response.body   = {
    "clearDataCenterResponse" => {
      "requestId"         => Fog::Mock::random_numbers(7),
      "dataCenterId"      => Fog::UUID.uuid,
      "dataCenterVersion" => 1,
    }
  }
  response
end
connect_storage_to_server(storage_id, server_id, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/connect_storage_to_server.rb, line 47
def connect_storage_to_server(storage_id, server_id, options={})

  if storage = self.data[:volumes].find {
      |attrib| attrib['storageId'] == storage_id
  }
  else
    raise Fog::Errors::NotFound.new(
              'The requested volume could not be found'
          )
  end

  if server = self.data[:servers].find {
      |attrib| attrib['serverId'] == server_id
  }
    server['connectedStorages'] << storage
  else
    raise Fog::Errors::NotFound.new(
              'The requested server could not be found'
          )
  end

  response = Excon::Response.new
  response.status = 200
  response.body =
      { 'connectStorageToServerResponse' =>
            {
                'requestId' => Fog::Mock::random_numbers(7),
                'dataCenterId' => Fog::UUID.uuid,
                'dataCenterVersion' => 1
            }
      }
  response
end
create_data_center(data_center_name='', location='') click to toggle source
# File lib/fog/compute/profit_bricks/requests/create_data_center.rb, line 42
def create_data_center(data_center_name='', location='')

    data_center = {
        'requestId'         => Fog::Mock::random_numbers(7),
        'dataCenterId'      => Fog::UUID.uuid,
        'dataCenterName'    => data_center_name || '',
        'location'          => location || '',
        'dataCenterVersion' => 1,
        'provisioningState' => 'AVAILABLE'
    }

    self.data[:datacenters] << data_center
    response        = Excon::Response.new
    response.status = 200
    response.body   = { 'createDataCenterResponse' => data_center }
    response
end
create_flavor(flavor_name, ram, cores) click to toggle source
# File lib/fog/compute/profit_bricks/requests/create_flavor.rb, line 22
def create_flavor(flavor_name, ram, cores)
    response = Excon::Response.new
    response.status = 200

    flavor = {
      'id'    => Fog::UUID.uuid,
      'name'  => flavor_name,
      'ram'   => ram,
      'cores' => cores
    }

    self.data[:flavors] << flavor
    response.body = { 'createFlavorResponse' => flavor }
    response
end
create_nic(server_id, lan_id, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/create_nic.rb, line 47
def create_nic(server_id, lan_id, options={})
  response = Excon::Response.new
  response.status = 200

  nic_id = Fog::UUID.uuid
  nic = {
      'nicId'             => nic_id,
      'lanId'             => lan_id,
      'nicName'           => options['nicName'] || '',
      'internetAccess'    => options['internetAccess'] || 'false',
      'ip'                => options['ip'] || nil,
      'macAddress'        => Fog::Mock::random_hex(12),
      'firewall'          => {},
      'dhcpActive'        => options['dhcpActive'] || 'false',
      'provisioningState' => 'AVAILABLE'
  }

  self.data[:interfaces] << nic
  response.body = {
      'createNicResponse' =>
          {
              'requestId'         => Fog::Mock::random_numbers(7),
              'dataCenterId'      => Fog::UUID.uuid,
              'dataCenterVersion' => 1,
              'nicId'             => nic_id
          }
  }
  response
end
create_server(data_center_id, cores, ram, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/create_server.rb, line 59
def create_server(data_center_id, cores, ram, options={})
  server_id = Fog::UUID.uuid

  server = {
      'serverId'             => server_id,
      'cores'                => cores,
      'ram'                  => ram,
      'serverName'           => options['serverName'],
      'internetAccess'       => options['internetAccess'] || 'false',
      #'ips'                  => options['ips'] || '',
      'connectedStorages'    => options['connectedStorages'] || [],
      'romDrives'            => options['romDrives'] || [],
      'nics'                 => options['nics'] || [],
      'provisioningState'    => 'AVAILABLE',
      'virtualMachineState'  => 'RUNNING',
      'creationTime'         => Time.now,
      'lastModificationTime' => Time.now,
      'osType'               => options['osType'] || 'UNKNOWN',
      'availabilityZone'     => options['availabilityZone'] || 'AUTO',
      'dataCenterId'         => Fog::UUID.uuid,
      'dataCenterVersion'    => 1
      ##'cpuHotPlug'           => 'true',
      ##'ramHotPlug'           => 'true',
      ##'nicHotPlug'           => 'true',
      ##'nicHotUnPlug'         => 'true',
      ##'discVirtioHotPlug'    => 'true',
      ##'discVirtioHotUnPlug'  => 'true'
  }

  self.data[:servers] << server

  response = Excon::Response.new
  response.status = 200
  response.body = {
      'createServerResponse' => {
          'requestId'         => Fog::Mock::random_numbers(7),
          'dataCenterId'      => Fog::UUID.uuid,
          'dataCenterVersion' => 1,
          'serverId'          => server_id
      }
  }
  response
end
create_storage(data_center_id, size, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/create_storage.rb, line 47
def create_storage(data_center_id, size, options={})
    response = Excon::Response.new
    response.status = 200

    if data_center = self.data[:datacenters].find {
        |attrib| attrib['dataCenterId'] == data_center_id
    }
        data_center['dataCenterVersion'] += 1
    else
        raise Fog::Errors::NotFound.new('Data center resource could not be found')
    end

    if image = self.data[:images].find {
        |attrib| attrib['imageId'] == options['mountImageId']
    }
        mount_image = {
            'imageId'   => options['mountImageId'],
            'imageName' => image['imageName']
        }
    end

    storage_id = Fog::UUID.uuid
    storage = {
        'dataCenterId'         => data_center_id,
        'dataCenterVersion'    => data_center['dataCenterVersion'],
        'storageId'            => storage_id,
        'size'                 => size,
        'storageName'          => options['storageName'] || '',
        'mountImage'           => mount_image || {},
        'provisioningState'    => 'AVAILABLE',
        'creationTime'         => Time.now,
        'lastModificationTime' => Time.now,
        'profitBricksImagePassword' => options['profitBricksImagePassword'] || ''
    }

    self.data[:volumes] << storage
    response.body = {
      'createStorageResponse' => {
        'requestId'         => Fog::Mock::random_numbers(7),
        'dataCenterId'      => Fog::UUID.uuid,
        'dataCenterVersion' => 1,
        'storageId'         => storage_id
      }
    }
    response
end
data() click to toggle source
# File lib/fog/compute/profit_bricks.rb, line 207
def data
  self.class.data[@profitbricks_username]
end
delete_data_center(data_center_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/delete_data_center.rb, line 39
def delete_data_center(data_center_id)
    response = Excon::Response.new
    response.status = 200

    if data_center = self.data[:datacenters].find {
      |attrib| attrib['dataCenterId'] == data_center_id
    }
        self.data[:datacenters].delete(data_center)
    else
        raise Fog::Errors::NotFound.new('The requested resource could not be found')
    end

    response.body = { 'deleteDataCenterResponse' => {
        'requestId' => data_center['requestId']
        }
    }
    response
end
delete_nic(nic_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/delete_nic.rb, line 39
def delete_nic(nic_id)
    response = Excon::Response.new
    response.status = 200

    if nic = self.data[:interfaces].find {
      |attrib| attrib['nicId'] == nic_id
    }
        self.data[:interfaces].delete(nic)
    else
        raise Fog::Errors::NotFound.new(
          'The requested NIC could not be found'
        )
    end

    response.body = { 'deleteNicResponse' => {
        'requestId'         => Fog::Mock::random_numbers(7),
        'dataCenterId'      => Fog::UUID.uuid,
        'dataCenterVersion' => 1,
        }
    }
    response
end
delete_server(server_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/delete_server.rb, line 39
def delete_server(server_id)

    if server = self.data[:servers].find {
      |attrib| attrib['serverId'] == server_id
    }
        self.data[:servers].delete(server)
    else
        raise Fog::Errors::NotFound.new(
          'The requested server resource could not be found'
        )
    end

    response        = Excon::Response.new
    response.status = 200
    response.body   = { 'deleteServerResponse' => {
        'requestId'         => Fog::Mock::random_numbers(7),
        'dataCenterId'      => Fog::UUID.uuid,
        'dataCenterVersion' => 1,
        }
    }
    response
end
delete_storage(storage_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/delete_storage.rb, line 39
def delete_storage(storage_id)
    response = Excon::Response.new
    response.status = 200

    if storage = self.data[:volumes].find {
      |attrib| attrib['storageId'] == storage_id
    }
        self.data[:volumes].delete(storage)
    else
        raise Fog::Errors::NotFound.new(
          'The requested resource could not be found'
        )
    end

    response.body = { 'deleteStorageResponse' => {
        'requestId'         => Fog::Mock::random_numbers(7),
        'dataCenterId'      => Fog::UUID.uuid,
        'dataCenterVersion' => 3
        }
    }
    response
end
disconnect_storage_from_server(storage_id, server_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/disconnect_storage_from_server.rb, line 41
def disconnect_storage_from_server(storage_id, server_id)

  if storage = self.data[:volumes].find {
      |attrib| attrib['storageId'] == storage_id
  }
  else
    raise Fog::Errors::NotFound.new(
              'The requested storage resource could not be found'
          )
  end

  if server = self.data[:servers].find {
      |attrib| attrib['serverId'] == server_id
  }['connectedStorages'].delete(storage)
  else
    raise Fog::Errors::NotFound.new(
              'The requested server resource could not be found'
          )
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   =
      { 'disconnectStorageFromServerResponse' =>
            {
                'requestId' => Fog::Mock::random_numbers(7),
                'dataCenterId' => Fog::UUID.uuid,
                'dataCenterVersion' => 1
            }
      }
  response
end
get_all_data_centers() click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_data_centers.rb, line 20
def get_all_data_centers
  response        = Excon::Response.new
  response.status = 200
  response.body   = {
    "getAllDataCentersResponse" => self.data[:datacenters]
  }
  response
end
get_all_flavors() click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_flavors.rb, line 65
def get_all_flavors
    data = self.data[:flavors]
    response        = Excon::Response.new
    response.status = 200
    response.body   = {
        'getAllFlavorsResponse' => self.data[:flavors]
    }
    response
end
get_all_images() click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_images.rb, line 50
def get_all_images()
    if data = self.data[:images]
        response        = Excon::Response.new
        response.status = 200
        response.body   = {
            'getAllImagesResponse' => self.data[:images]
        }
        response
    else
        raise Fog::Compute::NotFound
    end
end
get_all_locations(options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_locations.rb, line 32
def get_all_locations(options={})
    data = self.data[:regions]
    response        = Excon::Response.new
    response.status = 200
    response.body   = {
        'getAllLocationsResponse' => self.data[:regions]
    }
    response
end
get_all_nic() click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_nic.rb, line 44
def get_all_nic
    response        = Excon::Response.new
    response.status = 200
    response.body   = { 'getAllNicResponse' => self.data[:interfaces] }
    response
end
get_all_servers() click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_servers.rb, line 48
def get_all_servers
  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getAllServersResponse" => self.data[:servers] }
  response
end
get_all_storages() click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_all_storages.rb, line 44
def get_all_storages
    data = self.data[:volumes]
    response        = Excon::Response.new
    response.status = 200
    response.body   = {
      'getAllStoragesResponse' => self.data[:volumes]
    }
    response
end
get_data_center(data_center_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_data_center.rb, line 22
def get_data_center(data_center_id)
  if dc = self.data[:datacenters].find {
    |attrib| attrib["dataCenterId"] == data_center_id
  }
  else
    raise Fog::Errors::NotFound.new("The requested resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getDataCenterResponse" => dc }
  response
end
get_data_center_state(data_center_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_data_center_state.rb, line 23
def get_data_center_state(data_center_id)
    if data = self.data[:datacenters]
        dc = self.data[:datacenters].find {
          |attrib| attrib['dataCenterId'] == data_center_id
        }

        response        = Excon::Response.new
        response.status = 200
        response.body   = { 'getDataCenterStateResponse' =>
          { 'return' => dc['provisioningState'] }
        }
        response
    else
        raise Fog::Compute::NotFound
    end
end
get_flavor(flavor_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_flavor.rb, line 65
def get_flavor(flavor_id)
  response        = Excon::Response.new
  response.status = 200

  if flavor = self.data[:flavors].find {
    |attrib| attrib["flavorId"] == flavor_id
  }
  else
    raise Fog::Errors::NotFound.new("The requested flavor could not be found")
  end

  response.body = { "getFlavorResponse" => flavor }
  response
end
get_image(image_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_image.rb, line 53
def get_image(image_id)
  if data_center = self.data[:images].find {
    |attrib| attrib["imageId"] == image_id
  }
  else
    raise Fog::Errors::NotFound.new("The requested resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getImageResponse" => data_center }
  response
end
get_location(location_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_location.rb, line 32
def get_location(location_id)
  if location = self.data[:regions].find {
    |attrib| attrib["locationId"] == location_id
  }
  else
    raise Fog::Errors::NotFound.new("The requested resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getLocationResponse" => location }
  response
end
get_nic(nic_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_nic.rb, line 47
def get_nic(nic_id)
  if nic = self.data[:interfaces].find {
    |attrib| attrib["nicId"] == nic_id
  }
  else
    raise Fog::Errors::NotFound.new("The requested resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getNicResponse" => nic }
  response
end
get_server(server_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_server.rb, line 79
def get_server(server_id)

  if server = self.data[:servers].find {
    |attrib| attrib["serverId"] == server_id
  }
  else
    raise Fog::Errors::NotFound.new("The server resource could not be found")
  end

  server["requestId"] = Fog::Mock::random_numbers(7)

  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getServerResponse" => server }
  response
end
get_storage(storage_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/get_storage.rb, line 47
def get_storage(storage_id)
  if storage = self.data[:volumes].find {
    |attrib| attrib["storageId"] == storage_id
  }
  else
    raise Fog::Errors::NotFound.new("The requested resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = { "getStorageResponse" => storage }
  response
end
reset_data() click to toggle source
# File lib/fog/compute/profit_bricks.rb, line 211
def reset_data
  self.class.data.delete(@profitbricks_username)
end
reset_server(server_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/reset_server.rb, line 36
def reset_server(server_id)
  response        = Excon::Response.new
  response.status = 200
  response.body   = {
    "resetServerResponse" => {
      "requestId" => Fog::Mock::random_numbers(7)
    }
  }
  response
end
set_internet_access(data_center_id, lan_id, internet_access) click to toggle source
# File lib/fog/compute/profit_bricks/requests/set_internet_access.rb, line 43
def set_internet_access(data_center_id, lan_id, internet_access)
  response        = Excon::Response.new
  response.status = 200
  response.body   = {
      'setInternetAccessResponse' =>
          {
              'requestId'         => Fog::Mock::random_numbers(7),
              'dataCenterId'      => Fog::UUID.uuid,
              'dataCenterVersion' => 1
          }
  }
  response
end
start_server(server_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/start_server.rb, line 35
def start_server(server_id)

  if server = self.data[:servers].find {
    |attrib| attrib["serverId"] == server_id
  }
    server["virtualMachineState"] = "RUNNING"
    server["provisioningState"] = "AVAILABLE"
  else
    raise Fog::Errors::NotFound.new("The requested server resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = {
    "startServerResponse" => {
      "requestId" => Fog::Mock::random_numbers(7)
    }
  }
  response
end
stop_server(server_id) click to toggle source
# File lib/fog/compute/profit_bricks/requests/stop_server.rb, line 35
def stop_server(server_id)

  if server = self.data[:servers].find {
    |attrib| attrib["serverId"] == server_id
  }
    server["virtualMachineState"] = "SHUTOFF"
    server["provisioningState"] = "INACTIVE"
  else
    raise Fog::Errors::NotFound.new("The requested server resource could not be found")
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = {
    "stopServerResponse" => {
      "requestId" => Fog::Mock::random_numbers(7)
    }
  }
  response
end
update_data_center(data_center_id, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/update_data_center.rb, line 28
def update_data_center(data_center_id, options={})

    if data_center = self.data[:datacenters].find {
      |attrib| attrib['dataCenterId'] == data_center_id
    }
        data_center['dataCenterName'] = options['dataCenterName']
        data_center['dataCenterVersion'] += 1
    else
        raise Fog::Errors::NotFound.new('The requested resource could not be found')
    end

    response        = Excon::Response.new
    response.status = 200
    response.body   = {
        'updateDataCenterResponse' =>
        {
            'requestId'         => Fog::Mock::random_numbers(7),
            'dataCenterId'      => Fog::UUID.uuid,
            'dataCenterVersion' => 1
        }
    }
    response
end
update_nic(nic_id, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/update_nic.rb, line 47
def update_nic(nic_id, options={})

  if nic = self.data[:interfaces].find {
      |attrib| attrib['nicId'] == nic_id
  }
    options.each do |key, value|
      nic[key] = value
    end
  else
    raise Fog::Errors::NotFound.new('The requested NIC could not be found')
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = {
      'updateNicResponse' =>
          {
              'requestId'         => Fog::Mock::random_numbers(7),
              'dataCenterId'      => Fog::UUID.uuid,
              'dataCenterVersion' => 1
          }
  }
  response
end
update_server(server_id, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/update_server.rb, line 50
def update_server(server_id, options={})

  if server = self.data[:servers].find {
      |attrib| attrib['serverId'] == server_id
  }
    options.each do |key, value|
      server[key] = value
    end
  else
    raise Fog::Errors::NotFound.new(
              'The requested server resource could not be found'
          )
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = {
      'updateServerResponse' =>
          {
              'requestId'         => Fog::Mock::random_numbers(7),
              'dataCenterId'      => Fog::UUID.uuid,
              'dataCenterVersion' => 1
          }
  }
  response
end
update_storage(storage_id, options={}) click to toggle source
# File lib/fog/compute/profit_bricks/requests/update_storage.rb, line 46
def update_storage(storage_id, options={})

  if storage = self.data[:volumes].find {
      |attrib| attrib['storageId'] == storage_id
  }
    options.each do |key, value|
      storage[key] = value
    end
  else
    raise Fog::Errors::NotFound.new('The requested resource could not be found')
  end

  response        = Excon::Response.new
  response.status = 200
  response.body   = {
      'updateStorageResponse' =>
          {
              'requestId'         => Fog::Mock::random_numbers(7),
              'dataCenterId'      => Fog::UUID.uuid,
              'dataCenterVersion' => 1
          }
  }
  response
end