class Deltacloud::Drivers::Mock::MockDriver

Constants

REALMS

Public Class Methods

new() click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 87
def initialize
  if ENV["DELTACLOUD_MOCK_STORAGE"]
    storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
  elsif Etc.getlogin
    storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
  else
    raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
  end
  @client = Client.new(storage_root)
end

Public Instance Methods

address_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 111
def address_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    address_templates = @client.load_all_cimi(:address_template).map{|addr_templ| CIMI::Model::AddressTemplate.from_json(addr_templ)}
    address_templates.map{|addr_templ|convert_cimi_mock_urls(:address_template, addr_templ, opts[:env])}.flatten
  else
    address_template = CIMI::Model::AddressTemplate.from_json(@client.load_cimi(:address_template, opts[:id]))
    convert_cimi_mock_urls(:address_template, address_template, opts[:env])
  end
end
addresses(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 339
def addresses(credentials, opts={})
  check_credentials(credentials)
  addresses = @client.build_all(Address)
  addresses = filter_on( addresses, :id, opts )
end
associate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 359
def associate_address(credentials, opts={})
  check_credentials(credentials)
  address = @client.load_collection(:addresses, opts[:id])
  raise "AddressInUse" unless address[:instance_id].nil?
  instance = @client.load_collection(:instances, opts[:instance_id])
  address[:instance_id] = instance[:id]
  instance[:public_addresses] = [InstanceAddress.new(address[:id])]
  @client.store(:addresses, address)
  @client.store(:instances, instance)
end
attach_storage_volume(credentials, opts={}) click to toggle source

opts: {:id=,:instance_id,:device}

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 287
def attach_storage_volume(credentials, opts={})
  check_credentials(credentials)
  attach_volume_instance(opts[:id], opts[:device], opts[:instance_id])
end
blob_data(credentials, bucket_id, blob_id, opts = {}) { |part| ... } click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 435
def blob_data(credentials, bucket_id, blob_id, opts = {})
  check_credentials(credentials)
  if blob = @client.load_collection(:blobs, blob_id)
    #give event machine a chance
    sleep 1
    blob[:content].split('').each {|part| yield part}
  end
end
blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 489
def blob_metadata(credentials, opts={})
  check_credentials(credentials)
  if blob = @client.load_collection(:blobs, opts[:id])
    blob[:user_metadata]
  else
    nil
  end
end
blobs(credentials, opts = {}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 425
def blobs(credentials, opts = {})
  check_credentials(credentials)
  blobs = @client.build_all(Blob)
  filter_on( blobs, :bucket, :bucket => opts['bucket'] )
  filter_on( blobs, :id, opts )
end
buckets(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 384
def buckets(credentials, opts={})
  check_credentials(credentials)
  buckets = @client.build_all(Bucket)
  blob_map = @client.load_all(:blobs).inject({}) do |map, blob|
    map[blob[:bucket]] ||= []
    map[blob[:bucket]] << blob[:id]
    map
  end
  buckets.each { |bucket| bucket.blob_list = blob_map[bucket.id] }
  filter_on( buckets, :id, opts )
end
create_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 345
def create_address(credentials, opts={})
  check_credentials(credentials)
  address = {:id => allocate_mock_address.to_s, :instance_id=>nil}
  @client.store(:addresses, address)
  Address.new(address)
end
create_blob(credentials, bucket_id, blob_id, blob_data, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 447
def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
  check_credentials(credentials)
  blob_meta = BlobHelper::extract_blob_metadata_hash(opts)
  blob = {
    :id => blob_id,
    :name => blob_id,
    :bucket => bucket_id,
    :last_modified => Time.now,
    :user_metadata => BlobHelper::rename_metadata_headers(blob_meta, ''),
  }
  if blob_data.kind_of? Hash
    blob_data[:tempfile].rewind
    blob.merge!({
      :content_length => blob_data[:tempfile].length,
      :content_type => blob_data[:type],
      :content => blob_data[:tempfile].read
    })
  elsif blob_data.kind_of? String
    blob.merge!({
      :content_length => blob_data.size,
      :content_type => 'text/plain',
      :content => blob_data
    })
  end
  @client.store(:blobs, blob)
  Blob.new(blob)
end
create_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 399
def create_bucket(credentials, name, opts={})
  check_credentials(credentials)
  bucket = {
    :id => name,
    :name=>name,
    :size=>'0',
    :blob_list=>[]
  }
  @client.store(:buckets, bucket)
  Bucket.new(bucket)
end
create_image(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 132
def create_image(credentials, opts={})
  check_credentials(credentials)
  instance = instance(credentials, :id => opts[:id])
  safely do
    raise 'CreateImageNotSupported' unless instance and instance.can_create_image?
    image = {
      :id => opts[:name],
      :name => opts[:name],
      :owner_id => 'root',
      :state => "AVAILABLE",
      :description => opts[:description],
      :architecture => 'i386'
    }
    @client.store(:images, image)
    Image.new(image)
  end
end
create_instance(credentials, image_id, opts) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 176
def create_instance(credentials, image_id, opts)
  check_credentials( credentials )
  ids = @client.members(:instances)

  count = 0
  while true
    next_id = "inst" + count.to_s
    if not ids.include?(next_id)
      break
    end
    count = count + 1
  end

  realm_id = opts[:realm_id]
  if ( realm_id.nil? )
    realm = realms(credentials).first
    ( realm_id = realm.id ) if realm
  end

  hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
  hwp ||= find_hardware_profile(credentials, 'm1-small', image_id)

  name = opts[:name] || "i-#{Time.now.to_i}"

  instance = {
    :id => next_id,
    :name=>name,
    :state=>'RUNNING',
    :keyname => opts[:keyname],
    :image_id=>image_id,
    :owner_id=>credentials.user,
    :public_addresses=>[ InstanceAddress.new("#{image_id}.#{next_id}.public.com", :type => :hostname) ],
    :private_addresses=>[ InstanceAddress.new("#{image_id}.#{next_id}.private.com", :type => :hostname) ],
    :instance_profile => InstanceProfile.new(hwp.name, opts),
    :realm_id=>realm_id,
    :create_image=>true,
    :actions=>instance_actions_for( 'RUNNING' ),
    :user_data => opts[:user_data] ? Base64::decode64(opts[:user_data]) : nil
  }
  @client.store(:instances, instance)
  Instance.new( instance )
end
create_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 319
def create_key(credentials, opts={})
  check_credentials(credentials)
  key_hash = {
    :id => opts[:key_name],
    :credential_type => :key,
    :fingerprint => Key::generate_mock_fingerprint,
    :pem_rsa_key => Key::generate_mock_pem
  }
  safely do
    raise "KeyExist" if @client.load_collection(:keys, key_hash[:id])
    @client.store(:keys, key_hash)
  end
  return Key.new(key_hash)
end
create_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 266
def create_storage_volume(credentials, opts={})
  check_credentials(credentials)
  opts[:capacity] ||= "1"
  id = "Volume#{Time.now.to_i}"
  volume = {
        :id => id,
        :name => opts[:name] ? opts[:name] : id,
        :created => Time.now.to_s,
        :state => "AVAILABLE",
        :capacity => opts[:capacity],
  }
  @client.store(:storage_volumes, volume)
  StorageVolume.new(volume)
end
delete_blob(credentials, bucket_id, blob_id, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 478
def delete_blob(credentials, bucket_id, blob_id, opts={})
  check_credentials(credentials)
  safely do
    raise "NotExistentBlob" unless @client.load_collection(:blobs, blob_id)
    @client.destroy(:blobs, blob_id)
  end
end
delete_bucket(credentials, name, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 414
def delete_bucket(credentials, name, opts={})
  check_credentials(credentials)
  bucket = bucket(credentials, {:id => name})
  raise 'BucketNotExist' if bucket.nil?
  raise "BucketNotEmpty" unless bucket.blob_list.empty?
  @client.destroy(:buckets, bucket.id)
end
destroy_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 352
def destroy_address(credentials, opts={})
  check_credentials(credentials)
  address = @client.load_collection(:addresses, opts[:id])
  raise "AddressInUse" unless address[:instance_id].nil?
  @client.destroy(:addresses, opts[:id])
end
destroy_image(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 150
def destroy_image(credentials, id)
  check_credentials( credentials )
  @client.destroy(:images, id)
end
destroy_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 240
def destroy_instance(credentials, id)
  check_credentials( credentials )
  @client.destroy(:instances, id)
end
destroy_key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 334
def destroy_key(credentials, opts={})
  key = key(credentials, opts)
  @client.destroy(:keys, key.id)
end
destroy_storage_volume(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 281
def destroy_storage_volume(credentials, opts={})
  check_credentials(credentials)
  @client.destroy(:storage_volumes, opts[:id])
end
detach_storage_volume(credentials, opts) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 292
def detach_storage_volume(credentials, opts)
  check_credentials(credentials)
  detach_volume_instance(opts[:id], opts[:instance_id])
end
disassociate_address(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 370
def disassociate_address(credentials, opts={})
  check_credentials(credentials)
  address = @client.load_collection(:addresses, opts[:id])
  raise "AddressNotInUse" unless address[:instance_id]
  instance = @client.load_collection(:instances, address[:instance_id])
  address[:instance_id] = nil
  instance[:public_addresses] = [InstanceAddress.new("#{instance[:image_id]}.#{instance[:id]}.public.com", :type => :hostname)]
  @client.store(:addresses, address)
  @client.store(:instances, instance)
end
forwarding_group_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 67
def forwarding_group_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    forwarding_group_templates = @client.load_all_cimi(:forwarding_group_template).map{|fg_templ| CIMI::Model::ForwardingGroupTemplate.from_json(fg_templ)}
    forwarding_group_templates.map{|fg_templ|convert_cimi_mock_urls(:forwarding_group_template, fg_templ, opts[:env])}.flatten
  else
    forwarding_group_template = CIMI::Model::ForwardingGroupTemplate.from_json(@client.load_cimi(:forwarding_group_template, opts[:id]))
    convert_cimi_mock_urls(:forwarding_group_template, forwarding_group_template, opts[:env])
  end
end
forwarding_groups(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 56
def forwarding_groups(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    forwarding_groups = @client.load_all_cimi(:forwarding_group).map{|fg| CIMI::Model::ForwardingGroup.from_json(fg)}
    forwarding_groups.map{|fg|convert_cimi_mock_urls(:forwarding_group, fg, opts[:env])}.flatten
  else
    forwarding_group = CIMI::Model::ForwardingGroup.from_json(@client.load_cimi(:forwarding_group, opts[:id]))
    convert_cimi_mock_urls(:forwarding_group, forwarding_group, opts[:env])
  end
end
images(credentials, opts=nil ) click to toggle source

Images

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 117
def images(credentials, opts=nil )
  check_credentials( credentials )
  images = []
  images = @client.build_all(Image)
  images = filter_on( images, :id, opts )
  images = filter_on( images, :architecture, opts )
  if ( opts && opts[:owner_id] == 'self' )
    images = images.select{|e| e.owner_id == credentials.user }
  else
    images = filter_on( images, :owner_id, opts )
  end
  images = images.map { |i| (i.hardware_profiles = hardware_profiles(nil)) && i }
  images.sort_by{|e| [e.owner_id, e.description]}
end
instance(credentials, opts={}) click to toggle source

Instances

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 159
def instance(credentials, opts={})
  check_credentials( credentials )
  if instance = @client.load_collection(:instances, opts[:id])
    Instance.new(instance)
  end
end
instances(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 166
def instances(credentials, opts={})
  check_credentials( credentials )
  instances = @client.build_all(Instance)
  instances = filter_on( instances, :owner_id, :owner_id => credentials.user )
  instances = filter_on( instances, :id, opts )
  instances = filter_on( instances, :state, opts )
  instances = filter_on( instances, :realm_id, opts)
  instances
end
key(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 315
def key(credentials, opts={})
  keys(credentials, opts).first
end
keys(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 308
def keys(credentials, opts={})
  check_credentials(credentials)
  result = @client.build_all(Key)
  result = filter_on( result, :id, opts )
  result
end
metric(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 536
def metric(credentials, opts={})
  metric = metrics(credentials, opts).first

  metric.properties.each do |property|

    property.values = (0..5).collect do |i|

      unit = metric_unit_for(property.name)
      average = (property.name == 'cpuUtilization') ? (rand * 1000).to_i / 10.0 : rand(1000)
      max = (property.name == 'cpuUtilization') ? (1000 + 10 * average).to_i / 20.0 : average * (i + 1)
      min = (property.name == 'cpuUtilization') ? (2.5 * average).to_i / 10.0 : (average / 4).to_i
      {
        :minimum   => min,
        :maximum   => max,
        :average   => average,
        :timestamp => Time.now - i * 60,
        :unit      => unit
      }
    end
  end
  metric
end
metrics(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 514
def metrics(credentials, opts={})
  check_credentials( credentials )
  instances = @client.build_all(Instance)
  instances = filter_on( instances, :id, opts )

  metrics_arr = instances.collect do |instance|
    Metric.new(
      :id     => instance.id,
      :entity => instance.name
    )
  end

  # add metric names to metrics
  metrics_arr.each do |metric|
    @@METRIC_NAMES.each do |name|
      metric.add_property(name)
    end
    metric.properties.sort! {|a,b| a.name <=> b.name}
  end
  metrics_arr
end
network_configurations(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 34
def network_configurations(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_configs = @client.load_all_cimi(:network_configuration).map{|net_config| CIMI::Model::NetworkConfiguration.from_json(net_config)}
    network_configs.map{|net_config|convert_cimi_mock_urls(:network_configuration, net_config, opts[:env])}.flatten
  else
    network_config = CIMI::Model::NetworkConfiguration.from_json(@client.load_cimi(:network_configuration, opts[:id]))
    convert_cimi_mock_urls(:network_configuration, network_config, opts[:env])
  end
end
network_port_configurations(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 89
def network_port_configurations(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_port_configurations = @client.load_all_cimi(:network_port_configuration).map{|network_port_config| CIMI::Model::NetworkPortConfiguration.from_json(network_port_config)}
    network_port_configurations.map{|network_port_config|convert_cimi_mock_urls(:network_port_configuration, network_port_config, opts[:env])}.flatten
  else
    network_port_configuration = CIMI::Model::NetworkPortConfiguration.from_json(@client.load_cimi(:network_port_configuration, opts[:id]))
    convert_cimi_mock_urls(:network_port_configuration, network_port_configuration, opts[:env])
  end
end
network_port_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 100
def network_port_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_port_templates = @client.load_all_cimi(:network_port_template).map{|net_port_templ| CIMI::Model::NetworkPortTemplate.from_json(net_port_templ)}
    network_port_templates.map{|net_port_templ|convert_cimi_mock_urls(:network_port_template, net_port_templ, opts[:env])}.flatten
  else
    network_port_template = CIMI::Model::NetworkPortTemplate.from_json(@client.load_cimi(:network_port_template, opts[:id]))
    convert_cimi_mock_urls(:network_port_template, network_port_template, opts[:env])
  end
end
network_ports(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 78
def network_ports(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    ports = @client.load_all_cimi(:network_port).map{|net_port| CIMI::Model::NetworkPort.from_json(net_port)}
    ports.map{|net_port|convert_cimi_mock_urls(:network_port, net_port, opts[:env])}.flatten
  else
    port = CIMI::Model::NetworkPort.from_json(@client.load_cimi(:network_port, opts[:id]))
    convert_cimi_mock_urls(:network_port, port, opts[:env])
  end
end
network_templates(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 45
def network_templates(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    network_templates = @client.load_all_cimi(:network_template).map{|net_templ| CIMI::Model::NetworkTemplate.from_json(net_templ)}
    network_templates.map{|net_templ|convert_cimi_mock_urls(:network_template, net_templ, opts[:env])}.flatten
  else
    network_template = CIMI::Model::NetworkTemplate.from_json(@client.load_cimi(:network_template, opts[:id]))
    convert_cimi_mock_urls(:network_template, network_template, opts[:env])
  end
end
networks(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver_cimi_methods.rb, line 23
def networks(credentials, opts={})
  check_credentials(credentials)
  if opts[:id].nil?
    networks = @client.load_all_cimi(:network).map{|net| CIMI::Model::Network.from_json(net)}
    networks.map{|net|convert_cimi_mock_urls(:network, net ,opts[:env])}.flatten
  else
    network = CIMI::Model::Network.from_json(@client.load_cimi(:network, opts[:id]))
    convert_cimi_mock_urls(:network, network, opts[:env])
  end
end
realms(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 98
def realms(credentials, opts={})
  check_credentials( credentials )
  results = []
  safely do
    # This hack is used to test if client capture exceptions correctly
    # To raise an exception do GET /api/realms/50[0-2]
    raise "DeltacloudErrorTest" if opts and opts[:id] == "500"
    raise "NotImplementedTest" if opts and opts[:id] == "501"
    raise "ProviderErrorTest" if opts and opts[:id] == "502"
    raise "ProviderTimeoutTest" if opts and opts[:id] == "504"
    results = REALMS
  end
  results = filter_on( results, :id, opts )
  results
end
reboot_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 231
def reboot_instance(credentials, id)
  update_instance_state(credentials, id, 'RUNNING')
end
run_on_instance(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 250
def run_on_instance(credentials, opts={})
  ssh = Mock_ssh.new
  ssh.command = opts[:cmd]
  Deltacloud::Runner::Response.new(ssh, "This is where the output would appear if this were not a mock provider")
end
start_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 227
def start_instance(credentials, id)
  update_instance_state(credentials, id, 'RUNNING')
end
stop_instance(credentials, id) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 235
def stop_instance(credentials, id)
  update_instance_state(credentials, id, 'STOPPED')
end
storage_snapshots(credentials, opts=nil) click to toggle source

Storage Snapshots

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 301
def storage_snapshots(credentials, opts=nil)
  check_credentials( credentials )
  snapshots = @client.build_all(StorageSnapshot)
  snapshots = filter_on(snapshots, :id, opts )
  snapshots
end
storage_volumes(credentials, opts=nil) click to toggle source

Storage Volumes

# File lib/deltacloud/drivers/mock/mock_driver.rb, line 259
def storage_volumes(credentials, opts=nil)
  check_credentials( credentials )
  volumes = @client.build_all(StorageVolume)
  volumes = filter_on( volumes, :id, opts )
  volumes
end
update_blob_metadata(credentials, opts={}) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 501
def update_blob_metadata(credentials, opts={})
  check_credentials(credentials)
  safely do
    blob = @client.load_collection(:blobs, opts[:id])
    return false unless blob
    blob[:user_metadata] = BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
    @client.store(:blobs, blob)
  end
end
update_instance_state(credentials, id, state) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 219
def update_instance_state(credentials, id, state)
  instance  = @client.load_collection(:instances, id)
  instance[:state] = state
  instance[:actions] = instance_actions_for( instance[:state] )
  @client.store(:instances, instance)
  Instance.new( instance )
end
valid_credentials?(credentials) click to toggle source
# File lib/deltacloud/drivers/mock/mock_driver.rb, line 559
def valid_credentials?(credentials)
  begin
    check_credentials(credentials)
    return true
  rescue
  end
  return false
end