class Fog::Network::OpenStack::Real

Attributes

current_tenant[R]
current_user[R]

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/openstack/network.rb, line 91
def initialize(options={})
  require 'multi_json'

  @openstack_auth_token = options[:openstack_auth_token]

  unless @openstack_auth_token
    missing_credentials = Array.new
    @openstack_api_key  = options[:openstack_api_key]
    @openstack_username = options[:openstack_username]

    missing_credentials << :openstack_api_key  unless @openstack_api_key
    missing_credentials << :openstack_username unless @openstack_username
    raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
  end

  @openstack_tenant               = options[:openstack_tenant]
  @openstack_auth_uri             = URI.parse(options[:openstack_auth_url])
  @openstack_management_url       = options[:openstack_management_url]
  @openstack_must_reauthenticate  = false
  @openstack_service_name         = options[:openstack_service_name] || ['network']

  @connection_options = options[:connection_options] || {}

  @current_user = options[:current_user]
  @current_tenant = options[:current_tenant]

  authenticate

  @persistent = options[:persistent] || false
  @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
end

Public Instance Methods

create_network(options = {}) click to toggle source
# File lib/fog/openstack/requests/network/create_network.rb, line 6
def create_network(options = {})
  data = { 'network' => {} }

  vanilla_options = [:name, :shared, :admin_state_up, :tenant_id]
  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['network'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [201],
    :method   => 'POST',
    :path     => 'networks'
  )
end
create_port(network_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/create_port.rb, line 6
def create_port(network_id, options = {})
  data = {
    'port' => {
      'network_id' => network_id,
    }
  }

  vanilla_options = [:name, :fixed_ips, :mac_address, :admin_state_up,
                     :device_owner, :device_id, :tenant_id]
  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['port'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [201],
    :method   => 'POST',
    :path     => 'ports'
  )
end
create_subnet(network_id, cidr, ip_version, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/create_subnet.rb, line 6
def create_subnet(network_id, cidr, ip_version, options = {})
  data = {
    'subnet' => {
      'network_id' => network_id,
      'cidr'       => cidr,
      'ip_version' => ip_version,
    }
  }

  vanilla_options = [:name, :gateway_ip, :allocation_pools,
                     :dns_nameservers, :host_routes, :enable_dhcp,
                     :tenant_id]
  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['subnet'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [201],
    :method   => 'POST',
    :path     => 'subnets'
  )
end
credentials() click to toggle source
# File lib/fog/openstack/network.rb, line 123
def credentials
  { :provider                 => 'openstack',
    :openstack_auth_url       => @openstack_auth_uri.to_s,
    :openstack_auth_token     => @auth_token,
    :openstack_management_url => @openstack_management_url,
    :current_user             => @current_user,
    :current_tenant           => @current_tenant }
end
delete_network(network_id) click to toggle source
# File lib/fog/openstack/requests/network/delete_network.rb, line 6
def delete_network(network_id)
  request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => "networks/#{network_id}"
  )
end
delete_port(port_id) click to toggle source
# File lib/fog/openstack/requests/network/delete_port.rb, line 6
def delete_port(port_id)
  request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => "ports/#{port_id}"
  )
end
delete_subnet(subnet_id) click to toggle source
# File lib/fog/openstack/requests/network/delete_subnet.rb, line 6
def delete_subnet(subnet_id)
  request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => "subnets/#{subnet_id}"
  )
end
get_network(network_id) click to toggle source
# File lib/fog/openstack/requests/network/get_network.rb, line 6
def get_network(network_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "networks/#{network_id}"
  )
end
get_port(port_id) click to toggle source
# File lib/fog/openstack/requests/network/get_port.rb, line 6
def get_port(port_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "ports/#{port_id}"
  )
end
get_subnet(subnet_id) click to toggle source
# File lib/fog/openstack/requests/network/get_subnet.rb, line 6
def get_subnet(subnet_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "subnets/#{subnet_id}"
  )
end
list_networks(filters = {}) click to toggle source
# File lib/fog/openstack/requests/network/list_networks.rb, line 6
def list_networks(filters = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'networks',
    :query   => filters
  )
end
list_ports(filters = {}) click to toggle source
# File lib/fog/openstack/requests/network/list_ports.rb, line 6
def list_ports(filters = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'ports',
    :query   => filters
  )
end
list_subnets(filters = {}) click to toggle source
# File lib/fog/openstack/requests/network/list_subnets.rb, line 6
def list_subnets(filters = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'subnets',
    :query   => filters
  )
end
reload() click to toggle source
# File lib/fog/openstack/network.rb, line 132
def reload
  @connection.reset
end
request(params) click to toggle source
# File lib/fog/openstack/network.rb, line 136
def request(params)
  begin
    response = @connection.request(params.merge({
      :headers  => {
        'Content-Type' => 'application/json',
        'Accept' => 'application/json',
        'X-Auth-Token' => @auth_token
      }.merge!(params[:headers] || {}),
      :host     => @host,
      :path     => "#{@path}/#{params[:path]}"#,
      # Causes errors for some requests like tenants?limit=1
      # :query    => ('ignore_awful_caching' << Time.now.to_i.to_s)
    }))
  rescue Excon::Errors::Unauthorized => error
    if error.response.body != 'Bad username or password' # token expiration
      @openstack_must_reauthenticate = true
      authenticate
      retry
    else # bad credentials
      raise error
    end
  rescue Excon::Errors::HTTPStatusError => error
    raise case error
    when Excon::Errors::NotFound
      Fog::Network::OpenStack::NotFound.slurp(error)
    else
      error
    end
  end
  unless response.body.empty?
    response.body = MultiJson.decode(response.body)
  end
  response
end
set_tenant(tenant) click to toggle source
# File lib/fog/openstack/requests/network/set_tenant.rb, line 6
def set_tenant(tenant)
  @openstack_must_reauthenticate = true
  @openstack_tenant = tenant.to_s
  authenticate
end
update_network(network_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/update_network.rb, line 6
def update_network(network_id, options = {})
  data = { 'network' => {} }

  vanilla_options = [:name, :shared, :admin_state_up]
  vanilla_options.select{ |o| options.has_key?(o) }.each do |key|
    data['network'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => 200,
    :method   => 'PUT',
    :path     => "networks/#{network_id}.json"
  )
end
update_port(port_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/update_port.rb, line 6
def update_port(port_id, options = {})
  data = { 'port' => {} }

  vanilla_options = [:name, :fixed_ips, :admin_state_up, :device_owner,
                     :device_id]
  vanilla_options.select{ |o| options.has_key?(o) }.each do |key|
    data['port'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => 200,
    :method   => 'PUT',
    :path     => "ports/#{port_id}.json"
  )
end
update_subnet(subnet_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/update_subnet.rb, line 6
def update_subnet(subnet_id, options = {})
  data = { 'subnet' => {} }

  vanilla_options = [:name, :gateway_ip, :dns_nameservers,
                     :host_routes, :enable_dhcp]
  vanilla_options.select{ |o| options.has_key?(o) }.each do |key|
    data['subnet'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => 200,
    :method   => 'PUT',
    :path     => "subnets/#{subnet_id}"
  )
end

Private Instance Methods

authenticate() click to toggle source
# File lib/fog/openstack/network.rb, line 173
def authenticate
  if @openstack_must_reauthenticate || @openstack_auth_token.nil?
    options = {
      :openstack_tenant   => @openstack_tenant,
      :openstack_api_key  => @openstack_api_key,
      :openstack_username => @openstack_username,
      :openstack_auth_uri => @openstack_auth_uri,
      :openstack_auth_token => @openstack_auth_token,
      :openstack_service_name => @openstack_service_name,
      :openstack_endpoint_type => 'adminURL'
    }

    credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)

    @current_user = credentials[:user]
    @current_tenant = credentials[:tenant]

    @openstack_must_reauthenticate = false
    @auth_token = credentials[:token]
    @openstack_management_url = credentials[:server_management_url]
    uri = URI.parse(@openstack_management_url)
  else
    @auth_token = @openstack_auth_token
    uri = URI.parse(@openstack_management_url)
  end

  @host   = uri.host
  @path   = uri.path
  @path.sub!(/\/$/, '')
  unless @path.match(/^\/v(\d)+(\.)?(\d)*$/)
    @path = "/" + retrieve_current_version(uri)
  end
  @port   = uri.port
  @scheme = uri.scheme
  true
end
retrieve_current_version(uri) click to toggle source
# File lib/fog/openstack/network.rb, line 210
def retrieve_current_version(uri)
  response = Fog::Connection.new(
    "#{uri.scheme}://#{uri.host}:#{uri.port}", false, @connection_options).request({
      :expects => [200, 204],
      :headers => {'Content-Type' => 'application/json',
                   'Accept' => 'application/json',
                   'X-Auth-Token' => @auth_token},
      :host    => uri.host,
      :method  => 'GET'
  })

  body = Fog::JSON.decode(response.body)
  version = nil
  unless body['versions'].empty?
    current_version = body['versions'].detect { |x| x["status"] == "CURRENT" }
    version = current_version["id"]
  end
  raise Errors::NotFound.new('No API versions found') if version.nil?
  version
end