class Fog::ArubaCloud::Compute::Real

noinspection RubyResolve

Public Class Methods

new(*params) click to toggle source
# File lib/fog/arubacloud/compute.rb, line 172
def initialize(*params)
  super(*params)
end

Public Instance Methods

add_contact(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/add_contact.rb, line 18
def add_contact(data)
  body = self.body('SetAddLoadBalancerContacts').merge(
      :request => {
          :loadBalancerID => data[:id],
          :NotificationContacts => [
              {
                  :NotificationContact => [
                      {
                          :ContactValue => data[:contactvalue],
                          :LoadBalancerContactID => data[:loadbalancercontactid],
                          :Type => data[:type]
                      }
                  ]
              }
          ]
      }
  )

  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetAddLoadBalancerContacts' , 'SetAddLoadBalancerContacts Error')
  }
  Fog::Logger.debug("SetAddLoadBalancerContacts time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
add_instance(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/add_instance.rb, line 18
def add_instance(data)
  body = self.body('SetEnqueueLoadBalancerAddInstances').merge(
      :Instances => {
          :loadBalancerID => data[:id],
          :Instances => [
              {
                  :LoadBalancerInstance => [
                      {
                          :IPAddress => data[:ipaddress]
                      }
                  ]
              }
          ]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueLoadBalancerAddInstances', 'SetEnqueueLoadBalancerAddInstances Error')
  }
  Fog::Logger.debug("SetEnqueueLoadBalancerAddInstances time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
add_lb_rule(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/add_lb_rule.rb, line 18
def add_lb_rule(data)
  body = self.body('SetModifyLoadBalancer').merge(
      :LoadBalancerStartRequest => {
          :loadBalancerID => data[:id],
          :NewLoadBalancerRule => [
              {
                  :BalanceType => data[:balancetype],
                  :Certificate => data[:certificate],
                  :CreationDate => data[:creationdate],
                  :ID => data[:ruleid],
                  :InstancePort => data[:instanceport],
                  :LoadBalancerPort => data[:loadbalancerport],
                  :Protocol => data[:protocol]
              }
          ]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetModifyLoadBalancer', 'SetModifyLoadBalancer Error')
  }
  Fog::Logger.debug("SetModifyLoadBalancer time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
apply_snapshot(id) click to toggle source

Apply (restore) a snapshot on a VM

# File lib/fog/arubacloud/compute/requests/apply_snapshot.rb, line 19
def apply_snapshot(id)
  body = self.body('SetEnqueueServerSnapshot').merge(
    {
      :ServerId => id ,  :SnapshotOperation => Fog::ArubaCloud::Compute::SNAPOPTYPE["Restore"]
    }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueServerSnapshot', 'Error while attempting to restore a snapshot.')
  }
  Fog::Logger.debug("SetEnqueueServerSnapshot time: #{time}")
  if response['Success']
    response_ext = response.merge( {  "Req" => "restore" , "Id" => id })
    response_ext
  else
    raise Fog::ArubaCloud::Errors::RequestError.new(response)
  end

end
archive_vm(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/archive_vm.rb, line 18
def archive_vm(data)
  (service.servers).all.each do |server|
    id = server.id if (server.name).include? data[:name] and (server.vm_type).include? 'pro'
  end
  body = self.body('SetEnqueueServerArchiviation').merge(
      {
          :SetEnqueueServerArchiviation => {
              :ServerId => id
          }
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueServerArchiviation', 'SetEnqueueServerArchiviation Error')
  }
  Fog::Logger.debug("SetEnqueueServerArchiviation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new(response)
  end

end
body(method) click to toggle source
# File lib/fog/arubacloud/compute.rb, line 176
def body(method)
  super(method)
end
create_loadbalancer(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/create_loadbalancer.rb, line 17
def create_loadbalancer(data)
  body = self.body('SetEnqueueLoadBalancerCreation').merge(
        :LoadBalancerCreationRequest => {
            :HealthCheckNotification => data[:healthchecknotification],
            :Name => data[:name],
            :rules => [
                :LoadBalancerRule => [
                    {
                        :BalanceType => data[:balancetype],
                        :Certificate => data[:certificate],
                        :CreationDate => data[:creationdate],
                        :ID => data[:ruleid],
                        :InstancePort => data[:instanceport],
                        :LoadBalancerPort => data[:loadbalancerport],
                        :Protocol => data[:protocol]
                    }
                ]
            ],
            :ipAddressesResourceId => data[:ipaddressesresourceid],
            :NotificationContacts => [
                :NotificationContact => [
                    {
                        :ContactValue => data[:contacvalue],
                        :LoadBalancerContactID => data[:loadbalancercontactid],
                        :Type => data[:type]
                    }
                ]
            ]
        }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueLoadBalancerCreation', 'SetEnqueueLoadBalancerCreation Error')
  }
  Fog::Logger.debug("SetEnqueueLoadBalancerCreation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the Load Balancer creation.')
  end
end
create_scheduled_occurence(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/create_scheduled_occurrence.rb, line 18
def create_scheduled_occurence(data)
  body = self.body('SetAddServerScheduledOperation').merge(
      :NewSchedulePlan => {
          :FirstExecutionTime => data[:dateStart],
          :LastExecutionTime => data[:endDate],
          :OperationType => data[:OperationType],
          :ServerID => data[:ServerId],
      }
  )
  if data[:frequencyType].include? 'Monthly'
    body[:NewSchedulePlan] << {
        :ScheduleDaysOfMonth => [{
            :int => data[:daysOfMonth]
                                       }]
    }
  elsif data[:frequencyType].include? 'MonthlyRelative'
    body[:NewSchedulePlan] << {
        :ScheduledMontlyRecurrence => data[:monthlyRecurrence]
    }
  elsif data[:frequencyType].include? 'Weekly'
    body[:NewSchedulePlan] << {
        :ScheduleWeekDays => [{
            :ScheduleWeekDays => data[:daysOfWeek]
                              }]
    }
  elsif data[:frequencyType].include? 'Daily' or data[:frequencyType].include? 'Hourly'
    body[:NewSchedulePlan] << {
        :ScheduleFrequencyType => data[:frequency]
    }
  end
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetAddServerScheduledOperation', 'SetAddServerScheduledOperation Error')
  }
  Fog::Logger.debug("SetAddServerScheduledOperation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the Scheduled Operation creation.')
  end
end
create_scheduled_operation(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/create_scheduled_operation.rb, line 17
def create_scheduled_operation(data)
  body = {
      :NewSchedulePlan => {
          :FirstExecutionTime => data[:dateStart],
          :LastExecutionTime => data[:endDate],
          :OperationType => data[:OperationType],
          :ServerID => data[:ServerId],
          :ScheduledPlanStatus => 'Enabled'
      }
  }
  self.request(
      body=body,
      method_name='SetAddServerScheduledOperation',
      failure_message='Error configuring Scheduled Operation.',
      benchmark=true
  )
end
create_shared_storage(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/create_shared_storage.rb, line 18
def create_shared_storage(data)
  body = {
      :SharedStorage => {
          :Quantity => data[:quantity],
          :SharedStorageName => data[:sharedstoragename],
          :SharedStorageProtocolType => data[:sharedstorageprotocoltype],
      }
  }
  unless data[:sharedstorageprotocoltype].include? 'ISCSI'
    body[:SharedStorage] << {
        :Value => data[:Value]
    }
  end
  self.request(
      body,
      'SetEnqueuePurchaseSharedStorage',
      'Error during Shared Storage creation.'
  )
end
create_snapshot(id) click to toggle source

Create a new snapshot of a VM

# File lib/fog/arubacloud/compute/requests/create_snapshot.rb, line 20
def create_snapshot(id)
  body = self.body('SetEnqueueServerSnapshot').merge(
    {
      :ServerId => id ,  :SnapshotOperation => Fog::ArubaCloud::Compute::SNAPOPTYPE["Create"]
    }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueServerSnapshot', 'Error while attempting to create a snapshot.')
  }
  Fog::Logger.debug("SetEnqueueServerSnapshot time: #{time}")
  if response['Success']
    response_ext = response.merge( {  "Req" => "create" , "Id" => id })
    response_ext
  else
    raise Fog::ArubaCloud::Errors::RequestError.new(response)
  end

end
create_vm_pro(data) click to toggle source

Create a new VM: Pro. @param [String] name name of the server @param [String] admin_password server administrative password @param [Int] cpu amount of vcpu @param [Int] ram amount of ram in GB @param [String] template_id id of template to use @param [String] ipv4_id if present, the ID of the ip resource to associate @param [String] note Metadata for VM @return [Excon::Response]

# File lib/fog/arubacloud/compute/requests/create_vm_pro.rb, line 25
def create_vm_pro(data)
  body = self.body('SetEnqueueServerCreation').merge(
        {
            :Server => {
                :AdministratorPassword => data[:admin_passwd],
                :CPUQuantity => data[:cpu],
                :Name => data[:name],
                :NetworkAdaptersConfiguration => [],
                :Note => 'Created by Fog Cloud.',
                :OSTemplateId => data[:template_id],
                :RAMQuantity => data[:memory],
                :VirtualDisks => []
            }
        }
    )
    unless data[:ipv4_id].nil?
      body[:Server][:NetworkAdaptersConfiguration] << {
          :NetworkAdapterType => 0,
          :PublicIpAddresses => [{
              :PrimaryIPAddress => 'true',
              :PublicIpAddressResourceId => data[:ipv4_id]
          }]
      }
    end
    unless data[:disks].nil? && data[:disks].instance_of?(Array)
      data[:disks].each { |d| body[:Server][:VirtualDisks] << d}
    end

  response = nil
  time = Benchmark.realtime {
    mymux = Fog::ArubaCloud.getUserMutex
    mymux.synchronize {
      response = request( body, 'SetEnqueueServerCreation', 'Pro_vm creation error')
    }
  }

  Fog::Logger.debug("SetEnqueueServerCreation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new("Error during the VM creation. Object: \n#{body}\nError: \n#{response}")
  end

end
create_vm_smart(data) click to toggle source

Create a new VM: Smart. @param [String] name name of the server @param [String] admin_password server administrative password @param [String] template_id id of template to use @param [Int] size

  • 1 => small

  • 2 => medium

  • 3 => large

  • 4 => extra-large

@param [String] note Metadata for VM @return [Excon::Response]

# File lib/fog/arubacloud/compute/requests/create_vm_smart.rb, line 27
def create_vm_smart(data)
  idPackage = self.get_package_id( data[:package_id] )
  body = self.body('SetEnqueueServerCreation').merge(
      {
          :Server => {
              :AdministratorPassword => data[:admin_passwd],
              :Name => data[:name],
              :SmartVMWarePackageID => idPackage || 1  ,
              :Note => data[:note] || 'Created by Fog Cloud.',
              :OSTemplateId => data[:template_id]
          }
      }
  )

  response = nil
  time = Benchmark.realtime {
    mymux = Fog::ArubaCloud.getUserMutex
    mymux.synchronize {
      response = request( body, 'SetEnqueueServerCreation', "Smart_vm creation error"  )
    }
  }

  Fog::Logger.debug("SetEnqueueServerCreation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new("Error during the VM creation. Object: \n#{body}", response=response)
  end
end
delete_custom_template(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/delete_custom_template.rb, line 19
def delete_custom_template(data)
  body = {
      :template => {
          :templateID => data[:id]
      }
  }
  self.request(
      body=body,
      method_name='SetRemovePersonalTemplate',
      failure_message='Error while attempting to delete custom template.'
  )
end
delete_scheduled_operation(operationid) click to toggle source
# File lib/fog/arubacloud/compute/requests/delete_scheduled_operation.rb, line 18
def delete_scheduled_operation(operationid)
  body = self.body('SetRemoveServerScheduledOperation').merge({:operationid => operationid})
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetRemoveServerScheduledOperation', 'SetRemoveServerScheduledOperation Error')
  }
  Fog::Logger.debug("SetRemoveServerScheduledOperation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
delete_shared_storage(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/delete_shared_storage.rb, line 18
def delete_shared_storage(data)
  body = self.body('SetEnqueueRemoveSharedStorage').merge(
      {
          :SharedStorage => {
              :storageId => data[:id]
          }
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueRemoveSharedStorage', 'SetEnqueueRemoveSharedStorage Error')
  }
  Fog::Logger.debug("SetEnqueueRemoveSharedStorage time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
delete_snapshot(id) click to toggle source

Delete a snapshot on a VM

# File lib/fog/arubacloud/compute/requests/delete_snapshot.rb, line 19
def delete_snapshot(id)
  body = self.body('SetEnqueueServerSnapshot').merge(
    {
      :ServerId => id ,  :SnapshotOperation => Fog::ArubaCloud::Compute::SNAPOPTYPE["Delete"]
    }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueServerSnapshot', 'Error while attempting to delete a snapshot.')
  }
  Fog::Logger.debug("SetEnqueueServerSnapshot time: #{time}")
  if response['Success']
    response_ext = response.merge( {  "Req" => "Delete" , "Id" => id })
    response_ext
  else
    raise Fog::ArubaCloud::Errors::RequestError.new(response)
  end
end
delete_vm(id) click to toggle source
# File lib/fog/arubacloud/compute/requests/delete_vm.rb, line 14
def delete_vm(id)
  body = self.body('SetEnqueueServerDeletion').merge({:ServerId => "#{id}"})
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueServerDeletion', 'SetEnqueueServerDeletion Error')
  }
  Fog::Logger.debug("SetEnqueueServerDeletion time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new("Error Powering off the VM. Error: #{response}")
  end
end
disable_loadbalancer(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/disable_loadbalancer.rb, line 18
def disable_loadbalancer(data)
  body = self.body('SetEnqueueLoadBalancerPowerOff').merge(
      :LoadBalancerPowerOffRequest => {
          :loadBalancerID => data[:id]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueLoadBalancerPowerOff', 'SetEnqueueLoadBalancerPowerOff Error')
  }
  Fog::Logger.debug("SetEnqueueLoadBalancerPowerOff time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
edit_shared_storage(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/edit_shared_storage.rb, line 18
def edit_shared_storage(data)
  body = self.body('SetEnqueueModifySharedStorage').merge(
      {
          :SharedStorage => {
              :Quantity => data[:quantity],
              :storageId => data[:id]
          }
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request( body , 'SetEnqueueModifySharedStorage', 'SetEnqueueModifySharedStorage Error')
  }
  Fog::Logger.debug("SetEnqueueModifySharedStorage time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
enable_loadbalancer(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/enable_loadbalancer.rb, line 18
def enable_loadbalancer(data)
  body = self.body('SetEnqueueLoadBalancerStart').merge(
      :LoadBalancerStartRequest => {
          :loadBalancerID => data[:id]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueLoadBalancerStart', 'SetEnqueueLoadBalancerStart Error')
  }
  Fog::Logger.debug("SetEnqueueLoadBalancerStart time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
get_custom_templates() click to toggle source
# File lib/fog/arubacloud/compute/requests/get_custom_templates.rb, line 18
def get_custom_templates
  body = self.body('GetAvailablePersonalTemplates')
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetAvailablePersonalTemplates', 'GetAvailablePersonalTemplates Error')
  }
  Fog::Logger.debug("GetAvailablePersonalTemplates time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
get_hypervisors() click to toggle source
# File lib/fog/arubacloud/compute/requests/get_hypervisors.rb, line 17
def get_hypervisors
  body = self.body('GetHypervisors')
  response = nil
  time = Benchmark.realtime {
    response = request( body, 'GetHypervisors', "GetHypervisors Error"  )
  }
  Fog::Logger.debug("GetHypervisors time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
get_lb_loads(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/get_lb_loads.rb, line 18
def get_lb_loads(data)
  body = self.body('GetLoadBalancerLoads').merge(
      :GetLoadBalancerLoads => {
          :EndTime => data[:endtime],
          :LoadBalancerID => data[:id],
          :StartTime => data[:starttime]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetLoadBalancerLoads', 'GetLoadBalancerLoads  Error')
  }
  Fog::Logger.debug("GetLoadBalancerLoads time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
get_lb_stats(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/get_lb_stats.rb, line 18
def get_lb_stats(data)
  body = self.body('GetLoadBalancerRuleStatistics').merge(
      :GetLoadBalancerLoads => {
          :EndTime => data[:endtime],
          :loadBalancerRuleID => data[:ruleid],
          :StartTime => data[:starttime]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetLoadBalancerRuleStatistics', 'GetLoadBalancerRuleStatistics Error')
  }
  Fog::Logger.debug("GetLoadBalancerRuleStatistics time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
get_loadbalancer(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/get_loadbalancer.rb, line 18
def get_loadbalancer(data)
  body = self.body('GetLoadBalancers').merge(
      :GetLoadBalancers => {
          :loadBalancerID => data[:id]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'GetLoadBalancers', 'GetLoadBalancers Error')
  }
  Fog::Logger.debug("GetLoadBalancers time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the Load Balancer deletion.')
  end
end
get_notifications(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/get_notifications.rb, line 18
def get_notifications(data)
  body = self.body('GetLoadBalancerNotifications').merge(
      :request => {
          :loadBalancerID => data[:id],
          :EndDate => data[:endtime],
          :StartDate => data[:starttime],
          :LoadBalancerRuleID => data[:ruleid]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'GetLoadBalancerNotifications', 'GetLoadBalancerNotifications Error')
  }
  Fog::Logger.debug("GetLoadBalancerNotifications time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
get_package_id( name="small" ) click to toggle source

Return the correct package id @return [Excon::Response]

# File lib/fog/arubacloud/compute/requests/get_package_id.rb, line 21
def get_package_id( name="small" )
  body_r = self.body('GetPreConfiguredPackages').merge(
    {
      :HypervisorType => 4
    }
  )
  response = nil
  time = Benchmark.realtime {
    response = request( body_r, 'GetPreConfiguredPackages', "Smart_vm getPackageID error"  )
  }
  Fog::Logger.debug("GetPreConfiguredPackages time: #{time}")
  if response['Success']
    response['Value'].each { | package |
      packageId  = package['PackageID']
       package['Descriptions'].each { | description |
        languageID = description['LanguageID']
        packageName = description['Text']
        if (languageID == 2) and (packageName.downcase == name.downcase) then
           return packageId
        end
      }
    }
  else
   raise Fog::ArubaCloud::Errors::RequestError.new("Error during the get_package_id. Object: \n#{body}", response=response)
  end
  return 1
end
get_purchased_ip_addresses() click to toggle source
# File lib/fog/arubacloud/compute/requests/get_purchased_ip_addresses.rb, line 19
def get_purchased_ip_addresses
  body = self.body('GetPurchasedIpAddresses')
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetPurchasedIpAddresses', 'GetPurchasedIpAddresses Error')
  }
  Fog::Logger.debug("GetPurchasedIpAddresses time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Error::RequestError
  end
end
get_scheduled_operations(datestart, dateend) click to toggle source
# File lib/fog/arubacloud/compute/requests/get_scheduled_operations.rb, line 17
def get_scheduled_operations(datestart, dateend)
  body = self.body('GetScheduledOperations').merge({:dateStart => datestart, :dateEnd => dateend})
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetScheduledOperations', 'GetScheduledOperations Error')
  }
  Fog::Logger.debug("GetScheduledOperations time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
get_server_details(server_id) click to toggle source

Return the server details @return [Excon::Response]

# File lib/fog/arubacloud/compute/requests/get_server_details.rb, line 20
def get_server_details(server_id)
  body = self.body('GetServerDetails').merge({:ServerId => server_id})
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetServerDetails', 'GetServerDetails, error')
  }
  Fog::Logger.debug("GetServerDetails time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new( "Error during GetServerDetails request. Error message: \n#{response}" )
  end
end
get_servers() click to toggle source
# File lib/fog/arubacloud/compute/requests/get_servers.rb, line 17
def get_servers
  body = self.body('GetServers')
  response = nil
  time = Benchmark.realtime {
    response = request( body,  'GetServers', "GetServer Error"  )
  }
  Fog::Logger.debug("GetServers time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new(
        "Error during GetServers request. Error message: \n#{response}"
    )
  end
end
get_shared_storage() click to toggle source
# File lib/fog/arubacloud/compute/requests/get_shared_storage.rb, line 18
def get_shared_storage
  body = self.body('GetSharedStorages')
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'GetSharedStorages', 'GetSharedStorages Error')
  }
  Fog::Logger.debug("GetSharedStorages time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
list_snapshot(id) click to toggle source

List snapshot info of a VM if exist a snapshot

# File lib/fog/arubacloud/compute/requests/list_snapshot.rb, line 20
def list_snapshot(id)
  body = self.body('GetServersList').merge(
    {
      :operationRequest =>  {  :ServerStatuses => {}  }
    }
  )
  body = self.body('GetServersList')
  response = nil
  dataresp = nil
  time = Benchmark.realtime {
    dataresp = request( body,  'GetServersList', "GetServersList Error"  )
  }

  if dataresp
    xs = dataresp["Value"]
    if xs
      xs.each do | x |
        if x["ServerId"] == id
          if x["Snapshots"] != [] && x["Snapshots"].length > 0 
            winfo = x['Snapshots'][0]
            wcre = winfo['CreationDate']
            wexp = winfo['ExpirationDate']
            wdatecre = "unknow"
            wdateexp = "unknow"
            if wcre
              w = wcre.match(/\/Date\((\d+\+\d+)\)\//)
              if w && w.length > 1
                wdatecre = DateTime.strptime(w[1], "%Q%z").strftime("%Y-%m-%d %H:%M:%S")
              end
            end
            if wexp
              w = wexp.match(/\/Date\((\d+\+\d+)\)\//)
              if w && w.length > 1
                wdateexp = DateTime.strptime(w[1], "%Q%z").strftime("%Y-%m-%d %H:%M:%S")
              end
            end
            response = { "Success" => true , "credate" => wdatecre , "expdate" => wdateexp , "Req" => "list" , "Id" => id}
            break
          end
        end  
      end
    end
  end

  Fog::Logger.debug("GetServersList time: #{time}")
  if response && response['Success']
    response
  else
    return { "Success" => false , "Req" => "list", "Id" => id }
  end

end
manage_custom_template(data, action='create') click to toggle source
# File lib/fog/arubacloud/compute/requests/manage_custom_template.rb, line 19
def manage_custom_template(data, action='create')
  body = {
      :template => {
          :ApplianceTypeID => data[:ApplianceTypeID],
          :ArchitectureTypeID => data[:ArchitectureTypeID],
          :OSFamilyID => data[:OSFamilyID],
          :OSVersion => data[:OSVersion],
          :Revision => data[:Revision],
          :TemplateBound => [
              :TemplateBound => [
                  {
                      :DefaultValue => data[:DefaultValue],
                      :MaxValue => data[:MaxValue],
                      :MinValue => data[:MinValue],
                      :ResourceType => data[:ResourceType],
                      :TemplateBoundID => data[:TemplateBoundID]
                  }
              ]
          ],
          :TemplateDescription => data[:TemplateDescription],
          :TemplateExternalDescription => data[:TemplateExternalDescription],
          :TemplatePassword => data[:TemplatePassword],
          :TemplateUsername => data[:TemplateUsername],
          :VirtualMachineID => data[:VirtualMachineID]
      }
  }
  if action.eql? 'create'
    method_to_call = 'SetEnqueuePersonalTemplateCreation'
    error_message = 'Error while attempting to delete custom template.'
  elsif action.eql? 'edit'
    method_to_call = 'SetUpdatePersonalTemplate'
    error_message = 'Error while editing custom template.'
  else
    raise Fog::ArubaCloud::Errors::BadParameters.new('Action must be create or edit')
  end
  self.request(
          body,
          method_to_call,
          error_message
  )
end
modify_loadbalancer(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/modify_loadbalancer.rb, line 18
def modify_loadbalancer(data)
  body = self.body('SetModifyLoadBalancer').merge(
      :LoadBalancerStartRequest => {
          :loadBalancerID => data[:id],
          :name => data[:name],
          :healthCheckNotification => data[:healthchecknotification]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetModifyLoadBalancer', 'SetModifyLoadBalancer Error')
  }
  Fog::Logger.debug("SetModifyLoadBalancer time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
power_off_vm(id) click to toggle source
# File lib/fog/arubacloud/compute/requests/power_off_vm.rb, line 17
def power_off_vm(id)
  body = self.body('SetEnqueueServerStop').merge({:ServerId => "#{id}"})
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueServerStop', 'SetEnqueueServerStop Error')
  }
  Fog::Logger.debug("SetEnqueueServerStop time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new("Error Powering off the VM. Error: #{response}")
  end
end
power_on_vm(id) click to toggle source
# File lib/fog/arubacloud/compute/requests/power_on_vm.rb, line 15
def power_on_vm(id)
  body = self.body('SetEnqueueServerStart').merge({:ServerId => "#{id}"})
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetEnqueueServerStart', 'SetEnqueueServerStart Error')
  }
  Fog::Logger.debug("SetEnqueueServerStart time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Error::RequestError
  end
end
purchase_ip() click to toggle source
# File lib/fog/arubacloud/compute/requests/purchase_ip.rb, line 15
def purchase_ip
  body = self.body('SetPurchaseIpAddress')
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetPurchaseIpAddress', 'SetPurchaseIpAddress Error')
  }
  Fog::Logger.debug("SetPurchaseIpAddress time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new("Error purchasing new ip. Error: \n#{response}")
  end
end
reinitialize_vm(id) click to toggle source

Reinitialize a Smart VM @param id [String] the id of the virtual machine to reinitialize @return response [Excon::Response]

# File lib/fog/arubacloud/compute/requests/reinitialize_vm.rb, line 19
def reinitialize_vm(id)
  body = self.body('SetEnqueueReinitializeServer').merge({ :ServerId => id })
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueReinitializeServer', 'SetEnqueueReinitializeServer Error')
  }
  Fog::Logger.debug("SetEnqueueReinitializeServer time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError
  end
end
remove_contact(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/remove_contact.rb, line 18
def remove_contact(data)
  body = self.body('SetRemoveLoadBalancerContacts').merge(
      :request => {
          :loadBalancerID => data[:id],
          :LoadBalancerContactsID => data[:loadbalancercontactid]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetRemoveLoadBalancerContacts', 'SetRemoveLoadBalancerContacts Error')
  }
  Fog::Logger.debug("SetRemoveLoadBalancerContacts time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
remove_instance(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/remove_instance.rb, line 18
def remove_instance(data)
  body = self.body('SetEnqueueLoadBalancerRemoveInstances').merge(
      :Instances => {
          :loadBalancerID => data[:id],
          :Instances => [
              {
                  :LoadBalancerInstance => [
                      {
                          :IPAddress => data[:ipaddress]
                      }
                  ]
              }
          ]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueLoadBalancerRemoveInstances', 'SetEnqueueLoadBalancerRemoveInstances Error')
  }
  Fog::Logger.debug("SetEnqueueLoadBalancerRemoveInstances time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the request.')
  end
end
remove_ip(id) click to toggle source
# File lib/fog/arubacloud/compute/requests/remove_ip.rb, line 15
def remove_ip(id)
  body = self.body('SetRemoveIpAddress').merge(
      {:IpAddressResourceId => id}
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetRemoveIpAddress', 'SetRemoveIpAddress Error')
  }
  Fog::Logger.debug("SetRemoveIpAddress time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Error::RequestError
  end
end
remove_loadbalancer(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/remove_loadbalancer.rb, line 18
def remove_loadbalancer(data)
  body = self.body('SetEnqueueLoadBalancerDeletion').merge(
      :LoadBalancerDeletionRequest => {
          :loadBalancerID => data[:id]
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueLoadBalancerDeletion', 'SetEnqueueLoadBalancerDeletion Error')
  }
  Fog::Logger.debug("SetEnqueueLoadBalancerDeletion time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error during the Load Balancer deletion.')
  end
end
rename_shared_storage(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/rename_shared_storage.rb, line 18
def rename_shared_storage(data)
  body = self.body('SetRenameSharedStorage').merge(
      {
          :SharedStorage => {
              :SharedStorageId => data[:id],
              :SharedStorageName => data[:sharedstoragename]
          }
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetRenameSharedStorage', 'SetRenameSharedStorage Error')
  }
  Fog::Logger.debug("SetRenameSharedStorage time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end
request(body={}, method_name='', failure_message='', benchmark=true) click to toggle source
# File lib/fog/arubacloud/compute.rb, line 180
def request(body={}, method_name='', failure_message='', benchmark=true)
  super(body, method_name, failure_message, benchmark)
end
restore_vm(data) click to toggle source
# File lib/fog/arubacloud/compute/requests/restore_vm.rb, line 18
def restore_vm(data)
  (service.servers).all.each do |server|
    id = server.id if (server.name).include? data[:name] and (server.vm_type).include? 'pro'
  end
  body = self.body('SetEnqueueServerRestore').merge(
      {
          :ServerRestore  => {
              :ServerId => id,
              :CPUQuantity  => cpu,
              :RAMQuantity => memory
          }
      }
  )
  response = nil
  time = Benchmark.realtime {
    response = request(body, 'SetEnqueueServerRestore', 'SetEnqueueServerRestore Error')
  }
  Fog::Logger.debug("SetEnqueueServerRestore time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new(response)
  end

end
suspend_scheduled_operations(operationid) click to toggle source
# File lib/fog/arubacloud/compute/requests/suspend_scheduled_operations.rb, line 18
def suspend_scheduled_operations(operationid)
  body = self.body('SetUpdateServerScheduledOperation').merge({:operationid => operationid})
  response = nil
  time = Benchmark.realtime {
    response = request(body , 'SetUpdateServerScheduledOperation', 'SetUpdateServerScheduledOperation Error')
  }
  Fog::Logger.debug("SetUpdateServerScheduledOperation time: #{time}")
  if response['Success']
    response
  else
    raise Fog::ArubaCloud::Errors::RequestError.new('Error in request.')
  end
end