In Files

Parent

Class/Module Index [+]

Quicksearch

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 115
def initialize(options={})
  @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_type         = options[:openstack_service_type] || ['network']
  @openstack_service_name         = options[:openstack_service_name]
  @openstack_endpoint_type        = options[:openstack_endpoint_type] || 'adminURL'

  @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

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

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [200],
    :method   => 'PUT',
    :path     => "routers/#{router_id}/add_router_interface"
  )
end
associate_floating_ip(floating_ip_id, port_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/associate_floating_ip.rb, line 6
def associate_floating_ip(floating_ip_id, port_id, options = {})
  data = {
    'floatingip' => {
      'port_id'    => port_id,
    }
  }

  vanilla_options = [:fixed_ip_address]
  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['floatingip'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [200],
    :method   => 'PUT',
    :path     => "floatingips/#{floating_ip_id}"
  )
end
create_floating_ip(floating_network_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/create_floating_ip.rb, line 6
def create_floating_ip(floating_network_id, options = {})
  data = {
    'floatingip' => {
      'floating_network_id' => floating_network_id,
      'port_id' => options[:port_id],
      'tenant_id' => options[:tenant_id],
      'fixed_ip_address' => options[:fixed_ip_address],
    }
  }

  vanilla_options = [:port_id, :tenant_id, :fixed_ip_address ]
  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['floatingip'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [201],
    :method   => 'POST',
    :path     => 'floatingips'
  )
end
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

  # Advanced Features through API Extensions
  #
  # Not strictly required but commonly found in OpenStack
  # installs with Quantum networking.
  #
  # @see http://docs.openstack.org/trunk/openstack-network/admin/content/provider_attributes.html
  provider_options = [
    :router_external,
    :provider_network_type,
    :provider_segmentation_id,
    :provider_physical_network
  ]

  # Map Fog::Network::OpenStack::Network 
  # model attributes to OpenStack provider attributes 
  aliases = {
    :provider_network_type     => 'provider:network_type',
    # Not applicable to the "local" or "gre" network types
    :provider_physical_network => 'provider:physical_network',
    :provider_segmentation_id  => 'provider:segmentation_id',
    :router_external           => 'router:external'
  }

  provider_options.reject{ |o| options[o].nil? }.each do |key|
    aliased_key = aliases[key] || key
    data['network'][aliased_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_router(name, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/create_router.rb, line 6
def create_router(name, options = {})
  data = {
    'router' => {
      'name' => name,
    }
  }

  vanilla_options = [
    :admin_state_up, 
    :tenant_id,
    :network_id,
    :external_gateway_info,
    :status,
    :subnet_id
  ]

  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['router'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [201],
    :method   => 'POST',
    :path     => 'routers'
  )
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 147
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_floating_ip(floating_ip_id) click to toggle source
# File lib/fog/openstack/requests/network/delete_floating_ip.rb, line 6
def delete_floating_ip(floating_ip_id)
  request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => "floatingips/#{floating_ip_id}"
  )
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_router(router_id) click to toggle source
# File lib/fog/openstack/requests/network/delete_router.rb, line 6
def delete_router(router_id)
  request(
    :expects  => 204,
    :method   => 'DELETE',
    :path     => "routers/#{router_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
disassociate_floating_ip(floating_ip_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/disassociate_floating_ip.rb, line 6
def disassociate_floating_ip(floating_ip_id, options = {})
  data = {
    'floatingip' => {
      'port_id'    => nil,
    }
  }

  vanilla_options = [:fixed_ip_address]
  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['floatingip'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [200],
    :method   => 'PUT',
    :path     => "floatingips/#{floating_ip_id}"
  )
end
get_floating_ip(floating_ip_id) click to toggle source
# File lib/fog/openstack/requests/network/get_floating_ip.rb, line 6
def get_floating_ip(floating_ip_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "floatingips/#{floating_ip_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_router(router_id) click to toggle source
# File lib/fog/openstack/requests/network/get_router.rb, line 6
def get_router(router_id)
  request(
    :expects => [200],
    :method  => 'GET',
    :path    => "routers/#{router_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_floating_ips(filters = {}) click to toggle source
# File lib/fog/openstack/requests/network/list_floating_ips.rb, line 6
def list_floating_ips(filters = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'floatingips',
    :query   => filters
  )
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_routers(filters = {}) click to toggle source
# File lib/fog/openstack/requests/network/list_routers.rb, line 6
def list_routers(filters = {})
  request(
    :expects => 200,
    :method  => 'GET',
    :path    => 'routers',
    :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 156
def reload
  @connection.reset
end
remove_router_interface(router_id, subnet_id, options = {}) click to toggle source
# File lib/fog/openstack/requests/network/remove_router_interface.rb, line 6
def remove_router_interface(router_id, subnet_id, options = {})
  data = {
      'subnet_id' => subnet_id,
  }

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => [200],
    :method   => 'PUT',
    :path     => "routers/#{router_id}/remove_router_interface"
  )
end
request(params) click to toggle source
# File lib/fog/openstack/network.rb, line 160
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]}"#,
    }))
  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 = Fog::JSON.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_router(router_id, options = {}) click to toggle source

Update Router

Beyond the name and the administrative state, the only parameter which can be updated with this operation is the external gateway.

router = Fog::Network[:openstack].routers.first
net = Fog::Network[:openstack].networks.first

# :external_gateway_info can be either a
# Fog::Network::OpenStack::Network or a Hash
# like { 'network_id' => network.id }
Fog::Network[:openstack].update_router router.id,
                                       :name => 'foo',
                                       :external_gateway_info => net,
                                       :admin_state_up => true

@see docs.openstack.org/api/openstack-network/2.0/content/router_update.html

# File lib/fog/openstack/requests/network/update_router.rb, line 25
def update_router(router_id, options = {})
  data = { 'router' => {} }
  
  vanilla_options = [:name, :admin_state_up]

  egi = options[:external_gateway_info]
  if egi
    if egi.is_a?(Fog::Network::OpenStack::Network)
      data['router']['external_gateway_info'] = { 'network_id' => egi.id }
    elsif egi.is_a?(Hash) and egi['network_id']
      data['router']['external_gateway_info'] = egi
    else
      raise ArgumentError.new('Invalid external_gateway_info attribute')
    end
  end

  vanilla_options.reject{ |o| options[o].nil? }.each do |key|
    data['router'][key] = options[key]
  end

  request(
    :body     => Fog::JSON.encode(data),
    :expects  => 200,
    :method   => 'PUT',
    :path     => "routers/#{router_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

[Validate]

Generated with the Darkfish Rdoc Generator 2.