class Fog::Compute::ProfitBricks::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/profitbricks/compute.rb, line 107
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/profitbricks/compute.rb, line 200
def initialize(options={})
  @profitbricks_username = options[:profitbricks_username]
  @profitbricks_password = options[:profitbricks_password]
end
reset() click to toggle source
# File lib/fog/profitbricks/compute.rb, line 196
def self.reset
  @data = nil
end

Public Instance Methods

clear_data_center(data_center_id) click to toggle source
# File lib/fog/profitbricks/requests/compute/clear_data_center.rb, line 38
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/profitbricks/requests/compute/connect_storage_to_server.rb, line 49
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/profitbricks/requests/compute/create_data_center.rb, line 44
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/profitbricks/requests/compute/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/profitbricks/requests/compute/create_nic.rb, line 49
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/profitbricks/requests/compute/create_server.rb, line 61
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/profitbricks/requests/compute/create_storage.rb, line 49
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/profitbricks/compute.rb, line 205
def data
  self.class.data[@profitbricks_username]
end
delete_data_center(data_center_id) click to toggle source
# File lib/fog/profitbricks/requests/compute/delete_data_center.rb, line 41
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/profitbricks/requests/compute/delete_nic.rb, line 41
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/profitbricks/requests/compute/delete_server.rb, line 41
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/profitbricks/requests/compute/delete_storage.rb, line 41
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/profitbricks/requests/compute/disconnect_storage_from_server.rb, line 43
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/profitbricks/requests/compute/get_all_data_centers.rb, line 21
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/profitbricks/requests/compute/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/profitbricks/requests/compute/get_all_images.rb, line 52
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/profitbricks/requests/compute/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/profitbricks/requests/compute/get_all_nic.rb, line 46
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/profitbricks/requests/compute/get_all_servers.rb, line 49
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/profitbricks/requests/compute/get_all_storages.rb, line 46
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/profitbricks/requests/compute/get_data_center.rb, line 24
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/profitbricks/requests/compute/get_data_center_state.rb, line 24
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/profitbricks/requests/compute/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/profitbricks/requests/compute/get_image.rb, line 55
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/profitbricks/requests/compute/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/profitbricks/requests/compute/get_nic.rb, line 49
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/profitbricks/requests/compute/get_server.rb, line 81
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/profitbricks/requests/compute/get_storage.rb, line 49
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/profitbricks/compute.rb, line 209
def reset_data
  self.class.data.delete(@profitbricks_username)
end
reset_server(server_id) click to toggle source
# File lib/fog/profitbricks/requests/compute/reset_server.rb, line 38
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/profitbricks/requests/compute/set_internet_access.rb, line 45
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/profitbricks/requests/compute/start_server.rb, line 36
def start_server(server_id)

  if server = self.data[:servers].find {
    |attrib| attrib["serverId"] == server_id
  }
    server["machine_state"] = "RUNNING"
    server["provisioning_state"] = "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/profitbricks/requests/compute/stop_server.rb, line 36
def stop_server(server_id)

  if server = self.data[:servers].find {
    |attrib| attrib["serverId"] == server_id
  }
    server["machine_state"] = "SHUTOFF"
    server["provisioning_state"] = "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/profitbricks/requests/compute/update_data_center.rb, line 29
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/profitbricks/requests/compute/update_nic.rb, line 49
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/profitbricks/requests/compute/update_server.rb, line 52
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/profitbricks/requests/compute/update_storage.rb, line 48
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