ipam

package module
v1.3.2 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 7, 2020 License: MIT Imports: 12 Imported by: 21

README

go-ipam

Actions GoDoc Go Report Card codecov License

go-ipam is a module to handle IP address management. It can operate on networks, prefixes and IPs.

IP

Most obvious this library is all about IP management. The main purpose is to acquire and release an IP, or a bunch of IP's from prefixes.

Prefix

A prefix is a network with IP and mask, typically in the form of 192.168.0.0/24. To be able to manage IPs you have to create a prefix first.

Example usage:


package main

import (
    "fmt"
    goipam "github.com/metal-stack/go-ipam"
)

func main() {
    // create a ipamer with in memory storage
    ipam := goipam.New()

    prefix, err := ipam.NewPrefix("192.168.0.0/24")
    if err != nil {
        panic(err)
    }

    ip, err := ipam.AcquireIP(prefix.Cidr)
    if err != nil {
        panic(err)
    }
    fmt.Printf("got IP: %s", ip.IP)

    prefix, err = ipam.ReleaseIP(ip)
    if err != nil {
        panic(err)
    }
    fmt.Printf("IP: %s released.", ip.IP)
}

Performance

BenchmarkNewPrefixMemory-4               1000000              1637 ns/op             728 B/op         27 allocs/op
BenchmarkNewPrefixPostgres-4                 200           8611579 ns/op            6170 B/op        155 allocs/op
BenchmarkAcquireIPMemory-4               1000000              1234 ns/op             232 B/op         15 allocs/op
BenchmarkAcquireIPPostgres-4                 200          11583345 ns/op            7252 B/op        184 allocs/op
BenchmarkAcquireChildPrefix1-4            300000              3771 ns/op            1528 B/op         58 allocs/op
BenchmarkAcquireChildPrefix2-4            300000              3773 ns/op            1528 B/op         58 allocs/op
BenchmarkAcquireChildPrefix3-4            300000              3997 ns/op            1541 B/op         58 allocs/op
BenchmarkAcquireChildPrefix4-4            300000              4877 ns/op            1581 B/op         60 allocs/op
BenchmarkAcquireChildPrefix5-4            200000              5541 ns/op            1854 B/op         70 allocs/op
BenchmarkAcquireChildPrefix6-4            300000              4123 ns/op            1528 B/op         58 allocs/op
BenchmarkAcquireChildPrefix7-4            300000              4954 ns/op            1528 B/op         58 allocs/op
BenchmarkAcquireChildPrefix8-4            300000              5017 ns/op            1528 B/op         58 allocs/op
BenchmarkAcquireChildPrefix9-4            300000              5309 ns/op            1528 B/op         58 allocs/op
BenchmarkAcquireChildPrefix10-4           200000              5234 ns/op            1532 B/op         58 allocs/op
BenchmarkPrefixOverlapping-4             1000000              1934 ns/op             432 B/op         24 allocs/op

Documentation

Overview

Package ipam is a ip address management library for ip's and prefixes (networks).

It uses either memory or postgresql database to store the ip's and prefixes. You can also bring you own Storage implementation as you need.

Example usage:

import (
	"fmt"
	goipam "github.com/metal-stack/go-ipam"
)

func main() {
	// create a ipamer with in memory storage
	ipam := goipam.New()

	prefix, err := ipam.NewPrefix("192.168.0.0/24")
	if err != nil {
		panic(err)
	}

	ip, err := ipam.AcquireIP(prefix)
	if err != nil {
		panic(err)
	}
	fmt.Printf("got IP: %s", ip.IP)

	err = ipam.ReleaseIP(ip)
	if err != nil {
		panic(err)
	}
	fmt.Printf("IP: %s released.", ip.IP)
}

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func JitterDelay

func JitterDelay(_ uint, config *retry.Config) time.Duration

JitterDelay is a DelayType which varies delay in each iterations

func NewMemory

func NewMemory() *memory

NewMemory create a memory storage for ipam

func NewPostgresStorage

func NewPostgresStorage(host, port, user, password, dbname, sslmode string) (*sql, error)

NewPostgresStorage creates a new Storage which uses postgres.

Types

type IP

type IP struct {
	IP           net.IP
	ParentPrefix string
}

IP is a single ipaddress.

type Ipamer

type Ipamer struct {
	// contains filtered or unexported fields
}

Ipamer can be used to do IPAM stuff.

func New

func New() *Ipamer

New returns a Ipamer with in memory storage for networks, prefixes and ips.

func NewWithStorage

func NewWithStorage(storage Storage) *Ipamer

NewWithStorage allows you to create a Ipamer instance with your Storage implementation. The Storage interface must be implemented.

func (*Ipamer) AcquireChildPrefix

func (i *Ipamer) AcquireChildPrefix(parentCidr string, length int) (*Prefix, error)

AcquireChildPrefix will return a Prefix with a smaller length from the given Prefix.

func (*Ipamer) AcquireIP

func (i *Ipamer) AcquireIP(prefixCidr string) (*IP, error)

AcquireIP will return the next unused IP from this Prefix.

func (*Ipamer) AcquireSpecificIP

func (i *Ipamer) AcquireSpecificIP(prefixCidr, specificIP string) (*IP, error)

acquireSpecificIPInternal will acquire given IP and mark this IP as used, if already in use, return nil. If specificIP is empty, the next free IP is returned. If there is no free IP an NewNoIPAvailableError is returned.

func (*Ipamer) DeletePrefix

func (i *Ipamer) DeletePrefix(cidr string) (*Prefix, error)

DeletePrefix delete a Prefix from a string notation.

func (*Ipamer) GetHostAddresses

func (i *Ipamer) GetHostAddresses(prefix string) ([]string, error)

GetHostAddresses will return all possible ipadresses a host can get in the given prefix. The IPs will be acquired by this method, so that the prefix has no free IPs afterwards.

func (*Ipamer) NewPrefix

func (i *Ipamer) NewPrefix(cidr string) (*Prefix, error)

NewPrefix create a new Prefix from a string notation.

Example
ipamer := New()
prefix, err := ipamer.NewPrefix("192.168.0.0/24")
if err != nil {
	panic(err)
}
ip1, err := ipamer.AcquireIP(prefix.Cidr)
if err != nil {
	panic(err)
}
ip2, err := ipamer.AcquireIP(prefix.Cidr)
if err != nil {
	panic(err)
}

fmt.Println(prefix)
fmt.Println(ip1.IP.String())
fmt.Println(ip1.ParentPrefix)
fmt.Println(ip2.IP.String())
fmt.Println(ip2.ParentPrefix)
Output:
192.168.0.0/24
192.168.0.1
192.168.0.0/24
192.168.0.2
192.168.0.0/24

func (*Ipamer) PrefixFrom

func (i *Ipamer) PrefixFrom(cidr string) *Prefix

PrefixFrom will return a known Prefix.

func (*Ipamer) PrefixesOverlapping

func (i *Ipamer) PrefixesOverlapping(existingPrefixes []string, newPrefixes []string) error

PrefixesOverlapping will check if one ore more prefix of newPrefixes is overlapping with one of existingPrefixes

func (*Ipamer) ReleaseChildPrefix

func (i *Ipamer) ReleaseChildPrefix(child *Prefix) error

ReleaseChildPrefix will mark this child Prefix as available again.

func (*Ipamer) ReleaseIP

func (i *Ipamer) ReleaseIP(ip *IP) (*Prefix, error)

ReleaseIP will release the given IP for later usage and returns the updated Prefix.

func (*Ipamer) ReleaseIPFromPrefix

func (i *Ipamer) ReleaseIPFromPrefix(prefixCidr, ip string) error

ReleaseIPFromPrefix will release the given IP for later usage.

type NoIPAvailableError

type NoIPAvailableError struct {
	// contains filtered or unexported fields
}

NoIPAvailableError indicates that the acquire-operation could not be executed because the specified prefix has no free IP anymore.

func NewNoIPAvailableError

func NewNoIPAvailableError(msg string) NoIPAvailableError

func (NoIPAvailableError) Error

func (o NoIPAvailableError) Error() string

type OptimisticLockError

type OptimisticLockError struct {
	// contains filtered or unexported fields
}

OptimisticLockError indicates that the operation could not be executed because the dataset to update has changed in the meantime. clients can decide to read the current dataset and retry the operation.

func NewOptimisticLockError

func NewOptimisticLockError(msg string) OptimisticLockError

func (OptimisticLockError) Error

func (o OptimisticLockError) Error() string

type Prefix

type Prefix struct {
	Cidr       string // The Cidr of this prefix
	ParentCidr string // if this prefix is a child this is a pointer back
	// contains filtered or unexported fields
}

Prefix is a expression of a ip with length and forms a classless network.

func (Prefix) DeepCopy

func (p Prefix) DeepCopy() *Prefix

func (*Prefix) IPNet

func (p *Prefix) IPNet() (*net.IPNet, error)

IPNet return the net.IPNet part of the Prefix

func (*Prefix) Network

func (p *Prefix) Network() (net.IP, error)

Network return the net.IP part of the Prefix

func (*Prefix) String

func (p *Prefix) String() string

func (*Prefix) Usage

func (p *Prefix) Usage() Usage

Usage report Prefix usage.

type Storage

type Storage interface {
	CreatePrefix(prefix Prefix) (Prefix, error)
	ReadPrefix(prefix string) (Prefix, error)
	ReadAllPrefixes() ([]Prefix, error)
	UpdatePrefix(prefix Prefix) (Prefix, error)
	DeletePrefix(prefix Prefix) (Prefix, error)
}

Storage is a interface to store ipam objects.

type Usage

type Usage struct {
	AvailableIPs      uint64
	AcquiredIPs       uint64
	AvailablePrefixes uint64
	AcquiredPrefixes  uint64
}

Usage of ips and child Prefixes of a Prefix

func (*Usage) String

func (u *Usage) String() string

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL