Merge pull request #728 from digitalocean/develop

Release v1.7.2-r1

.gitignore

@@ -1,6 +1,8 @@
 *.pyc
-configuration.py
+/netbox/netbox/configuration.py
+/netbox/static
 .idea
 /*.sh
 !upgrade.sh
 fabfile.py
+*.swp

.travis.yml

@@ -1,3 +1,11 @@
+sudo: required
+
+services:
+  - docker
+
+env:
+  - DOCKER_TAG=$TRAVIS_TAG
+
 language: python
 python:
   - "2.7"
@@ -6,3 +14,7 @@ install:
   - pip install pep8
 script:
   - ./scripts/cibuild.sh
+after_success:
+  - if [ ! -z "$TRAVIS_TAG" ] && [ "$TRAVIS_PULL_REQUEST" == "false" ]; then
+    ./scripts/docker-build.sh;
+    fi

CONTRIBUTING.md

@@ -1,37 +1,53 @@
-# Contributing to NetBox
+## Getting Help
 
-Thank you for your interest in contributing to NetBox! This document contains some quick pointers on reporting bugs and
-requesting new features.
+If you encounter any issues installing or using NetBox, try one of the following resources to get assistance. Please
+**do not** open an issue on GitHub except to report bugs or request features.
 
-## Reporting Issues
+### Freenode IRC
 
-* First, ensure that you've installed the latest stable version of NetBox. If you're running an older version, it's
-possible that the bug has already been fixed.
+Join the #netbox channel on [Freenode IRC](https://freenode.net/). You can connect to Freenode at irc.freenode.net using
+an IRC client, or you can use their [webchat client](https://webchat.freenode.net/).
 
-* Check the [issues list](https://github.com/digitalocean/netbox/issues) to see if the bug you've found has already been
-reported. If you think you may be experiencing a reported issue, please add a quick comment to it with a "+1" and a
-quick description of how it's affecting your installation.
+### Reddit
 
-* If you're unsure whether the behavior you're seeing is expected, you can join #netbox on irc.freenode.net and ask
-before going through the trouble of submitting an issue report.
+We have established [/r/netbox](https://www.reddit.com/r/netbox) on Reddit for NetBox issues and general discussion.
+Reddit registration is free and does not require providing an email address (although it is encouraged).
 
-* When submitting an issue, please be as descriptive as possible. Be sure to describe:
+## Reporting Bugs
+
+* First, ensure that you've installed the [latest stable version](https://github.com/digitalocean/netbox/releases) of
+NetBox. If you're running an older version, it's possible that the bug has already been fixed.
+
+* Next, check the GitHub [issues list](https://github.com/digitalocean/netbox/issues) to see if the bug you've found has
+already been reported. If you think you may be experiencing a reported issue that hasn't already been resolved, please
+click "add a reaction" in the top right corner of the issue and add a thumbs up (+1). You might also want to add a
+comment describing how it's affecting your installation. This will allow us to prioritize bugs based on how many users
+are affected.
+
+* If you haven't found an existing issue that describes your suspected bug, please inquire about it on IRC or Reddit.
+**Do not** file an issue until you have received confirmation that it is in fact a bug. Invalid issues are very
+distracting and slow the pace at which NetBox is developed.
+
+* When submitting an issue, please be as descriptive as possible. Be sure to include:
 
     * The environment in which NetBox is running
     * The exact steps that can be taken to reproduce the issue (if applicable)
     * Any error messages returned
+    * Screenshots (if applicable)
 
 * Keep in mind that we prioritize bugs based on their severity and how much work is required to resolve them. It may
-take some time for someone to address your issue. If it's been longer than a week with no updates, please ping us on
-IRC.
+take some time for someone to address your issue.
 
 ## Feature Requests
 
-* First, check the [issues list](https://github.com/digitalocean/netbox/issues) to see if the feature you'd like to see
-has already been requested (and possibly rejected). If it is, be sure to comment with a "+1" and any additional
-justification you have for the feature.
+* First, check the GitHub [issues list](https://github.com/digitalocean/netbox/issues) to see if the feature you're
+requesting is already listed. (Be sure to search closed issues as well, since some feature requests are rejected.) If
+the feature you'd like to see has already been requested, click "add a reaction" in the top right corner of the issue
+and add a thumbs up. This ensures that the issue has a better chance of making it onto the roadmap. Also feel free
+to add a comment with any additional justification for the feature. (However, note that comments with no substance
+other than a "+1" will be deleted as spam. Please use GitHub's reactions feature to indicate your support.)
 
-* While discussion of new features is welcome, it's important to limit the scope of NetBox's feature set to avoid
+* While suggestions for new features are welcome, it's important to limit the scope of NetBox's feature set to avoid
 feature creep. For example, the following features would be firmly out of scope for NetBox:
 
     * Ticket management
@@ -39,21 +55,28 @@ feature creep. For example, the following features would be firmly out of scope
     * Acting as a DNS server
     * Acting as an authentication server
 
-* If you're not sure whether the feature you want is a good fit for NetBox, please ask in #netbox on irc.freenode.net.
-Even if it's not quite right for NetBox, we may be able to point you to a tool better suited for the job.
+* Before filing a new feature request, propose it on IRC or Reddit first. Feedback you receive there will help validate
+and shape the proposed feature before filing a formal issue.
 
-* When submitting a feature request, be sure to include the following:
+* Good feature requests are very narrowly defined. Be sure to enumerate specific functionality and data schema. The more
+effort you put into writing a feature request, the better its chances are of being implemented. Overly broad feature
+requests will be closed.
 
-    * A brief description of the functionality
+* When submitting a feature request on GitHub, be sure to include the following:
+
+    * A detailed description of the proposed functionality
     * A use case for the feature; who would use it and what value it would add to NetBox
-    * A rough description of any changes necessary to the database schema (if applicable)
+    * A rough description of any changes necessary to the database schema
     * Any third-party libraries or other resources which would be involved
 
 ## Submitting Pull Requests
 
-* When submitting a pull request, please be sure to work off of branch `develop`, rather than branch `master`.
-In NetBox, the `develop` branch is used for ongoing development, while `master` is used for tagging new
-stable releases.
+* Be sure to open an issue before starting work on a pull request, and discuss your idea with the NetBox maintainers
+before beginning work​. This will help prevent wasting time on something that might we might not be able to implement.
+When suggesting a new feature, also make sure it won't conflict with any work that's already in progress.
+
+* When submitting a pull request, please be sure to work off of the `develop` branch, rather than `master`. In NetBox,
+the `develop` branch is used for ongoing development, while `master` is used for tagging new stable releases.
 
 * All code submissions should meet the following criteria (CI will enforce these checks):
 

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:2.7-wheezy
+
+WORKDIR /opt/netbox
+
+ARG BRANCH=master
+ARG URL=https://github.com/digitalocean/netbox.git
+RUN git clone --depth 1 $URL -b $BRANCH .  && \
+    apt-get update -qq && apt-get install -y libldap2-dev libsasl2-dev libssl-dev graphviz && \
+	pip install gunicorn==17.5 && \
+	pip install django-auth-ldap && \
+    pip install -r requirements.txt
+
+ADD docker/docker-entrypoint.sh /docker-entrypoint.sh
+ADD netbox/netbox/configuration.docker.py /opt/netbox/netbox/netbox/configuration.py
+
+ENTRYPOINT [ "/docker-entrypoint.sh" ]
+
+ADD docker/gunicorn_config.py /opt/netbox/
+ADD docker/nginx.conf /etc/netbox-nginx/
+VOLUME ["/etc/netbox-nginx/"]

README.md

@@ -1,10 +1,12 @@
-# NetBox
+![NetBox](docs/netbox_logo.png "NetBox logo")
 
 NetBox is an IP address management (IPAM) and data center infrastructure management (DCIM) tool. Initially conceived by the network engineering team at [DigitalOcean](https://www.digitalocean.com/), NetBox was developed specifically to address the needs of network and infrastructure engineers.
 
 NetBox runs as a web application atop the [Django](https://www.djangoproject.com/) Python framework with a [PostgreSQL](http://www.postgresql.org/) database. For a complete list of requirements, see `requirements.txt`. The code is available [on GitHub](https://github.com/digitalocean/netbox).
 
-Questions? Comments? Please join us on IRC in **#netbox** on **irc.freenode.net**!
+The complete documentation for Netbox can be found at [Read the Docs](http://netbox.readthedocs.io/en/latest/).
+
+Questions? Comments? Please subscribe to [the netbox-discuss mailing list](https://groups.google.com/forum/#!forum/netbox-discuss), or join us on IRC in **#netbox** on **irc.freenode.net**!
 
 ### Build Status
 
@@ -15,62 +17,14 @@ Questions? Comments? Please join us on IRC in **#netbox** on **irc.freenode.net*
 
 ## Screenshots
 
-![Screenshot of main page](docs/screenshot1.png "Main page")
+![Screenshot of main page](docs/media/screenshot1.png "Main page")
 
-![Screenshot of rack elevation](docs/screenshot2.png "Rack elevation")
+![Screenshot of rack elevation](docs/media/screenshot2.png "Rack elevation")
 
-![Screenshot of prefix hierarchy](docs/screenshot3.png "Prefix hierarchy")
+![Screenshot of prefix hierarchy](docs/media/screenshot3.png "Prefix hierarchy")
 
 # Installation
 
-Please see docs/getting-started.md for instructions on installing NetBox.
+Please see [the documentation](http://netbox.readthedocs.io/en/latest/) for instructions on installing NetBox.
 
 To upgrade NetBox, please download the [latest release](https://github.com/digitalocean/netbox/releases) and run `upgrade.sh`.
-
-# Components
-
-NetBox understands all of the physical and logical building blocks that comprise network infrastructure, and the manners in which they are all related.
-
-## DCIM
-
-DCIM comprises all the physical installations and connections which comprise a network. NetBox tracks where devices are installed, as well as their individual power, console, and network connections.
-
-**Site:** A physical location (typically a building) where network devices are installed. Devices in different sites cannot be directly connected to one another.
-
-**Rack:** An equipment rack into which devices are installed. Each rack belongs to a site.
-
-**Device:** Any type of rack-mounted device. For example, routers, switches, servers, console servers, PDUs, etc. 0U (non-rack-mounted) devices are supported.
-
-## IPAM
-
-IPAM deals with the IP addressing and VLANs in use on a network. NetBox makes a distinction between IP prefixes (networks) and individual IP addresses.
-
-Because NetBox is a combined DCIM/IPAM system, IP addresses can be assigned to device interfaces in the application just as they are in the real world.
-
-**Aggregate:** A top-level aggregate of IP address space; for example, 10.0.0.0/8 or 2001:db8::/32. Each aggregate belongs to a regional Internet registry (RIR) like ARIN or RIPE, or to an authoritative standard such as RFC 1918.
-
-**VRF:** A virtual routing table. VRF support is currently still under development.
-
-**Prefix:** An IPv4 or IPv6 network. A prefix can be assigned to a VRF; if not, it is considered to belong to the global table. Prefixes are grouped by aggregates automatically and can optionally be assigned to sites.
-
-**IP Address:** An individual IPv4 or IPv6 address (with CIDR mask). IP address can be assigned to device interfaces.
-
-**VLAN:** VLANs are assigned to sites, and can optionally have one or more IP prefixes assigned to them. VLAN IDs are unique only within the scope of a site.
-
-## Circuits
-
-Long-distance data connections are typically referred to as _circuits_. NetBox provides a method for managing circuits and their providers. Individual circuits can be terminated to device interfaces.
-
-**Provider:** An entity to which a network connects to. This can be a transit provider, peer, or some other organization.
-
-**Circuit:** A data circuit which connects to a provider. The local end of a circuit can be assigned to a device interface.
-
-## Secrets
-
-NetBox provides encrypted storage of sensitive data it calls _secrets_. Each user may be issued an encryption key with which stored secrets can be retrieved.
-
-Note that NetBox does not merely hash secrets, a function which is only useful for validation. It employs fully reversible AES-256 encryption so that secret data can be retrieved and consumed by other services.
-
-**Secrets** Any piece of confidential data which must be retrievable. For example: passwords, SNMP communities, RADIUS shared secrets, etc.
-
-**User Key:** An individual user's encrypted copy of the master key, which can be used to retrieve secret data.

docker-compose.yml

@@ -0,0 +1,53 @@
+version: '2'
+
+services:
+    postgres:
+        image: postgres:9.6
+        container_name: postgres
+        environment:
+            POSTGRES_USER: netbox
+            POSTGRES_PASSWORD: J5brHrAXFLQSif0K
+            POSTGRES_DB: netbox
+    netbox:
+        build: .
+        image: digitalocean/netbox
+        links:
+        - postgres
+        container_name: netbox
+        depends_on:
+        - postgres
+        environment:
+            SUPERUSER_NAME: admin
+            SUPERUSER_EMAIL: admin@example.com
+            SUPERUSER_PASSWORD: admin
+            ALLOWED_HOSTS: localhost
+            DB_NAME: netbox
+            DB_USER: netbox
+            DB_PASSWORD: J5brHrAXFLQSif0K
+            DB_HOST: postgres
+            SECRET_KEY: r8OwDznj!!dci#P9ghmRfdu1Ysxm0AiPeDCQhKE+N_rClfWNj
+            EMAIL_SERVER: localhost
+            EMAIL_PORT: 25
+            EMAIL_USERNAME: foo
+            EMAIL_PASSWORD: bar
+            EMAIL_TIMEOUT: 10
+            EMAIL_FROM: netbox@bar.com
+            NETBOX_USERNAME: guest
+            NETBOX_PASSWORD: guest
+        volumes:
+        - netbox-static-files:/opt/netbox/netbox/static
+    nginx:
+        image: nginx:1.11.1-alpine
+        links:
+        - netbox
+        container_name: nginx
+        command: nginx -g 'daemon off;' -c /etc/netbox-nginx/nginx.conf
+        depends_on:
+        - netbox
+        ports:
+        - 80:80
+        volumes_from:
+        - netbox
+volumes:
+    netbox-static-files:
+        driver: local

docker/docker-entrypoint.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -e
+
+# run db migrations (retry on error)
+while ! /opt/netbox/netbox/manage.py migrate 2>&1; do
+    sleep 5
+done
+
+# create superuser silently
+if [[ -z ${SUPERUSER_NAME} || -z ${SUPERUSER_EMAIL} || -z ${SUPERUSER_PASSWORD} ]]; then
+        SUPERUSER_NAME='admin'
+        SUPERUSER_EMAIL='admin@example.com'
+        SUPERUSER_PASSWORD='admin'
+        echo "Using defaults: Username: ${SUPERUSER_NAME}, E-Mail: ${SUPERUSER_EMAIL}, Password: ${SUPERUSER_PASSWORD}"
+fi
+echo "from django.contrib.auth.models import User; User.objects.create_superuser('${SUPERUSER_NAME}', '${SUPERUSER_EMAIL}', '${SUPERUSER_PASSWORD}')" | python /opt/netbox/netbox/manage.py shell
+
+# copy static files
+/opt/netbox/netbox/manage.py collectstatic --no-input
+
+# start unicorn
+gunicorn --log-level debug --debug --error-logfile /dev/stderr --log-file /dev/stdout -c /opt/netbox/gunicorn_config.py netbox.wsgi

docker/gunicorn_config.py

@@ -0,0 +1,5 @@
+command = '/usr/bin/gunicorn'
+pythonpath = '/opt/netbox/netbox'
+bind = '0.0.0.0:8001'
+workers = 3
+user = 'root'

docker/nginx.conf

@@ -0,0 +1,35 @@
+worker_processes 1;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+    sendfile        on;
+    tcp_nopush     on;
+    keepalive_timeout  65;
+    gzip  on;
+    server_tokens off;
+
+    server {
+        listen 80;
+
+        server_name localhost;
+
+        access_log off;
+
+        location /static/ {
+            alias /opt/netbox/netbox/static/;
+        }
+
+        location / {
+            proxy_pass http://netbox:8001;
+            proxy_set_header X-Forwarded-Host $server_name;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            add_header P3P 'CP="ALL DSP COR PSAa PSDa OUR NOR ONL UNI COM NAV"';
+        }
+    }
+}

docs/api-integration.md

@@ -0,0 +1,19 @@
+# API Integration
+
+NetBox features a read-only REST API which can be used to integrate it with
+other applications.
+
+In the future, both read and write actions will be available via the API.
+
+## Clients
+
+The easiest way to start integrating your applications with NetBox is to make
+use of an API client.  If you build or discover an API client that is not part
+of this list, please send a pull request!
+
+- **Go**: [github.com/digitalocean/go-netbox](https://github.com/digitalocean/go-netbox)
+
+## Documentation
+
+If you wish to build a new API client or simply explore the NetBox API,
+Swagger documentation can be found at the URL `/api/docs/` on a NetBox server.

docs/configuration/mandatory-settings.md

@@ -0,0 +1,45 @@
+NetBox's local configuration is held in `netbox/netbox/configuration.py`. An example configuration is provided at `netbox/netbox/configuration.example.py`. You may copy or rename the example configuration and make changes as appropriate. NetBox will not run without a configuration file.
+
+## ALLOWED_HOSTS
+
+This is a list of valid fully-qualified domain names (FQDNs) that is used to reach the NetBox service. Usually this is the same as the hostname for the NetBox server, but can also be different (e.g. when using a reverse proxy serving the NetBox website under a different FQDN than the hostname of the NetBox server). NetBox will not permit access to the server via any other hostnames (or IPs). The value of this option is also used to set `CSRF_TRUSTED_ORIGINS`, which restricts `HTTP POST` to the same set of hosts (more about this [here](https://docs.djangoproject.com/en/1.9/ref/settings/#std:setting-CSRF_TRUSTED_ORIGINS)). Keep in mind that NetBox, by default, has `USE_X_FORWARDED_HOST = True` (in `netbox/netbox/settings.py`) which means that if you're using a reverse proxy, it's the FQDN used to reach that reverse proxy which needs to be in this list (more about this [here](https://docs.djangoproject.com/en/1.9/ref/settings/#allowed-hosts)).
+
+Example:
+
+```
+ALLOWED_HOSTS = ['netbox.example.com', '192.0.2.123']
+```
+
+---
+
+## DATABASE
+
+NetBox requires access to a PostgreSQL database service to store data. This service can run locally or on a remote system. The following parameters must be defined within the `DATABASE` dictionary:
+
+* NAME - Database name
+* USER - PostgreSQL username
+* PASSWORD - PostgreSQL password
+* HOST - Name or IP address of the database server (use `localhost` if running locally)
+* PORT - TCP port of the PostgreSQL service; leave blank for default port (5432)
+
+Example:
+
+```
+DATABASE = {
+    'NAME': 'netbox',               # Database name
+    'USER': 'netbox',               # PostgreSQL username
+    'PASSWORD': 'J5brHrAXFLQSif0K', # PostgreSQL password
+    'HOST': 'localhost',            # Database server
+    'PORT': '',                     # Database port (leave blank for default)
+}
+```
+
+---
+
+## SECRET_KEY
+
+This is a secret cryptographic key is used to improve the security of cookies and password resets. The key defined here should not be shared outside of the configuration file. `SECRET_KEY` can be changed at any time, however be aware that doing so will invalidate all existing sessions.
+
+Please note that this key is **not** used for hashing user passwords or for the encrypted storage of secret data in NetBox.
+
+`SECRET_KEY` should be at least 50 characters in length and contain a random mix of letters, digits, and symbols. The script located at `netbox/generate_secret_key.py` may be used to generate a suitable key.

docs/configuration/optional-settings.md

@@ -1,62 +1,6 @@
-<h1>Configuration</h1>
+The following are optional settings which may be declared in `netbox/netbox/configuration.py`.
 
-NetBox's local configuration is held in `netbox/netbox/configuration.py`. An example configuration is provided at `netbox/netbox/configuration.example.py`. You may copy or rename the example configuration and make changes as appropriate. NetBox will not run without a configuration file.
-
-[TOC]
-
-# Mandatory Settings
-
----
-
-#### ALLOWED_HOSTS
-
-This is a list of valid fully-qualified domain names (FQDNs) for the NetBox server. NetBox will not permit write access to the server via any other hostnames. The first FQDN in the list will be treated as the preferred name.
-
-Example:
-
-```
-ALLOWED_HOSTS = ['netbox.example.com', '192.0.2.123']
-```
-
----
-
-#### DATABASE
-
-NetBox requires access to a PostgreSQL database service to store data. This service can run locally or on a remote system. The following parameters must be defined within the `DATABASE` dictionary:
-
-* NAME - Database name
-* USER - PostgreSQL username
-* PASSWORD - PostgreSQL password
-* HOST - Name or IP address of the database server (use `localhost` if running locally)
-* PORT - TCP port of the PostgreSQL service; leave blank for default port (5432)
-
-Example:
-
-```
-DATABASE = {
-    'NAME': 'netbox',               # Database name
-    'USER': 'netbox',               # PostgreSQL username
-    'PASSWORD': 'J5brHrAXFLQSif0K', # PostgreSQL password
-    'HOST': 'localhost',            # Database server
-    'PORT': '',                     # Database port (leave blank for default)
-}
-```
-
----
-
-#### SECRET_KEY
-
-This is a secret cryptographic key is used to improve the security of cookies and password resets. The key defined here should not be shared outside of the configuration file. `SECRET_KEY` can be changed at any time, however be aware that doing so will invalidate all existing sessions.
-
-Please note that this key is **not** used for hashing user passwords or for the encrypted storage of secret data in NetBox.
-
-`SECRET_KEY` should be at least 50 characters in length and contain a random mix of letters, digits, and symbols. The script located at `netbox/generate_secret_key.py` may be used to generate a suitable key.
-
-# Optional Settings
-
----
-
-#### ADMINS
+## ADMINS
 
 NetBox will email details about critical errors to the administrators listed here. This should be a list of (name, email) tuples. For example:
 
@@ -69,15 +13,40 @@ ADMINS = [
 
 ---
 
-#### DEBUG
+## BANNER_TOP
 
-Default: False
+## BANNER_BOTTOM
 
-This setting enables debugging. This should be done only during development or troubleshooting. Never enable debugging on a production system, as it can expose sensitive data to unauthenticated users. 
+Setting these variables will display content in a banner at the top and/or bottom of the page, respectively. To replicate the content of the top banner in the bottom banner, set:
+
+```
+BANNER_TOP = 'Your banner text'
+BANNER_BOTTOM = BANNER_TOP
+```
 
 ---
 
-#### EMAIL
+## BASE_PATH
+
+Default: None
+
+The base URL path to use when accessing NetBox. Do not include the scheme or domain name. For example, if installed at http://example.com/netbox/, set:
+
+```
+BASE_PATH = 'netbox/'
+```
+
+---
+
+## DEBUG
+
+Default: False
+
+This setting enables debugging. This should be done only during development or troubleshooting. Never enable debugging on a production system, as it can expose sensitive data to unauthenticated users.
+
+---
+
+## EMAIL
 
 In order to send email, NetBox needs an email server configured. The following items can be defined within the `EMAIL` setting:
 
@@ -90,15 +59,23 @@ In order to send email, NetBox needs an email server configured. The following i
 
 ---
 
-#### LOGIN_REQUIRED
+# ENFORCE_GLOBAL_UNIQUE
 
-Default: False,
+Default: False
+
+Enforcement of unique IP space can be toggled on a per-VRF basis. To enforce unique IP space within the global table (all prefixes and IP addresses not assigned to a VRF), set `ENFORCE_GLOBAL_UNIQUE` to True.
+
+---
+
+## LOGIN_REQUIRED
+
+Default: False
 
 Setting this to True will permit only authenticated users to access any part of NetBox. By default, anonymous users are permitted to access most data in NetBox (excluding secrets) but not make any changes.
 
 ---
 
-#### MAINTENANCE_MODE
+## MAINTENANCE_MODE
 
 Default: False
 
@@ -106,15 +83,15 @@ Setting this to True will display a "maintenance mode" banner at the top of ever
 
 ---
 
-#### NETBOX_USERNAME
+## NETBOX_USERNAME
 
-#### NETBOX_PASSWORD
+## NETBOX_PASSWORD
 
 If provided, NetBox will use these credentials to authenticate against devices when collecting data.
 
 ---
 
-#### PAGINATE_COUNT
+## PAGINATE_COUNT
 
 Default: 50
 
@@ -122,7 +99,15 @@ Determine how many objects to display per page within each list of objects.
 
 ---
 
-#### TIME_ZONE
+## PREFER_IPV4
+
+Default: False
+
+When determining the primary IP address for a device, IPv6 is preferred over IPv4 by default. Set this to True to prefer IPv4 instead.
+
+---
+
+## TIME_ZONE
 
 Default: UTC
 
@@ -130,7 +115,7 @@ The time zone NetBox will use when dealing with dates and times. It is recommend
 
 ---
 
-#### Date and Time Formatting
+## Date and Time Formatting
 
 You may define custom formatting for date and times. For detailed instructions on writing format strings, please see [the Django documentation](https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date).
 

docs/data-model/circuits.md

@@ -1,9 +1,5 @@
-<h1>Circuits</h1>
-
 The circuits component of NetBox deals with the management of long-haul Internet and private transit links and providers.
 
-[TOC]
-
 # Providers
 
 A provider is any entity which provides some form of connectivity. This obviously includes carriers which offer Internet and private transit service. However, it might also include Internet exchange (IX) points and even organizations with whom you peer directly.

docs/data-model/dcim.md

@@ -1,9 +1,5 @@
-<h1>DCIM</h1>
-
 Data center infrastructure management (DCIM) entails all physical assets: sites, racks, devices, cabling, etc.
 
-[TOC]
-
 # Sites
 
 How you define sites will depend on the nature of your organization, but typically a site will equate a building or campus. For example, a chain of banks might create a site to represent each of its branches, a site for its corporate headquarters, and two additional sites for its presence in two colocation facilities.
@@ -14,15 +10,21 @@ Sites can be assigned an optional facility ID to identify the actual facility ho
 
 # Racks
 
-Within each site exist one or more racks. Each rack within NetBox represents a physical two- or four-post equipment rack in which equipment is mounted. Rack height is measured in *rack units *(U); most racks are between 42U and 48U, but NetBox allows you to define racks of any height. Each rack has two faces (front and rear) on which devices can be mounted.
+Within each site exist one or more racks. Each rack within NetBox represents a physical two- or four-post equipment rack in which equipment is mounted. Rack height is measured in *rack units* (U); most racks are between 42U and 48U, but NetBox allows you to define racks of any height. Each rack has two faces (front and rear) on which devices can be mounted.
 
 Each rack is assigned a name and (optionally) a separate facility ID. This is helpful when leasing space in a data center your organization does not own: The facility will often assign a seemingly arbitrary ID to a rack (for example, M204.313) whereas internally you refer to is simply as "R113." The facility ID can alternatively be used to store a rack's serial number.
 
+The available rack types include 2- and 4-post frames, 4-post cabinet, and wall-mounted frame and cabinet. Rail-to-rail width may be 19 or 23 inches.
+
 ### Rack Groups
 
 Racks can be arranged into groups. As with sites, how you choose to designate rack groups will depend on the nature of your organization. For example, if each site is a campus, each group might be a building. If each site is a building, each rack group might be a floor or room.
 
-Each group is assigned to a parent site for easy navigation. Hierarchical recursion of rack groups is not currently supported.
+Each group is assigned to a parent site for easy navigation. Hierarchical recursion of rack groups is not supported.
+
+### Rack Roles
+
+Each rak can optionally be assigned to a functional role. For example, you might designate a rack for compute or storage resources, or to house colocated customer devices.
 
 ---
 
@@ -43,6 +45,7 @@ Each device type is assigned a number of component templates which describe the
 * Power port templates
 * Power outlet templates
 * Interface templates
+* Device bay templates
 
 Whenever a new device is created, it is automatically assigned console, power, and interface components per the templates assigned to its device type. For example, suppose your network employs Juniper EX4300-48T switches. You would create a device type with a model name "EX4300-48T" and assign it to the manufacturer "Juniper." You might then also create the following templates for it:
 
@@ -59,12 +62,12 @@ Note that assignment of components from templates occurs only at the time of dev
 
 # Devices
 
-Every piece of hardware which is installed within a rack exists in NetBox as a device. Devices are measured in rack units (U) and whether they are full depth. 0U devices which can be installed in a rack but don't consume vertical rack space (such as a vertically-mounted power distribution unit) can also be defined.
+Every piece of hardware which is installed within a rack exists in NetBox as a device. Devices are measured in rack units (U) and depth. 0U devices which can be installed in a rack but don't consume vertical rack space (such as a vertically-mounted power distribution unit) can also be defined.
+
+When assigning a multi-U device to a rack, it is considered to be mounted in the lowest-numbered rack unit which it occupies. For example, a 3U device which occupies U8 through U10 shows as being mounted in U8.
 
 A device is said to be "full depth" if its installation on one rack face prevents the installation of any other device on the opposite face within the same rack unit(s). This could be either because the device is physically too deep to allow a device behind it, or because the installation of an opposing device would impede air flow.
 
-Each device has a physical device type (make and model), which is discussed below.
-
 ### Roles
 
 NetBox allows for the definition of arbitrary device roles by which devices can be organized. For example, you might create roles for core switches, distribution switches, and access switches. In the interest of simplicity, device can only belong to one device role.
@@ -77,20 +80,23 @@ The assignment of platforms to devices is an entirely optional feature, and may
 
 ### Modules
 
-A device can be assigned modules which represent internal components. Currently, these are used merely for inventory tracking, although future development might see their functionality expand.
+A device can be assigned modules which represent internal components. Currently, these are used merely for inventory tracking, although future development might see their functionality expand. Each module can optionally be assigned to a manufacturer.
 
 ### Components
 
-There are five types of device components which comprise all of the interconnection logic with NetBox:
+There are six types of device components which comprise all of the interconnection logic with NetBox:
 
 * Console ports
 * Console server ports
 * Power ports
 * Power outlets
 * Interfaces
+* Device bays
 
 Console ports connect only to console server ports, and power ports connect only to power outlets. Interfaces connect to one another in a symmetric manner: If interface A connects to interface B, interface B therefore connects to interface A. (The relationship between two interfaces is actually represented in the database by an InterfaceConnection object, but this is transparent to the user.)
 
-Each type of connection can be defined as either *planned* or *connected*. This allows for easily denoting connections which have not yet been installed.
+Each type of connection can be classified as either *planned* or *connected*. This allows for easily denoting connections which have not yet been installed. In addition to a connecting peer, interfaces are also assigned a form factor and may be designated as management-only (for out-of-band management). Interfaces may also be assigned a short description.
 
-In addition to a connecting peer, interfaces are also assigned a form factor and may be designated as management-only (for out-of-band management). Interfaces may also be assigned a short description.
+Device bays represent the ability of a device to house child devices. For example, you might install four blade servers into a 2U chassis. The chassis would appear in the rack elevation as a 2U device with four device bays. Each server within it would be defined as a 0U device installed in one of the device bays. Child devices do not appear on rack elevations, but they are included in the "Non-Racked Devices" list within the rack view.
+
+Note that child devices differ from modules in that they are still treated as independent devices, with their own console/power/data components, modules, and IP addresses. Modules, on the other hand, are parts within a device, such as a hard disk or power supply.

docs/data-model/extras.md

@@ -1,8 +1,31 @@
-<h1>Extras</h1>
+This section entails features of NetBox which are not crucial to its primary functions, but provide additional value.
 
-This section entails features of NetBox which are not crucial to its primary functions, but that provide additional value.
+# Custom Fields
 
-[TOC]
+Each object in NetBox is represented in the database as a discrete table, and each attribute of an object exists as a column within its table. For example, sites are stored in the `dcim_site` table, which has columns named `name`, `facility`, `physical_address` and so on. As new attributes are added to objects throughout the development of NetBox, tables are expanded to include new rows.
+
+However, some users might want to associate with objects attributes that are somewhat esoteric in nature, and that would not make sense to include in the core NetBox database schema. For instance, suppose your organization needs to associate each device with a ticket number pointing to the support ticket that was opened to have it installed. This is certainly a legitimate use for NetBox, but it's perhaps not a common enough need to warrant expanding the internal data schema. Instead, you can create a custom field to hold this data.
+
+Custom fields must be created through the admin UI under Extras > Custom Fields. To create a new custom field, select the object(s) to which you want it to apply, and the type of field it will be. NetBox supports six field types:
+
+* Free-form text (up to 255 characters)
+* Integer
+* Boolean (true/false)
+* Date
+* URL
+* Selection
+
+Assign the field a name. This should be a simple database-friendly string, e.g. `tps_report`. You may optionally assign the field a human-friendly label (e.g. "TPS report") as well; the label will be displayed on forms. If a description is provided, it will appear beneath the field in a form.
+
+Marking the field as required will require the user to provide a value for the field when creating a new object or when saving an existing object. A default value for the field may also be provided. Use "true" or "false" for boolean fields. (The default value has no effect for selection fields.)
+
+When creating a selection field, you should create at least two choices. These choices will be arranged first by weight, with lower weights appearing higher in the list, and then alphabetically.
+
+## Using Custom Fields
+
+When a single object is edited, the form will include any custom fields which have been defined for the object type. These fields are included in the "Custom Fields" panel. On the backend, each custom field value is saved separately from the core object as an independent database call, so it's best to avoid adding too many custom fields per object.
+
+When editing multiple objects, custom field values are saved in bulk. There is no significant difference in overhead when saving a custom field value for 100 objects versus one object. However, the bulk operation must be performed separately for each custom field.
 
 # Export Templates
 
@@ -12,6 +35,8 @@ Each export template is associated with a certain type of object. For instance,
 
 Export templates are written in [Django's template language](https://docs.djangoproject.com/en/1.9/ref/templates/language/), which is very similar to Jinja2. The list of objects returned from the database is stored in the `queryset` variable. Typically, you'll want to iterate through this list using a for loop.
 
+To access custom fields of an object within a template, use the `cf` attribute. For example, `{{ obj.cf.color }}` will return the value (if any) for a custom field named `color` on `obj`.
+
 A MIME type and file extension can optionally be defined for each export template. The default MIME type is `text/plain`.
 
 ## Example
@@ -73,4 +98,4 @@ dist-switch\d
 access-switch\d+,oob-switch\d+
 ```
 
-Note that you can combine multiple regexes onto one line using commas. (Commas can only be used for separating regexes; they will not be processed as part of a regex.) The order in which regexes are listed on a line is significant: devices matching the first regex will be rendered first, and subsequent groups will be rendered to the right of those.
+Note that you can combine multiple regexes onto one line using semicolons. The order in which regexes are listed on a line is significant: devices matching the first regex will be rendered first, and subsequent groups will be rendered to the right of those.

docs/data-model/ipam.md

@@ -1,9 +1,5 @@
-<h1>IPAM</h1>
-
 IP address management (IPAM) entails the allocation of IP networks, addresses, and related numeric resources.
 
-[TOC]
-
 # VRFs
 
 A VRF object in NetBox represents a virtual routing and forwarding (VRF) domain within a network. Each VRF is essentially a separate routing table: the same IP prefix or address can exist in multiple VRFs. VRFs are commonly used to isolate customers or organizations from one another within a network.

docs/data-model/secrets.md

@@ -1,9 +1,5 @@
-<h1>Secrets</h1>
-
 "Secrets" are small amounts of data that must be kept confidential; for example, passwords and SNMP community strings. NetBox provides encrypted storage of secret data.
 
-[TOC]
-
 # Secrets
 
 A secret represents a single credential or other string which must be stored securely. Each secret is assigned to a device within NetBox. The plaintext value of a secret is encrypted to a ciphertext immediately prior to storage within the database using a 256-bit AES master key. A SHA256 hash of the plaintext is also stored along with each ciphertext to validate the decrypted plaintext.
@@ -20,6 +16,8 @@ Each secret is assigned a functional role which indicates what it is used for. T
 * IKE key strings
 * Routing protocol shared secrets
 
+Roles are also used to control access to secrets. Each role is assigned an arbitrary number of groups and/or users. Only the users associated with a role have permission to decrypt the secrets assigned to that role. (A superuser has permission to decrypt all secrets, provided they have an active user key.)
+
 ---
 
 # User Keys

docs/data-model/tenancy.md

@@ -0,0 +1,22 @@
+NetBox supports the concept of individual tenants within its parent organization. Typically, these are used to represent individual customers or internal departments.
+
+# Tenants
+
+A tenant represents a discrete organization. Certain resources within NetBox can be assigned to a tenant. This makes it very convenient to track which resources are assigned to which customers, for instance.
+
+The following objects can be assigned to tenants:
+
+* Sites
+* Racks
+* Devices
+* VRFs
+* Prefixes
+* IP addresses
+* VLANs
+* Circuits
+
+If a prefix or IP address is not assigned to a tenant, it will appear to inherit the tenant to which its parent VRF is assigned, if any.
+
+### Tenant Groups
+
+Tenants can be grouped by type. For instance, you might create one group called "Customers" and one called "Acquisitions." The assignment of tenants to groups is optional.

docs/getting-started.md

@@ -1,452 +0,0 @@
-<h1>Getting Started</h1>
-
-This guide documents the process of installing NetBox on an Ubuntu 14.04 server with [nginx](https://www.nginx.com/) and [gunicorn](http://gunicorn.org/).
-
-[TOC]
-
-# PostgreSQL
-
-## Installation
-
-The following packages are needed to install PostgreSQL:
-
-* postgresql
-* libpq-dev
-* python-psycopg2
-
-```
-# apt-get install postgresql libpq-dev python-psycopg2
-```
-
-## Configuration
-
-At a minimum, we need to create a database for NetBox and assign it a username and password for authentication. This is done with the following commands.
-
-DO NOT USE THE PASSWORD FROM THE EXAMPLE.
-
-```
-# sudo -u postgres psql
-psql (9.3.13)
-Type "help" for help.
-
-postgres=# CREATE DATABASE netbox;
-CREATE DATABASE
-postgres=# CREATE USER netbox WITH PASSWORD 'J5brHrAXFLQSif0K';
-CREATE ROLE
-postgres=# GRANT ALL PRIVILEGES ON DATABASE netbox TO netbox;
-GRANT
-postgres=# \q
-```
-
-You can verify that authentication works using the following command:
-
-```
-# psql -U netbox -h localhost -W
-```
-
----
-
-# NetBox
-
-## Installation
-
-NetBox requires following dependencies:
-
-* python2.7
-* python-dev
-* python-pip
-* libxml2-dev
-* libxslt1-dev
-* libffi-dev
-* graphviz
-
-```
-# apt-get install python2.7 python-dev git python-pip libxml2-dev libxslt1-dev libffi-dev graphviz
-```
-
-You may opt to install NetBox either from a numbered release or by cloning the master branch of its repository on GitHub.
-
-### Option A: Download a Release
-
-Download the [latest stable release](https://github.com/digitalocean/netbox/releases) from GitHub as a tarball or ZIP archive. Extract it to your desired path. In this example, we'll use `/opt/netbox`.
-
-```
-# wget https://github.com/digitalocean/netbox/archive/vX.Y.Z.tar.gz
-# tar -xzf vX.Y.Z.tar.gz -C /opt
-# cd /opt/
-# ln -s netbox-1.0.4/ netbox
-# cd /opt/netbox/
-```
-
-### Option B: Clone the Git Repository
-
-Create the base directory for the NetBox installation. For this guide, we'll use `/opt/netbox`.
-
-```
-# mkdir -p /opt/netbox/
-# cd /opt/netbox/
-```
-
-If `git` is not already installed, install it:
-
-```
-# sudo apt-get install git
-```
-
-Next, clone the NetBox git repository into the current directory:
-
-```
-# git clone https://github.com/digitalocean/netbox.git .
-Cloning into '.'...
-remote: Counting objects: 1994, done.
-remote: Compressing objects: 100% (150/150), done.
-remote: Total 1994 (delta 80), reused 0 (delta 0), pack-reused 1842
-Receiving objects: 100% (1994/1994), 472.36 KiB | 0 bytes/s, done.
-Resolving deltas: 100% (1495/1495), done.
-Checking connectivity... done.
-```
-
-### Install Python Packages
-
-Install the necessary Python packages using pip. (If you encounter any compilation errors during this step, ensure that you've installed all of the required dependencies.)
-
-```
-# pip install -r requirements.txt
-```
-
-## Configuration
-
-Move into the NetBox configuration directory and make a copy of `configuration.example.py` named `configuration.py`.
-
-```
-# cd netbox/netbox/
-# cp configuration.example.py configuration.py
-```
-
-Open `configuration.py` with your preferred editor and set the following variables:
- 
-* ALLOWED_HOSTS
-* DATABASE
-* SECRET_KEY
-
-### ALLOWED_HOSTS
-
-This is a list of the valid hostnames by which this server can be reached. You must specify at least one name or IP address.
-
-Example:
-
-```
-ALLOWED_HOSTS = ['netbox.example.com', '192.0.2.123']
-```
-
-### DATABASE
-
-This parameter holds the database configuration details. You must define the username and password used when you configured PostgreSQL. If the service is running on a remote host, replace `localhost` with its address.
-
-Example:
-
-```
-DATABASE = {
-    'NAME': 'netbox',               # Database name
-    'USER': 'netbox',               # PostgreSQL username
-    'PASSWORD': 'J5brHrAXFLQSif0K', # PostgreSQL password
-    'HOST': 'localhost',            # Database server
-    'PORT': '',                     # Database port (leave blank for default)
-}
-```
-
-### SECRET_KEY
-
-Generate a random secret key of at least 50 alphanumeric characters. This key must be unique to this installation and must not be shared outside the local system.
-
-You may use the script located at `netbox/generate_secret_key.py` to generate a suitable key.
-
-## Run Migrations
-
-Before NetBox can run, we need to install the database schema. This is done by running `./manage.py migrate` from the `netbox` directory (`/opt/netbox/netbox/` in our example):
-
-```
-# ./manage.py migrate
-Operations to perform:
-  Apply all migrations: dcim, sessions, admin, ipam, utilities, auth, circuits, contenttypes, extras, secrets, users
-Running migrations:
-  Rendering model states... DONE
-  Applying contenttypes.0001_initial... OK
-  Applying auth.0001_initial... OK
-  Applying admin.0001_initial... OK
-  ...
-```
-
-If this step results in a PostgreSQL authentication error, ensure that the username and password created in the database match what has been specified in `configuration.py`
-
-## Create a Super User
-
-NetBox does not come with any predefined user accounts. You'll need to create a super user to be able to log into NetBox:
-
-```
-# ./manage.py createsuperuser
-Username: admin
-Email address: admin@example.com
-Password: 
-Password (again): 
-Superuser created successfully.
-```
-
-## Collect Static Files
-
-```
-# ./manage.py collectstatic
-
-You have requested to collect static files at the destination
-location as specified in your settings:
-
-    /opt/netbox/netbox/static
-
-This will overwrite existing files!
-Are you sure you want to do this?
-
-Type 'yes' to continue, or 'no' to cancel: yes
-```
-
-## Test the Application
-
-At this point, NetBox should be able to run. We can verify this by starting a development instance:
-
-```
-# ./manage.py runserver 0.0.0.0:8000 --insecure
-Performing system checks...
-
-System check identified no issues (0 silenced).
-June 17, 2016 - 16:17:36
-Django version 1.9.7, using settings 'netbox.settings'
-Starting development server at http://0.0.0.0:8000/
-Quit the server with CONTROL-C.
-```
-
-Now if we navigate to the name or IP of the server (as defined in `ALLOWED_HOSTS`) we should be greeted with the NetBox home page. Note that this built-in web service is for development and testing purposes only. It is not suited for production use.
-
-If the test service does not run, or you cannot reach the NetBox home page, something has gone wrong. Do not proceed with the rest of this guide until the installation has been corrected.
-
-# Web Server and gunicorn
-
-## Installation
-
-We'll set up a simple HTTP front end using [gunicorn](http://gunicorn.org/) for the purposes of this guide. For web servers, we provide example configurations for both [nginx](https://www.nginx.com/resources/wiki/) and [Apache](http://httpd.apache.org/docs/2.4). (You are of course free to use whichever combination of HTTP and WSGI services you'd like.) We'll also use [supervisord](http://supervisord.org/) for service persistence. 
-
-```
-# apt-get install gunicorn supervisor
-```
-
-## nginx Configuration
-
-The following will serve as a minimal nginx configuration. Be sure to modify your server name and installation path appropriately.
-
-```
-# apt-get install nginx
-```
-
-Once nginx is installed, proceed with the following configuration:
-
-```
-server {
-    listen 80;
-
-    server_name netbox.example.com;
-
-    access_log off;
-
-    location /static/ {
-        alias /opt/netbox/netbox/static/;
-    }
-
-    location / {
-        proxy_pass http://127.0.0.1:8001;
-        proxy_set_header X-Forwarded-Host $server_name;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-Proto $scheme;
-        add_header P3P 'CP="ALL DSP COR PSAa PSDa OUR NOR ONL UNI COM NAV"';
-    }
-}
-```
-
-Save this configuration to `/etc/nginx/sites-available/netbox`. Then, delete `/etc/nginx/sites-enabled/default` and create a symlink in the `sites-enabled` directory to the configuration file you just created.
-
-```
-# cd /etc/nginx/sites-enabled/
-# rm default
-# ln -s /etc/nginx/sites-available/netbox 
-```
-
-Restart the nginx service to use the new configuration.
-
-```
-# service nginx restart
- * Restarting nginx nginx
-```
-## Apache Configuration
-
-The following configuration should work for Apache. Be sure to modify the `ServerName` appropriately.
-
-```
-<VirtualHost *:80>
-    ProxyPreserveHost On
-
-    ServerName netbox.example.com
-
-    Alias /static /opt/netbox/netbox/static
-
-    <Directory /opt/netbox/netbox/static>
-        Options Indexes FollowSymLinks MultiViews
-        AllowOverride None
-        Require all granted
-    </Directory>
-
-    <Location /static>
-        ProxyPass !
-    </Location>
-
-    ProxyPass / http://127.0.0.1:8001/
-    ProxyPassReverse / http://127.0.0.1:8001/
-</VirtualHost>
-```
-
-Save the contents of the above example in `/etc/apache2/sites-available/netbox.conf`, enable the `proxy` and `proxy_http` modules, and reload Apache:
-
-```
-# a2enmod proxy
-# a2enmod proxy_http
-# a2ensite netbox
-# service apache2 restart
-```
-
-## gunicorn Configuration
-
-Save the following configuration file in the root netbox installation path (in this example, `/opt/netbox/`.) as `gunicorn_config.py`. Be sure to verify the location of the gunicorn executable (e.g. `which gunicorn`) and to update the `pythonpath` variable if needed.
-
-```
-command = '/usr/bin/gunicorn'
-pythonpath = '/opt/netbox/netbox'
-bind = '127.0.0.1:8001'
-workers = 3
-user = 'www-data'
-```
-
-## supervisord Configuration
-
-Save the following as `/etc/supervisor/conf.d/netbox.conf`. Update the `command` and `directory` paths as needed.
-
-```
-[program:netbox]
-command = gunicorn -c /opt/netbox/gunicorn_config.py netbox.wsgi
-directory = /opt/netbox/netbox/
-user = www-data
-```
-
-Finally, restart the supervisor service to detect and run the gunicorn service:
-
-```
-# service supervisor restart
-```
-
-At this point, you should be able to connect to the nginx HTTP service at the server name or IP address you provided. If you are unable to connect, check that the nginx service is running and properly configured. If you receive a 502 (bad gateway) error, this indicates that gunicorn is misconfigured or not running.
-
-Please keep in mind that the configurations provided here are bare minimums required to get NetBox up and running. You will almost certainly want to make some changes to better suit your production environment.
-
-## Let's Encrypt SSL + nginx
-
-To add SSL support to the installation we'll start by installing the arbitrary precision calculator language.
-
-```
-# sudo apt-get -y bc
-```
-
-Next we'll clone Let’s Encrypt in to /opt
-
-```
-# sudo git clone https://github.com/letsencrypt/letsencrypt /opt/letsencrypt
-```
-
-To ensure Let's Encrypt can publicly access the directory it needs for certificate validation you'll need to edit `/etc/nginx/sites-available/netbox` and add:
-
-```
-    location /.well-known/ {
-        alias /opt/netbox/netbox/.well-known/;
-        allow all;
-    }
-```
-
-Then restart nginix:
-
-```
-# sudo services nginx restart
-```
-
-To create the certificate use the following commands ensuring to change `netbox.example.com` to the domain name of the server:
-
-```
-# cd /opt/letsencrypt
-# ./letsencrypt-auto certonly -a webroot --webroot-path=/opt/netbox/netbox/ -d netbox.example.com
-```
-
-If you wish to add support for the `www` prefix you'd use:
-
-```
-# cd /opt/letsencrypt
-# ./letsencrypt-auto certonly -a webroot --webroot-path=/opt/netbox/netbox/ -d netbox.example.com -d www.netbox.example.com
-```
-
-Make sure you have DNS records setup for the hostnames you use and that they resolve back the netbox server.
-
-You will be prompted for your email address to receive notifications about your SSL and then asked to accept the subscriber agreement.
-
-If successful you'll now have four files in `/etc/letsencrypt/live/netbox.example.com` (remember, your hostname is different)
-
-```
-cert.pem
-chain.pem
-fullchain.pem
-privkey.pem
-```
-
-Now edit your nginx configuration `/etc/nginx/sites-available/netbox` and at the top edit to the following:
-
-```
-    #listen 80;
-    #listen [::]80;
-    listen 443;
-    listen [::]443;
-
-    ssl on;
-    ssl_certificate /etc/letsencrypt/live/netbox.example.com/cert.pem;
-    ssl_certificate_key /etc/letsencrypt/live/netbox.example.com/privkey.pem;
-```
-
-If you are not using IPv6 then you do not need `listen [::]443;` The two commented lines are for non-SSL for both IPv4 and IPv6.
-
-Lastly, restart nginx:
-
-```
-# sudo services nginx restart
-```
-
-You should now have netbox running on a SSL protected connection.
-
-# Upgrading
-
-As with the initial installation, you can upgrade NetBox by either downloading the latest release package or by cloning the `master` branch of the git repository. Once the new code is in place, run the upgrade script (which may need to be run as root depending on how your environment is configured).
-
-```
-# ./upgrade.sh
-```
-
-This script:
-
-* Installs or upgrades any new required Python packages
-* Applies any database migrations that were included in the release
-* Collects all static files to be served by the HTTP service
-
-Finally, restart the WSGI service to run the new code. If you followed this guide for the initial installation, this is done using `supervisorctl`:
-
-```
-# sudo supervisorctl restart netbox
-```

docs/index.md

@@ -1,3 +1,53 @@
-# NetBox Documentation
+# What is NetBox?
 
-NetBox is an IP address management (IPAM) and data center infrastructure management (DCIM) application.
+NetBox is an open source web application designed to help manage and document computer networks. Initially conceived by the network engineering team at [DigitalOcean](https://www.digitalocean.com/), NetBox was developed specifically to address the needs of network and infrastructure engineers. It encompasses the following aspects of network management:
+
+* **IP address management (IPAM)** - IP networks and addresses, VRFs, and VLANs
+* **Equipment racks** - Organized by group and site
+* **Devices** - Types of devices and where they are installed
+* **Connections** - Network, console, and power connections among devices
+* **Data circuits** - Long-haul communications circuits and providers
+* **Secrets** - Encrypted storage of sensitive credentials
+
+# What NetBox Isn't
+
+While NetBox strives to cover many areas of network management, the scope of its feature set is necessarily limited. This ensures that development focuses on core functionality and that scope creep is reasonably contained. To that end, it might help to provide some examples of functionality that NetBox **does not** provide:
+
+* Network monitoring
+* DNS server
+* RADIUS server
+* Configuration management
+* Facilities management
+
+That said, NetBox _can_ be used to great effect in populating external tools with the data they need to perform these functions.
+
+# Design Philosophy
+
+NetBox was designed with the following tenets foremost in mind.
+
+## Replicate the Real World
+
+Careful consideration has been given to the data model to ensure that it can accurately reflect a real-world network. For instance, IP addresses are assigned not to devices, but to specific interfaces attached to a device, and an interface may have multiple IP addresses assigned to it.
+
+## Serve as a "Source of Truth"
+
+NetBox intends to represent the _desired_ state of a network versus its _operational_ state. As such, automated import of live network state is strongly discouraged. All data created in NetBox should first be vetted by a human to ensure its integrity. NetBox can then be used to populate monitoring and provisioning systems with a high degree of confidence.
+
+## Keep it Simple
+
+When given a choice between a relatively simple [80% solution](https://en.wikipedia.org/wiki/Pareto_principle) and a much more complex complete solution, the former will typically be favored. This ensures a lean codebase with a low learning curve.
+
+# Application Stack
+
+NetBox is built on the [Django](https://djangoproject.com/) Python framework and utilizes a [PostgreSQL](https://www.postgresql.org/) database. It runs as a WSGI service behind your choice of HTTP server.
+
+| Function     | Component         |
+|--------------|-------------------|
+| HTTP Service | nginx or Apache   |
+| WSGI Service | gunicorn or uWSGI |
+| Application  | Django/Python     |
+| Database     | PostgreSQL        |
+
+# Getting Started
+
+See the [installation guide](installation/postgresql.md) for help getting NetBox up and running quickly.

docs/installation/docker.md

@@ -0,0 +1,51 @@
+This guide demonstrates how to build and run NetBox as a Docker container. It assumes that the latest versions of [Docker](https://www.docker.com/) and [docker-compose](https://docs.docker.com/compose/) are already installed in your host.
+
+# Quickstart
+
+To get NetBox up and running:
+
+```no-highlight
+# git clone -b master https://github.com/digitalocean/netbox.git
+# cd netbox
+# docker-compose up -d
+```
+
+The application will be available on http://localhost/ after a few minutes.
+
+Default credentials:
+
+* Username: **admin**
+* Password: **admin**
+
+# Configuration
+
+You can configure the app at runtime using variables (see `docker-compose.yml`). Possible environment variables include:
+
+* SUPERUSER_NAME
+* SUPERUSER_EMAIL
+* SUPERUSER_PASSWORD
+* ALLOWED_HOSTS
+* DB_NAME
+* DB_USER
+* DB_PASSWORD
+* DB_HOST
+* DB_PORT
+* SECRET_KEY
+* EMAIL_SERVER
+* EMAIL_PORT
+* EMAIL_USERNAME
+* EMAIL_PASSWORD
+* EMAIL_TIMEOUT
+* EMAIL_FROM
+* LOGIN_REQUIRED
+* MAINTENANCE_MODE
+* NETBOX_USERNAME
+* NETBOX_PASSWORD
+* PAGINATE_COUNT
+* TIME_ZONE
+* DATE_FORMAT
+* SHORT_DATE_FORMAT
+* TIME_FORMAT
+* SHORT_TIME_FORMAT
+* DATETIME_FORMAT
+* SHORT_DATETIME_FORMAT

docs/installation/ldap.md

@@ -0,0 +1,101 @@
+This guide explains how to implement LDAP authentication using an external server. User authentication will fall back to
+built-in Django users in the event of a failure.
+
+# Requirements
+
+## Install openldap-devel
+
+On Ubuntu:
+
+```no-highlight
+sudo apt-get install -y python-dev libldap2-dev libsasl2-dev libssl-dev
+```
+
+On CentOS:
+
+```no-highlight
+sudo yum install -y python-devel openldap-devel
+```
+
+## Install django-auth-ldap
+
+```no-highlight
+sudo pip install django-auth-ldap
+```
+
+# Configuration
+
+Create a file in the same directory as `configuration.py` (typically `netbox/netbox/`) named `ldap_config.py`. Define all of the parameters required below in `ldap_config.py`.
+
+## General Server Configuration
+
+```python
+import ldap
+
+# Server URI
+AUTH_LDAP_SERVER_URI = "ldaps://ad.example.com"
+
+# The following may be needed if you are binding to Active Directory.
+AUTH_LDAP_CONNECTION_OPTIONS = {
+    ldap.OPT_REFERRALS: 0
+}
+
+# Set the DN and password for the NetBox service account.
+AUTH_LDAP_BIND_DN = "CN=NETBOXSA, OU=Service Accounts,DC=example,DC=com"
+AUTH_LDAP_BIND_PASSWORD = "demo"
+
+# Include this setting if you want to ignore certificate errors. This might be needed to accept a self-signed cert.
+# Note that this is a NetBox-specific setting which sets:
+#     ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
+LDAP_IGNORE_CERT_ERRORS = True
+```
+
+## User Authentication
+
+```python
+from django_auth_ldap.config import LDAPSearch
+
+# This search matches users with the sAMAccountName equal to the provided username. This is required if the user's
+# username is not in their DN (Active Directory).
+AUTH_LDAP_USER_SEARCH = LDAPSearch("ou=Users,dc=example,dc=com",
+                                    ldap.SCOPE_SUBTREE,
+                                    "(sAMAccountName=%(user)s)")
+
+# If a user's DN is producible from their username, we don't need to search.
+AUTH_LDAP_USER_DN_TEMPLATE = "uid=%(user)s,ou=users,dc=example,dc=com"
+
+# You can map user attributes to Django attributes as so.
+AUTH_LDAP_USER_ATTR_MAP = {
+    "first_name": "givenName",
+    "last_name": "sn"
+}
+```
+
+# User Groups for Permissions
+
+```python
+from django_auth_ldap.config import LDAPSearch, GroupOfNamesType
+
+# This search ought to return all groups to which the user belongs. django_auth_ldap uses this to determine group
+# heirarchy.
+AUTH_LDAP_GROUP_SEARCH = LDAPSearch("dc=example,dc=com", ldap.SCOPE_SUBTREE,
+                                    "(objectClass=group)")
+AUTH_LDAP_GROUP_TYPE = GroupOfNamesType()
+
+# Define a group required to login.
+AUTH_LDAP_REQUIRE_GROUP = "CN=NETBOX_USERS,DC=example,DC=com"
+
+# Define special user types using groups. Exercise great caution when assigning superuser status.
+AUTH_LDAP_USER_FLAGS_BY_GROUP = {
+    "is_active": "cn=active,ou=groups,dc=example,dc=com",
+    "is_staff": "cn=staff,ou=groups,dc=example,dc=com",
+    "is_superuser": "cn=superuser,ou=groups,dc=example,dc=com"
+}
+
+# For more granular permissions, we can map LDAP groups to Django groups.
+AUTH_LDAP_FIND_GROUP_PERMS = True
+
+# Cache groups for one hour to reduce LDAP traffic
+AUTH_LDAP_CACHE_GROUPS = True
+AUTH_LDAP_GROUP_CACHE_TIMEOUT = 3600
+```

docs/installation/netbox.md

@@ -0,0 +1,201 @@
+# Installation
+
+**Debian/Ubuntu**
+
+```no-highlight
+# apt-get install -y python2.7 python-dev python-pip libxml2-dev libxslt1-dev libffi-dev graphviz libpq-dev libssl-dev
+```
+
+**CentOS/RHEL**
+
+```no-highlight
+# yum install -y epel-release
+# yum install -y gcc python2 python-devel python-pip libxml2-devel libxslt-devel libffi-devel graphviz openssl-devel
+```
+
+You may opt to install NetBox either from a numbered release or by cloning the master branch of its repository on GitHub.
+
+## Option A: Download a Release
+
+Download the [latest stable release](https://github.com/digitalocean/netbox/releases) from GitHub as a tarball or ZIP archive and extract it to your desired path. In this example, we'll use `/opt/netbox`.
+
+```no-highlight
+# wget https://github.com/digitalocean/netbox/archive/vX.Y.Z.tar.gz
+# tar -xzf vX.Y.Z.tar.gz -C /opt
+# cd /opt/
+# ln -s netbox-X.Y.Z/ netbox
+# cd /opt/netbox/
+```
+
+## Option B: Clone the Git Repository
+
+Create the base directory for the NetBox installation. For this guide, we'll use `/opt/netbox`.
+
+```no-highlight
+# mkdir -p /opt/netbox/ && cd /opt/netbox/
+```
+
+If `git` is not already installed, install it:
+
+**Debian/Ubuntu**
+
+```no-highlight
+# apt-get install -y git
+```
+
+**CentOS/RHEL**
+
+```no-highlight
+# yum install -y git
+```
+
+Next, clone the **master** branch of the NetBox GitHub repository into the current directory:
+
+```no-highlight
+# git clone -b master https://github.com/digitalocean/netbox.git .
+Cloning into '.'...
+remote: Counting objects: 1994, done.
+remote: Compressing objects: 100% (150/150), done.
+remote: Total 1994 (delta 80), reused 0 (delta 0), pack-reused 1842
+Receiving objects: 100% (1994/1994), 472.36 KiB | 0 bytes/s, done.
+Resolving deltas: 100% (1495/1495), done.
+Checking connectivity... done.
+```
+
+## Install Python Packages
+
+Install the required Python packages using pip. (If you encounter any compilation errors during this step, ensure that you've installed all of the system dependencies listed above.)
+
+```no-highlight
+# pip install -r requirements.txt
+```
+
+# Configuration
+
+Move into the NetBox configuration directory and make a copy of `configuration.example.py` named `configuration.py`.
+
+```no-highlight
+# cd netbox/netbox/
+# cp configuration.example.py configuration.py
+```
+
+Open `configuration.py` with your preferred editor and set the following variables:
+
+* ALLOWED_HOSTS
+* DATABASE
+* SECRET_KEY
+
+## ALLOWED_HOSTS
+
+This is a list of the valid hostnames by which this server can be reached. You must specify at least one name or IP address.
+
+Example:
+
+```python
+ALLOWED_HOSTS = ['netbox.example.com', '192.0.2.123']
+```
+
+## DATABASE
+
+This parameter holds the database configuration details. You must define the username and password used when you configured PostgreSQL. If the service is running on a remote host, replace `localhost` with its address.
+
+Example:
+
+```python
+DATABASE = {
+    'NAME': 'netbox',               # Database name
+    'USER': 'netbox',               # PostgreSQL username
+    'PASSWORD': 'J5brHrAXFLQSif0K', # PostgreSQL password
+    'HOST': 'localhost',            # Database server
+    'PORT': '',                     # Database port (leave blank for default)
+}
+```
+
+## SECRET_KEY
+
+Generate a random secret key of at least 50 alphanumeric characters. This key must be unique to this installation and must not be shared outside the local system.
+
+You may use the script located at `netbox/generate_secret_key.py` to generate a suitable key.
+
+!!! note
+    In the case of a highly available installation with multiple web servers, `SECRET_KEY` must be identical among all servers in order to maintain a persistent user session state.
+
+# Run Database Migrations
+
+Before NetBox can run, we need to install the database schema. This is done by running `./manage.py migrate` from the `netbox` directory (`/opt/netbox/netbox/` in our example):
+
+```no-highlight
+# cd /opt/netbox/netbox/
+# ./manage.py migrate
+Operations to perform:
+  Apply all migrations: dcim, sessions, admin, ipam, utilities, auth, circuits, contenttypes, extras, secrets, users
+Running migrations:
+  Rendering model states... DONE
+  Applying contenttypes.0001_initial... OK
+  Applying auth.0001_initial... OK
+  Applying admin.0001_initial... OK
+  ...
+```
+
+If this step results in a PostgreSQL authentication error, ensure that the username and password created in the database match what has been specified in `configuration.py`
+
+# Create a Super User
+
+NetBox does not come with any predefined user accounts. You'll need to create a super user to be able to log into NetBox:
+
+```no-highlight
+# ./manage.py createsuperuser
+Username: admin
+Email address: admin@example.com
+Password:
+Password (again):
+Superuser created successfully.
+```
+
+# Collect Static Files
+
+```no-highlight
+# ./manage.py collectstatic
+
+You have requested to collect static files at the destination
+location as specified in your settings:
+
+    /opt/netbox/netbox/static
+
+This will overwrite existing files!
+Are you sure you want to do this?
+
+Type 'yes' to continue, or 'no' to cancel: yes
+```
+
+# Load Initial Data (Optional)
+
+NetBox ships with some initial data to help you get started: RIR definitions, common devices roles, etc. You can delete any seed data that you don't want to keep.
+
+!!! note
+    This step is optional. It's perfectly fine to start using NetBox without using this initial data if you'd rather create everything from scratch.
+
+```no-highlight
+# ./manage.py loaddata initial_data
+Installed 43 object(s) from 4 fixture(s)
+```
+
+# Test the Application
+
+At this point, NetBox should be able to run. We can verify this by starting a development instance:
+
+```no-highlight
+# ./manage.py runserver 0.0.0.0:8000 --insecure
+Performing system checks...
+
+System check identified no issues (0 silenced).
+June 17, 2016 - 16:17:36
+Django version 1.9.7, using settings 'netbox.settings'
+Starting development server at http://0.0.0.0:8000/
+Quit the server with CONTROL-C.
+```
+
+Now if we navigate to the name or IP of the server (as defined in `ALLOWED_HOSTS`) we should be greeted with the NetBox home page. Note that this built-in web service is for development and testing purposes only. It is not suited for production use.
+
+!!! warning
+    If the test service does not run, or you cannot reach the NetBox home page, something has gone wrong. Do not proceed with the rest of this guide until the installation has been corrected.

docs/installation/postgresql.md

@@ -0,0 +1,58 @@
+NetBox requires a PostgreSQL database to store data. MySQL is not supported, as NetBox leverage's PostgreSQL's built-in [network address types](https://www.postgresql.org/docs/9.1/static/datatype-net-types.html).
+
+# Installation
+
+**Debian/Ubuntu**
+
+```no-highlight
+# apt-get install -y postgresql libpq-dev python-psycopg2
+```
+
+**CentOS/RHEL**
+
+```no-highlight
+# yum install -y postgresql postgresql-server postgresql-devel python-psycopg2
+# postgresql-setup initdb
+```
+
+If using CentOS, modify the PostgreSQL configuration to accept password-based authentication by replacing `ident` with `md5` for all host entries within `/var/lib/pgsql/data/pg_hba.conf`. For example:
+
+```no-highlight
+host    all             all             127.0.0.1/32            md5
+host    all             all             ::1/128                 md5
+```
+
+Then, start the service:
+
+```no-highlight
+# systemctl start postgresql
+```
+
+# Database Creation
+
+At a minimum, we need to create a database for NetBox and assign it a username and password for authentication. This is done with the following commands.
+
+!!! danger
+    DO NOT USE THE PASSWORD FROM THE EXAMPLE.
+
+```no-highlight
+# sudo -u postgres psql
+psql (9.3.13)
+Type "help" for help.
+
+postgres=# CREATE DATABASE netbox;
+CREATE DATABASE
+postgres=# CREATE USER netbox WITH PASSWORD 'J5brHrAXFLQSif0K';
+CREATE ROLE
+postgres=# GRANT ALL PRIVILEGES ON DATABASE netbox TO netbox;
+GRANT
+postgres=# \q
+```
+
+You can verify that authentication works issuing the following command and providing the configured password:
+
+```no-highlight
+# psql -U netbox -h localhost -W
+```
+
+If successful, you will enter a `postgres` prompt. Type `\q` to exit.

docs/installation/upgrading.md

@@ -0,0 +1,61 @@
+# Install the Latest Code
+
+As with the initial installation, you can upgrade NetBox by either downloading the latest release package or by cloning the `master` branch of the git repository. 
+
+## Option A: Download a Release
+
+Download the [latest stable release](https://github.com/digitalocean/netbox/releases) from GitHub as a tarball or ZIP archive. Extract it to your desired path. In this example, we'll use `/opt/netbox`.
+
+Download and extract the latest version:
+
+```no-highlight
+# wget https://github.com/digitalocean/netbox/archive/vX.Y.Z.tar.gz
+# tar -xzf vX.Y.Z.tar.gz -C /opt
+# cd /opt/
+# ln -sf netbox-X.Y.Z/ netbox
+```
+
+Copy the 'configuration.py' you created when first installing to the new version:
+
+```no-highlight
+# cp /opt/netbox-X.Y.Z/netbox/netbox/configuration.py /opt/netbox/netbox/netbox/configuration.py
+```
+
+If you followed the original installation guide to set up gunicorn, be sure to copy its configuration as well:
+
+```no-highlight
+# cp /opt/netbox-X.Y.Z/gunicorn_config.py /opt/netbox/gunicorn_config.py
+```
+
+## Option B: Clone the Git Repository (latest master release)
+
+This guide assumes that NetBox is installed at `/opt/netbox`. Pull down the most recent iteration of the master branch:
+
+```no-highlight
+# cd /opt/netbox
+# git checkout master
+# git pull origin master
+# git status
+```
+
+# Run the Upgrade Script
+
+Once the new code is in place, run the upgrade script (which may need to be run as root depending on how your environment is configured).
+
+```no-highlight
+# ./upgrade.sh
+```
+
+This script:
+
+* Installs or upgrades any new required Python packages
+* Applies any database migrations that were included in the release
+* Collects all static files to be served by the HTTP service
+
+# Restart the WSGI Service
+
+Finally, restart the WSGI service to run the new code. If you followed this guide for the initial installation, this is done using `supervisorctl`:
+
+```no-highlight
+# sudo supervisorctl restart netbox
+```

docs/installation/web-server.md

@@ -0,0 +1,134 @@
+# Web Server Installation
+
+We'll set up a simple WSGI front end using [gunicorn](http://gunicorn.org/) for the purposes of this guide. For web servers, we provide example configurations for both [nginx](https://www.nginx.com/resources/wiki/) and [Apache](http://httpd.apache.org/docs/2.4). (You are of course free to use whichever combination of HTTP and WSGI services you'd like.) We'll also use [supervisord](http://supervisord.org/) to enable service persistence.
+
+!!! info
+    Only Debian/Ubuntu instructions are provided here, but the installation process for CentOS/RHEL does not differ much. Please consult the documentation for those distributions for details.
+
+```no-highlight
+# apt-get install -y gunicorn supervisor
+```
+
+## Option A: nginx
+
+The following will serve as a minimal nginx configuration. Be sure to modify your server name and installation path appropriately.
+
+```no-highlight
+# apt-get install -y nginx
+```
+
+Once nginx is installed, save the following configuration to `/etc/nginx/sites-available/netbox`. Be sure to replace `netbox.example.com` with the domain name or IP address of your installation. (This should match the value configured for `ALLOWED_HOSTS` in `configuration.py`.)
+
+```nginx
+server {
+    listen 80;
+
+    server_name netbox.example.com;
+
+    access_log off;
+
+    location /static/ {
+        alias /opt/netbox/netbox/static/;
+    }
+
+    location / {
+        proxy_pass http://127.0.0.1:8001;
+        proxy_set_header X-Forwarded-Host $server_name;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        add_header P3P 'CP="ALL DSP COR PSAa PSDa OUR NOR ONL UNI COM NAV"';
+    }
+}
+```
+
+Then, delete `/etc/nginx/sites-enabled/default` and create a symlink in the `sites-enabled` directory to the configuration file you just created.
+
+```no-highlight
+# cd /etc/nginx/sites-enabled/
+# rm default
+# ln -s /etc/nginx/sites-available/netbox
+```
+
+Restart the nginx service to use the new configuration.
+
+```no-highlight
+# service nginx restart
+```
+
+To enable SSL, consider this guide on [securing nginx with Let's Encrypt](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-14-04).
+
+## Option B: Apache
+
+```no-highlight
+# apt-get install -y apache2
+```
+
+Once Apache is installed, proceed with the following configuration (Be sure to modify the `ServerName` appropriately):
+
+```apache
+<VirtualHost *:80>
+    ProxyPreserveHost On
+
+    ServerName netbox.example.com
+
+    Alias /static /opt/netbox/netbox/static
+
+    <Directory /opt/netbox/netbox/static>
+        Options Indexes FollowSymLinks MultiViews
+        AllowOverride None
+        Require all granted
+    </Directory>
+
+    <Location /static>
+        ProxyPass !
+    </Location>
+
+    ProxyPass / http://127.0.0.1:8001/
+    ProxyPassReverse / http://127.0.0.1:8001/
+</VirtualHost>
+```
+
+Save the contents of the above example in `/etc/apache2/sites-available/netbox.conf`, enable the `proxy` and `proxy_http` modules, and reload Apache:
+
+```no-highlight
+# a2enmod proxy
+# a2enmod proxy_http
+# a2ensite netbox
+# service apache2 restart
+```
+
+To enable SSL, consider this guide on [securing Apache with Let's Encrypt](https://www.digitalocean.com/community/tutorials/how-to-secure-apache-with-let-s-encrypt-on-ubuntu-14-04).
+
+# gunicorn Installation
+
+Save the following configuration file in the root netbox installation path (in this example, `/opt/netbox/`) as `gunicorn_config.py`. Be sure to verify the location of the gunicorn executable (e.g. `which gunicorn`) and to update the `pythonpath` variable if needed. If using CentOS/RHEL change the username from `www-data` to `nginx` or `apache`.
+
+```no-highlight
+command = '/usr/bin/gunicorn'
+pythonpath = '/opt/netbox/netbox'
+bind = '127.0.0.1:8001'
+workers = 3
+user = 'www-data'
+```
+
+# supervisord Installation
+
+Save the following as `/etc/supervisor/conf.d/netbox.conf`. Update the `command` and `directory` paths as needed.
+
+```no-highlight
+[program:netbox]
+command = gunicorn -c /opt/netbox/gunicorn_config.py netbox.wsgi
+directory = /opt/netbox/netbox/
+user = www-data
+```
+
+Then, restart the supervisor service to detect and run the gunicorn service:
+
+```no-highlight
+# service supervisor restart
+```
+
+At this point, you should be able to connect to the nginx HTTP service at the server name or IP address you provided. If you are unable to connect, check that the nginx service is running and properly configured. If you receive a 502 (bad gateway) error, this indicates that gunicorn is misconfigured or not running.
+
+!!! info
+    Please keep in mind that the configurations provided here are bare minimums required to get NetBox up and running. You will almost certainly want to make some changes to better suit your production environment.

mkdocs.yml

@@ -0,0 +1,25 @@
+site_name: NetBox
+
+pages:
+    - 'Introduction': 'index.md'
+    - 'Installation':
+        - 'PostgreSQL': 'installation/postgresql.md'
+        - 'NetBox': 'installation/netbox.md'
+        - 'Web Server': 'installation/web-server.md'
+        - 'LDAP (Optional)': 'installation/ldap.md'
+        - 'Upgrading': 'installation/upgrading.md'
+        - 'Alternate Install: Docker': 'installation/docker.md'
+    - 'Configuration':
+        - 'Mandatory Settings': 'configuration/mandatory-settings.md'
+        - 'Optional Settings': 'configuration/optional-settings.md'
+    - 'Data Model':
+        - 'Circuits': 'data-model/circuits.md'
+        - 'DCIM': 'data-model/dcim.md'
+        - 'IPAM': 'data-model/ipam.md'
+        - 'Secrets': 'data-model/secrets.md'
+        - 'Tenancy': 'data-model/tenancy.md'
+        - 'Extras': 'data-model/extras.md'
+    - 'API Integration': 'api-integration.md'
+
+markdown_extensions:
+    - admonition:

netbox/circuits/admin.py

@@ -21,10 +21,11 @@ class CircuitTypeAdmin(admin.ModelAdmin):
 
 @admin.register(Circuit)
 class CircuitAdmin(admin.ModelAdmin):
-    list_display = ['cid', 'provider', 'type', 'site', 'install_date', 'port_speed', 'commit_rate', 'xconnect_id']
-    list_filter = ['provider']
+    list_display = ['cid', 'provider', 'type', 'tenant', 'site', 'install_date', 'port_speed_human',
+                    'upstream_speed_human', 'commit_rate_human', 'xconnect_id']
+    list_filter = ['provider', 'type', 'tenant']
     exclude = ['interface']
 
     def get_queryset(self, request):
         qs = super(CircuitAdmin, self).get_queryset(request)
-        return qs.select_related('provider', 'type', 'site')
+        return qs.select_related('provider', 'type', 'tenant', 'site')

netbox/circuits/api/serializers.py

@@ -2,17 +2,20 @@ from rest_framework import serializers
 
 from circuits.models import Provider, CircuitType, Circuit
 from dcim.api.serializers import SiteNestedSerializer, InterfaceNestedSerializer
+from extras.api.serializers import CustomFieldSerializer
+from tenancy.api.serializers import TenantNestedSerializer
 
 
 #
 # Providers
 #
 
-class ProviderSerializer(serializers.ModelSerializer):
+class ProviderSerializer(CustomFieldSerializer, serializers.ModelSerializer):
 
     class Meta:
         model = Provider
-        fields = ['id', 'name', 'slug', 'asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments']
+        fields = ['id', 'name', 'slug', 'asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments',
+                  'custom_fields']
 
 
 class ProviderNestedSerializer(ProviderSerializer):
@@ -42,16 +45,17 @@ class CircuitTypeNestedSerializer(CircuitTypeSerializer):
 # Circuits
 #
 
-class CircuitSerializer(serializers.ModelSerializer):
+class CircuitSerializer(CustomFieldSerializer, serializers.ModelSerializer):
     provider = ProviderNestedSerializer()
     type = CircuitTypeNestedSerializer()
+    tenant = TenantNestedSerializer()
     site = SiteNestedSerializer()
     interface = InterfaceNestedSerializer()
 
     class Meta:
         model = Circuit
-        fields = ['id', 'cid', 'provider', 'type', 'site', 'interface', 'install_date', 'port_speed', 'commit_rate',
-                  'xconnect_id', 'comments']
+        fields = ['id', 'cid', 'provider', 'type', 'tenant', 'site', 'interface', 'install_date', 'port_speed',
+                  'upstream_speed', 'commit_rate', 'xconnect_id', 'comments', 'custom_fields']
 
 
 class CircuitNestedSerializer(CircuitSerializer):

netbox/circuits/api/views.py

@@ -3,22 +3,23 @@ from rest_framework import generics
 from circuits.models import Provider, CircuitType, Circuit
 from circuits.filters import CircuitFilter
 
+from extras.api.views import CustomFieldModelAPIView
 from . import serializers
 
 
-class ProviderListView(generics.ListAPIView):
+class ProviderListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List all providers
     """
-    queryset = Provider.objects.all()
+    queryset = Provider.objects.prefetch_related('custom_field_values__field')
     serializer_class = serializers.ProviderSerializer
 
 
-class ProviderDetailView(generics.RetrieveAPIView):
+class ProviderDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single provider
     """
-    queryset = Provider.objects.all()
+    queryset = Provider.objects.prefetch_related('custom_field_values__field')
     serializer_class = serializers.ProviderSerializer
 
 
@@ -38,18 +39,20 @@ class CircuitTypeDetailView(generics.RetrieveAPIView):
     serializer_class = serializers.CircuitTypeSerializer
 
 
-class CircuitListView(generics.ListAPIView):
+class CircuitListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List circuits (filterable)
     """
-    queryset = Circuit.objects.select_related('type', 'provider', 'site', 'interface__device')
+    queryset = Circuit.objects.select_related('type', 'tenant', 'provider', 'site', 'interface__device')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.CircuitSerializer
     filter_class = CircuitFilter
 
 
-class CircuitDetailView(generics.RetrieveAPIView):
+class CircuitDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single circuit
     """
-    queryset = Circuit.objects.select_related('type', 'provider', 'site', 'interface__device')
+    queryset = Circuit.objects.select_related('type', 'tenant', 'provider', 'site', 'interface__device')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.CircuitSerializer

netbox/circuits/filters.py

@@ -1,10 +1,45 @@
 import django_filters
 
+from django.db.models import Q
+
 from dcim.models import Site
+from extras.filters import CustomFieldFilterSet
+from tenancy.models import Tenant
+from utilities.filters import NullableModelMultipleChoiceFilter
+
 from .models import Provider, Circuit, CircuitType
 
 
-class CircuitFilter(django_filters.FilterSet):
+class ProviderFilter(CustomFieldFilterSet, django_filters.FilterSet):
+    q = django_filters.MethodFilter(
+        action='search',
+        label='Search',
+    )
+    site_id = django_filters.ModelMultipleChoiceFilter(
+        name='circuits__site',
+        queryset=Site.objects.all(),
+        label='Site',
+    )
+    site = django_filters.ModelMultipleChoiceFilter(
+        name='circuits__site',
+        queryset=Site.objects.all(),
+        to_field_name='slug',
+        label='Site (slug)',
+    )
+
+    class Meta:
+        model = Provider
+        fields = ['q', 'name', 'account', 'asn']
+
+    def search(self, queryset, value):
+        return queryset.filter(
+            Q(name__icontains=value) |
+            Q(account__icontains=value) |
+            Q(comments__icontains=value)
+        )
+
+
+class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
     q = django_filters.MethodFilter(
         action='search',
         label='Search',
@@ -31,6 +66,17 @@ class CircuitFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Circuit type (slug)',
     )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
     site_id = django_filters.ModelMultipleChoiceFilter(
         name='site',
         queryset=Site.objects.all(),
@@ -48,5 +94,9 @@ class CircuitFilter(django_filters.FilterSet):
         fields = ['q', 'provider_id', 'provider', 'type_id', 'type', 'site_id', 'site', 'interface', 'install_date']
 
     def search(self, queryset, value):
-        value = value.strip()
-        return queryset.filter(cid__icontains=value)
+        return queryset.filter(
+            Q(cid__icontains=value) |
+            Q(xconnect_id__icontains=value) |
+            Q(pp_info__icontains=value) |
+            Q(comments__icontains=value)
+        )

netbox/circuits/fixtures/initial_data.json

@@ -0,0 +1,26 @@
+[
+{
+    "model": "circuits.circuittype",
+    "pk": 1,
+    "fields": {
+        "name": "Internet",
+        "slug": "internet"
+    }
+},
+{
+    "model": "circuits.circuittype",
+    "pk": 2,
+    "fields": {
+        "name": "Private WAN",
+        "slug": "private-wan"
+    }
+},
+{
+    "model": "circuits.circuittype",
+    "pk": 3,
+    "fields": {
+        "name": "Out-of-Band",
+        "slug": "out-of-band"
+    }
+}
+]

netbox/circuits/forms.py

@@ -2,8 +2,10 @@ from django import forms
 from django.db.models import Count
 
 from dcim.models import Site, Device, Interface, Rack, IFACE_FF_VIRTUAL
+from extras.forms import CustomFieldForm, CustomFieldBulkEditForm, CustomFieldFilterForm
+from tenancy.models import Tenant
 from utilities.forms import (
-    APISelect, BootstrapMixin, BulkImportForm, CommentField, ConfirmationForm, CSVDataField, Livesearch, SmallTextarea,
+    APISelect, BootstrapMixin, BulkImportForm, CommentField, CSVDataField, FilterChoiceField, Livesearch, SmallTextarea,
     SlugField,
 )
 
@@ -14,7 +16,7 @@ from .models import Circuit, CircuitType, Provider
 # Providers
 #
 
-class ProviderForm(forms.ModelForm, BootstrapMixin):
+class ProviderForm(BootstrapMixin, CustomFieldForm):
     slug = SlugField()
     comments = CommentField()
 
@@ -45,18 +47,22 @@ class ProviderImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=ProviderFromCSVForm)
 
 
-class ProviderBulkEditForm(forms.Form, BootstrapMixin):
+class ProviderBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Provider.objects.all(), widget=forms.MultipleHiddenInput)
     asn = forms.IntegerField(required=False, label='ASN')
     account = forms.CharField(max_length=30, required=False, label='Account number')
     portal_url = forms.URLField(required=False, label='Portal')
     noc_contact = forms.CharField(required=False, widget=SmallTextarea, label='NOC contact')
     admin_contact = forms.CharField(required=False, widget=SmallTextarea, label='Admin contact')
-    comments = CommentField()
+    comments = CommentField(widget=SmallTextarea)
+
+    class Meta:
+        nullable_fields = ['asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments']
 
 
-class ProviderBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Provider.objects.all(), widget=forms.MultipleHiddenInput)
+class ProviderFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Provider
+    site = FilterChoiceField(queryset=Site.objects.all(), to_field_name='slug')
 
 
 #
@@ -71,22 +77,18 @@ class CircuitTypeForm(forms.ModelForm, BootstrapMixin):
         fields = ['name', 'slug']
 
 
-class CircuitTypeBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=CircuitType.objects.all(), widget=forms.MultipleHiddenInput)
-
-
 #
 # Circuits
 #
 
-class CircuitForm(forms.ModelForm, BootstrapMixin):
+class CircuitForm(BootstrapMixin, CustomFieldForm):
     site = forms.ModelChoiceField(queryset=Site.objects.all(), widget=forms.Select(attrs={'filter-for': 'rack'}))
     rack = forms.ModelChoiceField(queryset=Rack.objects.all(), required=False, label='Rack',
                                   widget=APISelect(api_url='/api/dcim/racks/?site_id={{site}}',
                                                    attrs={'filter-for': 'device'}))
     device = forms.ModelChoiceField(queryset=Device.objects.all(), required=False, label='Device',
                                     widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack}}',
-                                                     attrs={'filter-for': 'interface'}))
+                                                     display_field='display_name', attrs={'filter-for': 'interface'}))
     livesearch = forms.CharField(required=False, label='Device', widget=Livesearch(
         query_key='q', query_url='dcim-api:device_list', field_to_update='device')
     )
@@ -98,8 +100,8 @@ class CircuitForm(forms.ModelForm, BootstrapMixin):
     class Meta:
         model = Circuit
         fields = [
-            'cid', 'type', 'provider', 'site', 'rack', 'device', 'livesearch', 'interface', 'install_date',
-            'port_speed', 'commit_rate', 'xconnect_id', 'pp_info', 'comments'
+            'cid', 'type', 'provider', 'tenant', 'site', 'rack', 'device', 'livesearch', 'interface', 'install_date',
+            'port_speed', 'upstream_speed', 'commit_rate', 'xconnect_id', 'pp_info', 'comments'
         ]
         help_texts = {
             'cid': "Unique circuit ID",
@@ -159,50 +161,40 @@ class CircuitFromCSVForm(forms.ModelForm):
                                       error_messages={'invalid_choice': 'Provider not found.'})
     type = forms.ModelChoiceField(CircuitType.objects.all(), to_field_name='name',
                                   error_messages={'invalid_choice': 'Invalid circuit type.'})
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
     site = forms.ModelChoiceField(Site.objects.all(), to_field_name='name',
                                   error_messages={'invalid_choice': 'Site not found.'})
 
     class Meta:
         model = Circuit
-        fields = ['cid', 'provider', 'type', 'site', 'install_date', 'port_speed', 'commit_rate', 'xconnect_id',
-                  'pp_info']
+        fields = ['cid', 'provider', 'type', 'tenant', 'site', 'install_date', 'port_speed', 'upstream_speed',
+                  'commit_rate', 'xconnect_id', 'pp_info']
 
 
 class CircuitImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=CircuitFromCSVForm)
 
 
-class CircuitBulkEditForm(forms.Form, BootstrapMixin):
+class CircuitBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Circuit.objects.all(), widget=forms.MultipleHiddenInput)
     type = forms.ModelChoiceField(queryset=CircuitType.objects.all(), required=False)
     provider = forms.ModelChoiceField(queryset=Provider.objects.all(), required=False)
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
     port_speed = forms.IntegerField(required=False, label='Port speed (Kbps)')
     commit_rate = forms.IntegerField(required=False, label='Commit rate (Kbps)')
-    comments = CommentField()
+    comments = CommentField(widget=SmallTextarea)
+
+    class Meta:
+        nullable_fields = ['tenant', 'port_speed', 'commit_rate', 'comments']
 
 
-class CircuitBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Circuit.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def circuit_type_choices():
-    type_choices = CircuitType.objects.annotate(circuit_count=Count('circuits'))
-    return [(t.slug, '{} ({})'.format(t.name, t.circuit_count)) for t in type_choices]
-
-
-def circuit_provider_choices():
-    provider_choices = Provider.objects.annotate(circuit_count=Count('circuits'))
-    return [(p.slug, '{} ({})'.format(p.name, p.circuit_count)) for p in provider_choices]
-
-
-def circuit_site_choices():
-    site_choices = Site.objects.annotate(circuit_count=Count('circuits'))
-    return [(s.slug, '{} ({})'.format(s.name, s.circuit_count)) for s in site_choices]
-
-
-class CircuitFilterForm(forms.Form, BootstrapMixin):
-    type = forms.MultipleChoiceField(required=False, choices=circuit_type_choices)
-    provider = forms.MultipleChoiceField(required=False, choices=circuit_provider_choices,
-                                         widget=forms.SelectMultiple(attrs={'size': 8}))
-    site = forms.MultipleChoiceField(required=False, choices=circuit_site_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
+class CircuitFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Circuit
+    type = FilterChoiceField(queryset=CircuitType.objects.annotate(filter_count=Count('circuits')),
+                             to_field_name='slug')
+    provider = FilterChoiceField(queryset=Provider.objects.annotate(filter_count=Count('circuits')),
+                                 to_field_name='slug')
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('circuits')), to_field_name='slug',
+                               null_option=(0, 'None'))
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('circuits')), to_field_name='slug')

netbox/circuits/migrations/0003_provider_32bit_asn_support.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-13 19:24
+from __future__ import unicode_literals
+
+import dcim.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('circuits', '0002_auto_20160622_1821'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='provider',
+            name='asn',
+            field=dcim.fields.ASNField(blank=True, null=True, verbose_name=b'ASN'),
+        ),
+    ]

netbox/circuits/migrations/0004_circuit_add_tenant.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-07-26 21:59
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tenancy', '0001_initial'),
+        ('circuits', '0003_provider_32bit_asn_support'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='circuit',
+            name='tenant',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='circuits', to='tenancy.Tenant'),
+        ),
+    ]

netbox/circuits/migrations/0005_circuit_add_upstream_speed.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-08-08 20:24
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('circuits', '0004_circuit_add_tenant'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='circuit',
+            name='upstream_speed',
+            field=models.PositiveIntegerField(blank=True, help_text=b'Upstream speed, if different from port speed', null=True, verbose_name=b'Upstream speed (Kbps)'),
+        ),
+    ]

netbox/circuits/models.py

@@ -1,23 +1,28 @@
+from django.contrib.contenttypes.fields import GenericRelation
 from django.core.urlresolvers import reverse
 from django.db import models
 
+from dcim.fields import ASNField
 from dcim.models import Site, Interface
+from extras.models import CustomFieldModel, CustomFieldValue
+from tenancy.models import Tenant
 from utilities.models import CreatedUpdatedModel
 
 
-class Provider(CreatedUpdatedModel):
+class Provider(CreatedUpdatedModel, CustomFieldModel):
     """
     Each Circuit belongs to a Provider. This is usually a telecommunications company or similar organization. This model
     stores information pertinent to the user's relationship with the Provider.
     """
     name = models.CharField(max_length=50, unique=True)
     slug = models.SlugField(unique=True)
-    asn = models.PositiveIntegerField(blank=True, null=True, verbose_name='ASN')
+    asn = ASNField(blank=True, null=True, verbose_name='ASN')
     account = models.CharField(max_length=30, blank=True, verbose_name='Account number')
     portal_url = models.URLField(blank=True, verbose_name='Portal')
     noc_contact = models.TextField(blank=True, verbose_name='NOC contact')
     admin_contact = models.TextField(blank=True, verbose_name='Admin contact')
     comments = models.TextField(blank=True)
+    custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
     class Meta:
         ordering = ['name']
@@ -56,7 +61,7 @@ class CircuitType(models.Model):
         return "{}?type={}".format(reverse('circuits:circuit_list'), self.slug)
 
 
-class Circuit(CreatedUpdatedModel):
+class Circuit(CreatedUpdatedModel, CustomFieldModel):
     """
     A communications circuit connects two points. Each Circuit belongs to a Provider; Providers may have multiple
     circuits. Each circuit is also assigned a CircuitType and a Site. A Circuit may be terminated to a specific device
@@ -65,21 +70,25 @@ class Circuit(CreatedUpdatedModel):
     cid = models.CharField(max_length=50, verbose_name='Circuit ID')
     provider = models.ForeignKey('Provider', related_name='circuits', on_delete=models.PROTECT)
     type = models.ForeignKey('CircuitType', related_name='circuits', on_delete=models.PROTECT)
+    tenant = models.ForeignKey(Tenant, related_name='circuits', blank=True, null=True, on_delete=models.PROTECT)
     site = models.ForeignKey(Site, related_name='circuits', on_delete=models.PROTECT)
     interface = models.OneToOneField(Interface, related_name='circuit', blank=True, null=True)
     install_date = models.DateField(blank=True, null=True, verbose_name='Date installed')
     port_speed = models.PositiveIntegerField(verbose_name='Port speed (Kbps)')
+    upstream_speed = models.PositiveIntegerField(blank=True, null=True, verbose_name='Upstream speed (Kbps)',
+                                                 help_text='Upstream speed, if different from port speed')
     commit_rate = models.PositiveIntegerField(blank=True, null=True, verbose_name='Commit rate (Kbps)')
     xconnect_id = models.CharField(max_length=50, blank=True, verbose_name='Cross-connect ID')
     pp_info = models.CharField(max_length=100, blank=True, verbose_name='Patch panel/port(s)')
     comments = models.TextField(blank=True)
+    custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
     class Meta:
         ordering = ['provider', 'cid']
         unique_together = ['provider', 'cid']
 
     def __unicode__(self):
-        return "{0} {1}".format(self.provider, self.cid)
+        return u'{} {}'.format(self.provider, self.cid)
 
     def get_absolute_url(self):
         return reverse('circuits:circuit', args=[self.pk])
@@ -89,9 +98,11 @@ class Circuit(CreatedUpdatedModel):
             self.cid,
             self.provider.name,
             self.type.name,
+            self.tenant.name if self.tenant else '',
             self.site.name,
             self.install_date.isoformat() if self.install_date else '',
             str(self.port_speed),
+            str(self.upstream_speed),
             str(self.commit_rate) if self.commit_rate else '',
             self.xconnect_id,
             self.pp_info,
@@ -112,12 +123,18 @@ class Circuit(CreatedUpdatedModel):
         else:
             return '{} Kbps'.format(speed)
 
-    @property
     def port_speed_human(self):
         return self._humanize_speed(self.port_speed)
+    port_speed_human.admin_order_field = 'port_speed'
+
+    def upstream_speed_human(self):
+        if not self.upstream_speed:
+            return ''
+        return self._humanize_speed(self.upstream_speed)
+    upstream_speed_human.admin_order_field = 'upstream_speed'
 
-    @property
     def commit_rate_human(self):
         if not self.commit_rate:
             return ''
         return self._humanize_speed(self.commit_rate)
+    commit_rate_human.admin_order_field = 'commit_rate'

netbox/circuits/tables.py

@@ -6,9 +6,9 @@ from utilities.tables import BaseTable, ToggleColumn
 from .models import Circuit, CircuitType, Provider
 
 
-CIRCUITTYPE_EDIT_LINK = """
+CIRCUITTYPE_ACTIONS = """
 {% if perms.circuit.change_circuittype %}
-    <a href="{% url 'circuits:circuittype_edit' slug=record.slug %}">Edit</a>
+    <a href="{% url 'circuits:circuittype_edit' slug=record.slug %}" class="btn btn-xs btn-warning"><i class="glyphicon glyphicon-pencil" aria-hidden="true"></i></a>
 {% endif %}
 """
 
@@ -21,11 +21,12 @@ class ProviderTable(BaseTable):
     pk = ToggleColumn()
     name = tables.LinkColumn('circuits:provider', args=[Accessor('slug')], verbose_name='Name')
     asn = tables.Column(verbose_name='ASN')
+    account = tables.Column(verbose_name='Account')
     circuit_count = tables.Column(accessor=Accessor('count_circuits'), verbose_name='Circuits')
 
     class Meta(BaseTable.Meta):
         model = Provider
-        fields = ('pk', 'name', 'asn', 'circuit_count')
+        fields = ('pk', 'name', 'asn', 'account', 'circuit_count')
 
 
 #
@@ -37,11 +38,12 @@ class CircuitTypeTable(BaseTable):
     name = tables.LinkColumn(verbose_name='Name')
     circuit_count = tables.Column(verbose_name='Circuits')
     slug = tables.Column(verbose_name='Slug')
-    edit = tables.TemplateColumn(template_code=CIRCUITTYPE_EDIT_LINK, verbose_name='')
+    actions = tables.TemplateColumn(template_code=CIRCUITTYPE_ACTIONS, attrs={'td': {'class': 'text-right'}},
+                                    verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = CircuitType
-        fields = ('pk', 'name', 'circuit_count', 'slug', 'edit')
+        fields = ('pk', 'name', 'circuit_count', 'slug', 'actions')
 
 
 #
@@ -53,10 +55,13 @@ class CircuitTable(BaseTable):
     cid = tables.LinkColumn('circuits:circuit', args=[Accessor('pk')], verbose_name='ID')
     type = tables.Column(verbose_name='Type')
     provider = tables.LinkColumn('circuits:provider', args=[Accessor('provider.slug')], verbose_name='Provider')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
     site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
-    port_speed_human = tables.Column(verbose_name='Port Speed')
-    commit_rate_human = tables.Column(verbose_name='Commit Rate')
+    port_speed = tables.Column(accessor=Accessor('port_speed_human'), order_by=Accessor('port_speed'),
+                               verbose_name='Port Speed')
+    commit_rate = tables.Column(accessor=Accessor('commit_rate_human'), order_by=Accessor('commit_rate'),
+                                verbose_name='Commit Rate')
 
     class Meta(BaseTable.Meta):
         model = Circuit
-        fields = ('pk', 'cid', 'type', 'provider', 'site', 'port_speed_human', 'commit_rate_human')
+        fields = ('pk', 'cid', 'type', 'provider', 'tenant', 'site', 'port_speed', 'commit_rate')

netbox/circuits/views.py

@@ -2,6 +2,7 @@ from django.contrib.auth.mixins import PermissionRequiredMixin
 from django.db.models import Count
 from django.shortcuts import get_object_or_404, render
 
+from extras.models import Graph, GRAPH_TYPE_PROVIDER
 from utilities.views import (
     BulkDeleteView, BulkEditView, BulkImportView, ObjectDeleteView, ObjectEditView, ObjectListView,
 )
@@ -16,6 +17,8 @@ from .models import Circuit, CircuitType, Provider
 
 class ProviderListView(ObjectListView):
     queryset = Provider.objects.annotate(count_circuits=Count('circuits'))
+    filter = filters.ProviderFilter
+    filter_form = forms.ProviderFilterForm
     table = tables.ProviderTable
     edit_permissions = ['circuits.change_provider', 'circuits.delete_provider']
     template_name = 'circuits/provider_list.html'
@@ -25,10 +28,12 @@ def provider(request, slug):
 
     provider = get_object_or_404(Provider, slug=slug)
     circuits = Circuit.objects.filter(provider=provider).select_related('site', 'interface__device')
+    show_graphs = Graph.objects.filter(type=GRAPH_TYPE_PROVIDER).exists()
 
     return render(request, 'circuits/provider.html', {
         'provider': provider,
         'circuits': circuits,
+        'show_graphs': show_graphs,
     })
 
 
@@ -61,20 +66,10 @@ class ProviderBulkEditView(PermissionRequiredMixin, BulkEditView):
     template_name = 'circuits/provider_bulk_edit.html'
     default_redirect_url = 'circuits:provider_list'
 
-    def update_objects(self, pk_list, form):
-
-        fields_to_update = {}
-        for field in ['asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments']:
-            if form.cleaned_data[field]:
-                fields_to_update[field] = form.cleaned_data[field]
-
-        return self.cls.objects.filter(pk__in=pk_list).update(**fields_to_update)
-
 
 class ProviderBulkDeleteView(PermissionRequiredMixin, BulkDeleteView):
     permission_required = 'circuits.delete_provider'
     cls = Provider
-    form = forms.ProviderBulkDeleteForm
     default_redirect_url = 'circuits:provider_list'
 
 
@@ -100,7 +95,6 @@ class CircuitTypeEditView(PermissionRequiredMixin, ObjectEditView):
 class CircuitTypeBulkDeleteView(PermissionRequiredMixin, BulkDeleteView):
     permission_required = 'circuits.delete_circuittype'
     cls = CircuitType
-    form = forms.CircuitTypeBulkDeleteForm
     default_redirect_url = 'circuits:circuittype_list'
 
 
@@ -109,7 +103,7 @@ class CircuitTypeBulkDeleteView(PermissionRequiredMixin, BulkDeleteView):
 #
 
 class CircuitListView(ObjectListView):
-    queryset = Circuit.objects.select_related('provider', 'type', 'site')
+    queryset = Circuit.objects.select_related('provider', 'type', 'tenant', 'site')
     filter = filters.CircuitFilter
     filter_form = forms.CircuitFilterForm
     table = tables.CircuitTable
@@ -156,18 +150,8 @@ class CircuitBulkEditView(PermissionRequiredMixin, BulkEditView):
     template_name = 'circuits/circuit_bulk_edit.html'
     default_redirect_url = 'circuits:circuit_list'
 
-    def update_objects(self, pk_list, form):
-
-        fields_to_update = {}
-        for field in ['type', 'provider', 'port_speed', 'commit_rate', 'comments']:
-            if form.cleaned_data[field]:
-                fields_to_update[field] = form.cleaned_data[field]
-
-        return self.cls.objects.filter(pk__in=pk_list).update(**fields_to_update)
-
 
 class CircuitBulkDeleteView(PermissionRequiredMixin, BulkDeleteView):
     permission_required = 'circuits.delete_circuit'
     cls = Circuit
-    form = forms.CircuitBulkDeleteForm
     default_redirect_url = 'circuits:circuit_list'

netbox/dcim/__init__.py

@@ -1 +1 @@
-default_app_config = 'dcim.apps.IPAMConfig'
+default_app_config = 'dcim.apps.DCIMConfig'

netbox/dcim/admin.py

@@ -2,9 +2,9 @@ from django.contrib import admin
 from django.db.models import Count
 
 from .models import (
-    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceRole, DeviceType,
-    Interface, InterfaceTemplate, Manufacturer, Module, Platform, PowerOutlet, PowerOutletTemplate, PowerPort,
-    PowerPortTemplate, Rack, RackGroup, Site,
+    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceBay,
+    DeviceBayTemplate, DeviceRole, DeviceType, Interface, InterfaceTemplate, Manufacturer, Module, Platform,
+    PowerOutlet, PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup, RackRole, Site,
 )
 
 
@@ -24,9 +24,17 @@ class RackGroupAdmin(admin.ModelAdmin):
     }
 
 
+@admin.register(RackRole)
+class RackRoleAdmin(admin.ModelAdmin):
+    list_display = ['name', 'slug', 'color']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
 @admin.register(Rack)
 class RackAdmin(admin.ModelAdmin):
-    list_display = ['name', 'facility_id', 'site', 'u_height']
+    list_display = ['name', 'facility_id', 'site', 'group', 'tenant', 'role', 'type', 'width', 'u_height']
 
 
 #
@@ -61,6 +69,10 @@ class InterfaceTemplateAdmin(admin.TabularInline):
     model = InterfaceTemplate
 
 
+class DeviceBayTemplateAdmin(admin.TabularInline):
+    model = DeviceBayTemplate
+
+
 @admin.register(DeviceType)
 class DeviceTypeAdmin(admin.ModelAdmin):
     prepopulated_fields = {
@@ -72,9 +84,10 @@ class DeviceTypeAdmin(admin.ModelAdmin):
         PowerPortTemplateAdmin,
         PowerOutletTemplateAdmin,
         InterfaceTemplateAdmin,
+        DeviceBayTemplateAdmin,
     ]
-    list_display = ['model', 'manufacturer', 'slug', 'u_height', 'console_ports', 'console_server_ports', 'power_ports',
-                    'power_outlets', 'interfaces']
+    list_display = ['model', 'manufacturer', 'slug', 'part_number', 'u_height', 'console_ports', 'console_server_ports',
+                    'power_ports', 'power_outlets', 'interfaces', 'device_bays']
     list_filter = ['manufacturer']
 
     def get_queryset(self, request):
@@ -84,6 +97,7 @@ class DeviceTypeAdmin(admin.ModelAdmin):
             power_port_count=Count('power_port_templates', distinct=True),
             power_outlet_count=Count('power_outlet_templates', distinct=True),
             interface_count=Count('interface_templates', distinct=True),
+            devicebay_count=Count('device_bay_templates', distinct=True),
         )
 
     def console_ports(self, instance):
@@ -101,6 +115,9 @@ class DeviceTypeAdmin(admin.ModelAdmin):
     def interfaces(self, instance):
         return instance.interface_count
 
+    def device_bays(self, instance):
+        return instance.devicebay_count
+
 
 #
 # Devices
@@ -144,6 +161,12 @@ class InterfaceAdmin(admin.TabularInline):
     model = Interface
 
 
+class DeviceBayAdmin(admin.TabularInline):
+    model = DeviceBay
+    fk_name = 'device'
+    readonly_fields = ['installed_device']
+
+
 class ModuleAdmin(admin.TabularInline):
     model = Module
     readonly_fields = ['parent', 'discovered']
@@ -157,11 +180,13 @@ class DeviceAdmin(admin.ModelAdmin):
         PowerPortAdmin,
         PowerOutletAdmin,
         InterfaceAdmin,
+        DeviceBayAdmin,
         ModuleAdmin,
     ]
-    list_display = ['display_name', 'device_type', 'device_role', 'primary_ip', 'rack', 'position', 'serial']
+    list_display = ['display_name', 'device_type', 'device_role', 'primary_ip', 'rack', 'position', 'asset_tag',
+                    'serial']
     list_filter = ['device_role']
 
     def get_queryset(self, request):
         qs = super(DeviceAdmin, self).get_queryset(request)
-        return qs.select_related('device_type__manufacturer', 'device_role', 'primary_ip', 'rack')
+        return qs.select_related('device_type__manufacturer', 'device_role', 'primary_ip4', 'primary_ip6', 'rack')

netbox/dcim/api/serializers.py

@@ -2,22 +2,26 @@ from rest_framework import serializers
 
 from ipam.models import IPAddress
 from dcim.models import (
-    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceType, DeviceRole,
-    Interface, InterfaceConnection, InterfaceTemplate, Manufacturer, Platform, PowerOutlet, PowerOutletTemplate,
-    PowerPort, PowerPortTemplate, Rack, RackGroup, RACK_FACE_FRONT, RACK_FACE_REAR, Site,
+    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceBay, DeviceType,
+    DeviceRole, Interface, InterfaceConnection, InterfaceTemplate, Manufacturer, Module, Platform, PowerOutlet,
+    PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup, RackRole, RACK_FACE_FRONT, RACK_FACE_REAR, Site,
+    SUBDEVICE_ROLE_CHILD, SUBDEVICE_ROLE_PARENT,
 )
+from extras.api.serializers import CustomFieldSerializer
+from tenancy.api.serializers import TenantNestedSerializer
 
 
 #
 # Sites
 #
 
-class SiteSerializer(serializers.ModelSerializer):
+class SiteSerializer(CustomFieldSerializer, serializers.ModelSerializer):
+    tenant = TenantNestedSerializer()
 
     class Meta:
         model = Site
-        fields = ['id', 'name', 'slug', 'facility', 'asn', 'physical_address', 'shipping_address', 'comments',
-                  'count_prefixes', 'count_vlans', 'count_racks', 'count_devices', 'count_circuits']
+        fields = ['id', 'name', 'slug', 'tenant', 'facility', 'asn', 'physical_address', 'shipping_address', 'comments',
+                  'custom_fields', 'count_prefixes', 'count_vlans', 'count_racks', 'count_devices', 'count_circuits']
 
 
 class SiteNestedSerializer(SiteSerializer):
@@ -38,24 +42,44 @@ class RackGroupSerializer(serializers.ModelSerializer):
         fields = ['id', 'name', 'slug', 'site']
 
 
-class RackGroupNestedSerializer(SiteSerializer):
+class RackGroupNestedSerializer(RackGroupSerializer):
 
     class Meta(SiteSerializer.Meta):
         fields = ['id', 'name', 'slug']
 
 
+#
+# Rack roles
+#
+
+class RackRoleSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = RackRole
+        fields = ['id', 'name', 'slug', 'color']
+
+
+class RackRoleNestedSerializer(RackRoleSerializer):
+
+    class Meta(RackRoleSerializer.Meta):
+        fields = ['id', 'name', 'slug']
+
+
 #
 # Racks
 #
 
 
-class RackSerializer(serializers.ModelSerializer):
+class RackSerializer(CustomFieldSerializer, serializers.ModelSerializer):
     site = SiteNestedSerializer()
     group = RackGroupNestedSerializer()
+    tenant = TenantNestedSerializer()
+    role = RackRoleNestedSerializer()
 
     class Meta:
         model = Rack
-        fields = ['id', 'name', 'facility_id', 'display_name', 'site', 'group', 'u_height', 'comments']
+        fields = ['id', 'name', 'facility_id', 'display_name', 'site', 'group', 'tenant', 'role', 'type', 'width',
+                  'u_height', 'desc_units', 'comments', 'custom_fields']
 
 
 class RackNestedSerializer(RackSerializer):
@@ -69,8 +93,8 @@ class RackDetailSerializer(RackSerializer):
     rear_units = serializers.SerializerMethodField()
 
     class Meta(RackSerializer.Meta):
-        fields = ['id', 'name', 'facility_id', 'display_name', 'site', 'group', 'u_height', 'comments', 'front_units',
-                  'rear_units']
+        fields = ['id', 'name', 'facility_id', 'display_name', 'site', 'group', 'tenant', 'role', 'type', 'width',
+                  'u_height', 'desc_units', 'comments', 'custom_fields', 'front_units', 'rear_units']
 
     def get_front_units(self, obj):
         units = obj.get_rack_units(face=RACK_FACE_FRONT)
@@ -108,11 +132,19 @@ class ManufacturerNestedSerializer(ManufacturerSerializer):
 
 class DeviceTypeSerializer(serializers.ModelSerializer):
     manufacturer = ManufacturerNestedSerializer()
+    subdevice_role = serializers.SerializerMethodField()
 
     class Meta:
         model = DeviceType
-        fields = ['id', 'manufacturer', 'model', 'slug', 'u_height', 'is_full_depth', 'is_console_server', 'is_pdu',
-                  'is_network_device']
+        fields = ['id', 'manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth',
+                  'is_console_server', 'is_pdu', 'is_network_device', 'subdevice_role']
+
+    def get_subdevice_role(self, obj):
+        return {
+            SUBDEVICE_ROLE_PARENT: 'parent',
+            SUBDEVICE_ROLE_CHILD: 'child',
+            None: None,
+        }[obj.subdevice_role]
 
 
 class DeviceTypeNestedSerializer(DeviceTypeSerializer):
@@ -164,9 +196,9 @@ class DeviceTypeDetailSerializer(DeviceTypeSerializer):
     interface_templates = InterfaceTemplateNestedSerializer(many=True, read_only=True)
 
     class Meta(DeviceTypeSerializer.Meta):
-        fields = ['id', 'manufacturer', 'model', 'slug', 'u_height', 'is_full_depth', 'is_console_server', 'is_pdu',
-                  'is_network_device', 'console_port_templates', 'cs_port_templates', 'power_port_templates',
-                  'power_outlet_templates', 'interface_templates']
+        fields = ['id', 'manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth',
+                  'is_console_server', 'is_pdu', 'is_network_device', 'console_port_templates', 'cs_port_templates',
+                  'power_port_templates', 'power_outlet_templates', 'interface_templates']
 
 
 #
@@ -215,22 +247,41 @@ class DeviceIPAddressNestedSerializer(serializers.ModelSerializer):
         fields = ['id', 'family', 'address']
 
 
-class DeviceSerializer(serializers.ModelSerializer):
+class DeviceSerializer(CustomFieldSerializer, serializers.ModelSerializer):
     device_type = DeviceTypeNestedSerializer()
     device_role = DeviceRoleNestedSerializer()
+    tenant = TenantNestedSerializer()
     platform = PlatformNestedSerializer()
     rack = RackNestedSerializer()
     primary_ip = DeviceIPAddressNestedSerializer()
+    primary_ip4 = DeviceIPAddressNestedSerializer()
+    primary_ip6 = DeviceIPAddressNestedSerializer()
+    parent_device = serializers.SerializerMethodField()
 
     class Meta:
         model = Device
-        fields = ['id', 'name', 'display_name', 'device_type', 'device_role', 'platform', 'serial', 'rack', 'position',
-                  'face', 'status', 'primary_ip', 'comments']
+        fields = ['id', 'name', 'display_name', 'device_type', 'device_role', 'tenant', 'platform', 'serial',
+                  'asset_tag', 'rack', 'position', 'face', 'parent_device', 'status', 'primary_ip', 'primary_ip4',
+                  'primary_ip6', 'comments', 'custom_fields']
+
+    def get_parent_device(self, obj):
+        try:
+            device_bay = obj.parent_bay
+        except DeviceBay.DoesNotExist:
+            return None
+        return {
+            'id': device_bay.device.pk,
+            'name': device_bay.device.name,
+            'device_bay': {
+                'id': device_bay.pk,
+                'name': device_bay.name,
+            }
+        }
 
 
-class DeviceNestedSerializer(DeviceSerializer):
+class DeviceNestedSerializer(serializers.ModelSerializer):
 
-    class Meta(DeviceSerializer.Meta):
+    class Meta:
         model = Device
         fields = ['id', 'name', 'display_name']
 
@@ -319,7 +370,7 @@ class InterfaceSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Interface
-        fields = ['id', 'device', 'name', 'form_factor', 'mgmt_only', 'description', 'is_connected']
+        fields = ['id', 'device', 'name', 'form_factor', 'mac_address', 'mgmt_only', 'description', 'is_connected']
 
 
 class InterfaceNestedSerializer(InterfaceSerializer):
@@ -333,10 +384,55 @@ class InterfaceDetailSerializer(InterfaceSerializer):
     connected_interface = InterfaceSerializer(source='get_connected_interface')
 
     class Meta(InterfaceSerializer.Meta):
-        fields = ['id', 'device', 'name', 'form_factor', 'mgmt_only', 'description', 'is_connected',
+        fields = ['id', 'device', 'name', 'form_factor', 'mac_address', 'mgmt_only', 'description', 'is_connected',
                   'connected_interface']
 
 
+#
+# Device bays
+#
+
+class DeviceBaySerializer(serializers.ModelSerializer):
+    device = DeviceNestedSerializer()
+
+    class Meta:
+        model = DeviceBay
+        fields = ['id', 'device', 'name']
+
+
+class DeviceBayNestedSerializer(DeviceBaySerializer):
+    installed_device = DeviceNestedSerializer()
+
+    class Meta(DeviceBaySerializer.Meta):
+        fields = ['id', 'name', 'installed_device']
+
+
+class DeviceBayDetailSerializer(DeviceBaySerializer):
+    installed_device = DeviceNestedSerializer()
+
+    class Meta(DeviceBaySerializer.Meta):
+        fields = ['id', 'device', 'name', 'installed_device']
+
+
+#
+# Modules
+#
+
+class ModuleSerializer(serializers.ModelSerializer):
+    device = DeviceNestedSerializer()
+    manufacturer = ManufacturerNestedSerializer()
+
+    class Meta:
+        model = Module
+        fields = ['id', 'device', 'parent', 'name', 'manufacturer', 'part_id', 'serial', 'discovered']
+
+
+class ModuleNestedSerializer(ModuleSerializer):
+
+    class Meta(ModuleSerializer.Meta):
+        fields = ['id', 'device', 'parent', 'name']
+
+
 #
 # Interface connections
 #

netbox/dcim/api/urls.py

@@ -18,6 +18,10 @@ urlpatterns = [
     url(r'^rack-groups/$', RackGroupListView.as_view(), name='rackgroup_list'),
     url(r'^rack-groups/(?P<pk>\d+)/$', RackGroupDetailView.as_view(), name='rackgroup_detail'),
 
+    # Rack roles
+    url(r'^rack-roles/$', RackRoleListView.as_view(), name='rackrole_list'),
+    url(r'^rack-roles/(?P<pk>\d+)/$', RackRoleDetailView.as_view(), name='rackrole_detail'),
+
     # Racks
     url(r'^racks/$', RackListView.as_view(), name='rack_list'),
     url(r'^racks/(?P<pk>\d+)/$', RackDetailView.as_view(), name='rack_detail'),
@@ -49,6 +53,8 @@ urlpatterns = [
     url(r'^devices/(?P<pk>\d+)/power-ports/$', PowerPortListView.as_view(), name='device_powerports'),
     url(r'^devices/(?P<pk>\d+)/power-outlets/$', PowerOutletListView.as_view(), name='device_poweroutlets'),
     url(r'^devices/(?P<pk>\d+)/interfaces/$', InterfaceListView.as_view(), name='device_interfaces'),
+    url(r'^devices/(?P<pk>\d+)/device-bays/$', DeviceBayListView.as_view(), name='device_devicebays'),
+    url(r'^devices/(?P<pk>\d+)/modules/$', ModuleListView.as_view(), name='device_modules'),
 
     # Console ports
     url(r'^console-ports/(?P<pk>\d+)/$', ConsolePortView.as_view(), name='consoleport'),
@@ -60,7 +66,8 @@ urlpatterns = [
     url(r'^interfaces/(?P<pk>\d+)/$', InterfaceDetailView.as_view(), name='interface_detail'),
     url(r'^interfaces/(?P<pk>\d+)/graphs/$', GraphListView.as_view(), {'type': GRAPH_TYPE_INTERFACE},
         name='interface_graphs'),
-    url(r'^interface-connections/(?P<pk>\d+)/$', InterfaceConnectionView.as_view(), name='interfaceconnection'),
+    url(r'^interface-connections/$', InterfaceConnectionListView.as_view(), name='interfaceconnection_list'),
+    url(r'^interface-connections/(?P<pk>\d+)/$', InterfaceConnectionView.as_view(), name='interfaceconnection_detail'),
 
     # Miscellaneous
     url(r'^related-connections/$', RelatedConnectionsView.as_view(), name='related_connections'),

netbox/dcim/api/views.py

@@ -5,37 +5,39 @@ from rest_framework.settings import api_settings
 from rest_framework.views import APIView
 
 from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
 from django.http import Http404
 from django.shortcuts import get_object_or_404
 
 from dcim.models import (
-    ConsolePort, ConsoleServerPort, Device, DeviceRole, DeviceType, IFACE_FF_VIRTUAL, Interface, InterfaceConnection,
-    Manufacturer, Platform, PowerOutlet, PowerPort, Rack, RackGroup, Site,
+    ConsolePort, ConsoleServerPort, Device, DeviceBay, DeviceRole, DeviceType, IFACE_FF_VIRTUAL, Interface,
+    InterfaceConnection, Manufacturer, Module, Platform, PowerOutlet, PowerPort, Rack, RackGroup, RackRole, Site,
 )
 from dcim import filters
-from .exceptions import MissingFilterException
-from . import serializers
+from extras.api.views import CustomFieldModelAPIView
 from extras.api.renderers import BINDZoneRenderer, FlatJSONRenderer
 from utilities.api import ServiceUnavailable
+from .exceptions import MissingFilterException
+from . import serializers
 
 
 #
 # Sites
 #
 
-class SiteListView(generics.ListAPIView):
+class SiteListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List all sites
     """
-    queryset = Site.objects.all()
+    queryset = Site.objects.select_related('tenant').prefetch_related('custom_field_values__field')
     serializer_class = serializers.SiteSerializer
 
 
-class SiteDetailView(generics.RetrieveAPIView):
+class SiteDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single site
     """
-    queryset = Site.objects.all()
+    queryset = Site.objects.select_related('tenant').prefetch_related('custom_field_values__field')
     serializer_class = serializers.SiteSerializer
 
 
@@ -47,7 +49,7 @@ class RackGroupListView(generics.ListAPIView):
     """
     List all rack groups
     """
-    queryset = RackGroup.objects.all()
+    queryset = RackGroup.objects.select_related('site')
     serializer_class = serializers.RackGroupSerializer
     filter_class = filters.RackGroupFilter
 
@@ -56,28 +58,50 @@ class RackGroupDetailView(generics.RetrieveAPIView):
     """
     Retrieve a single rack group
     """
-    queryset = RackGroup.objects.all()
+    queryset = RackGroup.objects.select_related('site')
     serializer_class = serializers.RackGroupSerializer
 
 
+#
+# Rack roles
+#
+
+class RackRoleListView(generics.ListAPIView):
+    """
+    List all rack roles
+    """
+    queryset = RackRole.objects.all()
+    serializer_class = serializers.RackRoleSerializer
+
+
+class RackRoleDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single rack role
+    """
+    queryset = RackRole.objects.all()
+    serializer_class = serializers.RackRoleSerializer
+
+
 #
 # Racks
 #
 
-class RackListView(generics.ListAPIView):
+class RackListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List racks (filterable)
     """
-    queryset = Rack.objects.select_related('site')
+    queryset = Rack.objects.select_related('site', 'group__site', 'tenant')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.RackSerializer
     filter_class = filters.RackFilter
 
 
-class RackDetailView(generics.RetrieveAPIView):
+class RackDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single rack
     """
-    queryset = Rack.objects.select_related('site')
+    queryset = Rack.objects.select_related('site', 'group__site', 'tenant')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.RackDetailSerializer
 
 
@@ -189,22 +213,25 @@ class PlatformDetailView(generics.RetrieveAPIView):
 # Devices
 #
 
-class DeviceListView(generics.ListAPIView):
+class DeviceListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List devices (filterable)
     """
-    queryset = Device.objects.select_related('device_type__manufacturer', 'device_role', 'platform', 'rack__site')\
-        .prefetch_related('primary_ip__nat_outside')
+    queryset = Device.objects.select_related('device_type__manufacturer', 'device_role', 'tenant', 'platform',
+                                             'rack__site', 'parent_bay').prefetch_related('primary_ip4__nat_outside',
+                                                                                          'primary_ip6__nat_outside',
+                                                                                          'custom_field_values__field')
     serializer_class = serializers.DeviceSerializer
     filter_class = filters.DeviceFilter
     renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES + [BINDZoneRenderer, FlatJSONRenderer]
 
 
-class DeviceDetailView(generics.RetrieveAPIView):
+class DeviceDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single device
     """
-    queryset = Device.objects.all()
+    queryset = Device.objects.select_related('device_type__manufacturer', 'device_role', 'tenant', 'platform',
+                                             'rack__site', 'parent_bay').prefetch_related('custom_field_values__field')
     serializer_class = serializers.DeviceSerializer
 
 
@@ -326,6 +353,46 @@ class InterfaceConnectionView(generics.RetrieveUpdateDestroyAPIView):
     queryset = InterfaceConnection.objects.all()
 
 
+class InterfaceConnectionListView(generics.ListAPIView):
+    """
+    Retrieve a list of all interface connections
+    """
+    serializer_class = serializers.InterfaceConnectionSerializer
+    queryset = InterfaceConnection.objects.all()
+
+
+#
+# Device bays
+#
+
+class DeviceBayListView(generics.ListAPIView):
+    """
+    List device bays (by device)
+    """
+    serializer_class = serializers.DeviceBayNestedSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return DeviceBay.objects.filter(device=device).select_related('installed_device')
+
+
+#
+# Modules
+#
+
+class ModuleListView(generics.ListAPIView):
+    """
+    List device modules (by device)
+    """
+    serializer_class = serializers.ModuleSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return Module.objects.filter(device=device).select_related('device', 'manufacturer')
+
+
 #
 # Live queries
 #
@@ -364,6 +431,13 @@ class RelatedConnectionsView(APIView):
     Retrieve all connections related to a given console/power/interface connection
     """
 
+    def __init__(self):
+        super(RelatedConnectionsView, self).__init__()
+
+        # Custom fields
+        self.content_type = ContentType.objects.get_for_model(Device)
+        self.custom_fields = self.content_type.custom_fields.prefetch_related('choices')
+
     def get(self, request):
 
         peer_device = request.GET.get('peer-device')
@@ -384,53 +458,36 @@ class RelatedConnectionsView(APIView):
                 return Response()
 
         else:
-            raise MissingFilterException(detail='Must specify search parameters (peer-device and peer-interface).')
+            raise MissingFilterException(detail='Must specify search parameters "peer-device" and "peer-interface".')
 
         # Initialize response skeleton
-        response = dict()
-        response['device'] = serializers.DeviceSerializer(device).data
-        response['console-ports'] = []
-        response['power-ports'] = []
-        response['interfaces'] = []
+        response = {
+            'device': serializers.DeviceSerializer(device, context={'view': self}).data,
+            'console-ports': [],
+            'power-ports': [],
+            'interfaces': [],
+        }
 
-        # Build console connections
+        # Console connections
         console_ports = ConsolePort.objects.filter(device=device).select_related('cs_port__device')
         for cp in console_ports:
-            cp_info = dict()
-            cp_info['name'] = cp.name
-            if cp.cs_port:
-                cp_info['console-server'] = cp.cs_port.device.name
-                cp_info['port'] = cp.cs_port.name
-            else:
-                cp_info['console-server'] = None
-                cp_info['port'] = None
-            response['console-ports'].append(cp_info)
+            data = serializers.ConsolePortSerializer(instance=cp).data
+            del(data['device'])
+            response['console-ports'].append(data)
 
-        # Build power connections
+        # Power connections
         power_ports = PowerPort.objects.filter(device=device).select_related('power_outlet__device')
         for pp in power_ports:
-            pp_info = dict()
-            pp_info['name'] = pp.name
-            if pp.power_outlet:
-                pp_info['pdu'] = pp.power_outlet.device.name
-                pp_info['outlet'] = pp.power_outlet.name
-            else:
-                pp_info['pdu'] = None
-                pp_info['outlet'] = None
-            response['power-ports'].append(pp_info)
+            data = serializers.PowerPortSerializer(instance=pp).data
+            del(data['device'])
+            response['power-ports'].append(data)
 
-        # Built interface connections
-        interfaces = Interface.objects.filter(device=device)
+        # Interface connections
+        interfaces = Interface.objects.filter(device=device).select_related('connected_as_a', 'connected_as_b',
+                                                                            'circuit')
         for iface in interfaces:
-            iface_info = dict()
-            iface_info['name'] = iface.name
-            peer_interface = iface.get_connected_interface()
-            if peer_interface:
-                iface_info['device'] = peer_interface.device.name
-                iface_info['interface'] = peer_interface.name
-            else:
-                iface_info['device'] = None
-                iface_info['interface'] = None
-            response['interfaces'].append(iface_info)
+            data = serializers.InterfaceDetailSerializer(instance=iface).data
+            del(data['device'])
+            response['interfaces'].append(data)
 
         return Response(response)

netbox/dcim/apps.py

@@ -1,6 +1,6 @@
 from django.apps import AppConfig
 
 
-class IPAMConfig(AppConfig):
+class DCIMConfig(AppConfig):
     name = "dcim"
     verbose_name = "DCIM"

netbox/dcim/fields.py

@@ -0,0 +1,53 @@
+from netaddr import EUI, mac_unix_expanded
+
+from django.core.exceptions import ValidationError
+from django.core.validators import MinValueValidator, MaxValueValidator
+from django.db import models
+
+from .formfields import MACAddressFormField
+
+
+class ASNField(models.BigIntegerField):
+    description = "32-bit ASN field"
+    default_validators = [
+        MinValueValidator(1),
+        MaxValueValidator(4294967295),
+    ]
+
+
+class mac_unix_expanded_uppercase(mac_unix_expanded):
+    word_fmt = '%.2X'
+
+
+class MACAddressField(models.Field):
+    description = "PostgreSQL MAC Address field"
+
+    def python_type(self):
+        return EUI
+
+    def from_db_value(self, value, expression, connection, context):
+        return self.to_python(value)
+
+    def to_python(self, value):
+        if value is None:
+            return value
+        try:
+            return EUI(value, version=48, dialect=mac_unix_expanded_uppercase)
+        except ValueError as e:
+            raise ValidationError(e)
+
+    def db_type(self, connection):
+        return 'macaddr'
+
+    def get_prep_value(self, value):
+        if not value:
+            return None
+        return str(self.to_python(value))
+
+    def form_class(self):
+        return MACAddressFormField
+
+    def formfield(self, **kwargs):
+        defaults = {'form_class': self.form_class()}
+        defaults.update(kwargs)
+        return super(MACAddressField, self).formfield(**defaults)

netbox/dcim/filters.py

@@ -1,29 +1,43 @@
 import django_filters
+from netaddr.core import AddrFormatError
 
 from django.db.models import Q
 
+from extras.filters import CustomFieldFilterSet
+from tenancy.models import Tenant
+from utilities.filters import NullableModelMultipleChoiceFilter
 from .models import (
     ConsolePort, ConsoleServerPort, Device, DeviceRole, DeviceType, Interface, InterfaceConnection, Manufacturer,
-    Platform, PowerOutlet, PowerPort, Rack, RackGroup, Site,
+    Platform, PowerOutlet, PowerPort, Rack, RackGroup, RackRole, Site,
 )
 
 
-class SiteFilter(django_filters.FilterSet):
+class SiteFilter(CustomFieldFilterSet, django_filters.FilterSet):
     q = django_filters.MethodFilter(
         action='search',
         label='Search',
     )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
 
     class Meta:
         model = Site
         fields = ['q', 'name', 'facility', 'asn']
 
     def search(self, queryset, value):
-        value = value.strip()
         qs_filter = Q(name__icontains=value) | Q(facility__icontains=value) | Q(physical_address__icontains=value) | \
-            Q(shipping_address__icontains=value)
+            Q(shipping_address__icontains=value) | Q(comments__icontains=value)
         try:
-            qs_filter |= Q(asn=int(value))
+            qs_filter |= Q(asn=int(value.strip()))
         except ValueError:
             pass
         return queryset.filter(qs_filter)
@@ -47,7 +61,7 @@ class RackGroupFilter(django_filters.FilterSet):
         fields = ['site_id', 'site']
 
 
-class RackFilter(django_filters.FilterSet):
+class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
     q = django_filters.MethodFilter(
         action='search',
         label='Search',
@@ -63,27 +77,49 @@ class RackFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Site (slug)',
     )
-    group_id = django_filters.ModelMultipleChoiceFilter(
+    group_id = NullableModelMultipleChoiceFilter(
         name='group',
         queryset=RackGroup.objects.all(),
         label='Group (ID)',
     )
-    group = django_filters.ModelMultipleChoiceFilter(
+    group = NullableModelMultipleChoiceFilter(
         name='group',
         queryset=RackGroup.objects.all(),
         to_field_name='slug',
         label='Group',
     )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
+    role_id = NullableModelMultipleChoiceFilter(
+        name='role',
+        queryset=RackRole.objects.all(),
+        label='Role (ID)',
+    )
+    role = NullableModelMultipleChoiceFilter(
+        name='role',
+        queryset=RackRole.objects.all(),
+        to_field_name='slug',
+        label='Role (slug)',
+    )
 
     class Meta:
         model = Rack
         fields = ['q', 'site_id', 'site', 'u_height']
 
     def search(self, queryset, value):
-        value = value.strip()
         return queryset.filter(
             Q(name__icontains=value) |
-            Q(facility_id__icontains=value)
+            Q(facility_id__icontains=value) |
+            Q(comments__icontains=value)
         )
 
 
@@ -102,15 +138,19 @@ class DeviceTypeFilter(django_filters.FilterSet):
 
     class Meta:
         model = DeviceType
-        fields = ['manufacturer_id', 'manufacturer', 'model', 'u_height', 'is_console_server', 'is_pdu',
+        fields = ['manufacturer_id', 'manufacturer', 'model', 'part_number', 'u_height', 'is_console_server', 'is_pdu',
                   'is_network_device']
 
 
-class DeviceFilter(django_filters.FilterSet):
+class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
     q = django_filters.MethodFilter(
         action='search',
         label='Search',
     )
+    mac_address = django_filters.MethodFilter(
+        action='_mac_address',
+        label='MAC address',
+    )
     site_id = django_filters.ModelMultipleChoiceFilter(
         name='rack__site',
         queryset=Site.objects.all(),
@@ -122,6 +162,11 @@ class DeviceFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Site name (slug)',
     )
+    rack_group_id = django_filters.ModelMultipleChoiceFilter(
+        name='rack__group',
+        queryset=RackGroup.objects.all(),
+        label='Rack group (ID)',
+    )
     rack_id = django_filters.ModelMultipleChoiceFilter(
         name='rack',
         queryset=Rack.objects.all(),
@@ -138,6 +183,17 @@ class DeviceFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Role (slug)',
     )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
     device_type_id = django_filters.ModelMultipleChoiceFilter(
         name='device_type',
         queryset=DeviceType.objects.all(),
@@ -160,12 +216,12 @@ class DeviceFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Device model (slug)',
     )
-    platform_id = django_filters.ModelMultipleChoiceFilter(
+    platform_id = NullableModelMultipleChoiceFilter(
         name='platform',
         queryset=Platform.objects.all(),
         label='Platform (ID)',
     )
-    platform = django_filters.ModelMultipleChoiceFilter(
+    platform = NullableModelMultipleChoiceFilter(
         name='platform',
         queryset=Platform.objects.all(),
         to_field_name='slug',
@@ -190,18 +246,25 @@ class DeviceFilter(django_filters.FilterSet):
 
     class Meta:
         model = Device
-        fields = ['q', 'name', 'site_id', 'site', 'rack_id', 'role_id', 'role', 'device_type_id', 'manufacturer_id',
-                  'manufacturer', 'model', 'platform_id', 'platform', 'status', 'is_console_server', 'is_pdu',
-                  'is_network_device']
+        fields = ['q', 'name', 'serial', 'asset_tag', 'site_id', 'site', 'rack_id', 'role_id', 'role', 'device_type_id',
+                  'manufacturer_id', 'manufacturer', 'model', 'platform_id', 'platform', 'status', 'is_console_server',
+                  'is_pdu', 'is_network_device']
 
     def search(self, queryset, value):
-        value = value.strip()
         return queryset.filter(
             Q(name__icontains=value) |
-            Q(serial__icontains=value) |
-            Q(modules__serial__icontains=value)
+            Q(serial__icontains=value.strip()) |
+            Q(modules__serial__icontains=value.strip()) |
+            Q(asset_tag=value.strip()) |
+            Q(comments__icontains=value)
         ).distinct()
 
+    def _mac_address(self, queryset, value):
+        try:
+            return queryset.filter(interfaces__mac_address=value.strip()).distinct()
+        except AddrFormatError:
+            return queryset.none()
+
 
 class ConsolePortFilter(django_filters.FilterSet):
     device_id = django_filters.ModelMultipleChoiceFilter(

netbox/dcim/fixtures/dcim.json

@@ -1919,7 +1919,8 @@
         "position": 1,
         "face": 0,
         "status": true,
-        "primary_ip": 1,
+        "primary_ip4": 1,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -1938,7 +1939,8 @@
         "position": 17,
         "face": 0,
         "status": true,
-        "primary_ip": 5,
+        "primary_ip4": 5,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -1957,7 +1959,8 @@
         "position": 33,
         "face": 0,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -1976,7 +1979,8 @@
         "position": 34,
         "face": 0,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -1995,7 +1999,8 @@
         "position": 34,
         "face": 0,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -2014,7 +2019,8 @@
         "position": 33,
         "face": 0,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -2033,7 +2039,8 @@
         "position": 1,
         "face": 0,
         "status": true,
-        "primary_ip": 3,
+        "primary_ip4": 3,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -2052,7 +2059,8 @@
         "position": 17,
         "face": 0,
         "status": true,
-        "primary_ip": 19,
+        "primary_ip4": 19,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -2071,7 +2079,8 @@
         "position": 42,
         "face": 0,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -2090,7 +2099,8 @@
         "position": null,
         "face": null,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -2109,7 +2119,8 @@
         "position": null,
         "face": null,
         "status": true,
-        "primary_ip": null,
+        "primary_ip4": null,
+        "primary_ip6": null,
         "comments": ""
     }
 },
@@ -3419,6 +3430,7 @@
     "fields": {
         "device": 3,
         "name": "em0",
+        "mac_address": "00-00-00-AA-BB-CC",
         "form_factor": 800,
         "mgmt_only": true,
         "description": ""
@@ -3772,6 +3784,7 @@
         "device": 4,
         "name": "em0",
         "form_factor": 1000,
+        "mac_address": "ff-ee-dd-33-22-11",
         "mgmt_only": true,
         "description": ""
     }
@@ -5686,6 +5699,7 @@
         "device": 9,
         "name": "eth0",
         "form_factor": 1000,
+        "mac_address": "44-55-66-77-88-99",
         "mgmt_only": true,
         "description": ""
     }
@@ -5865,4 +5879,4 @@
         "connection_status": true
     }
 }
-]
+]

netbox/dcim/fixtures/initial_data.json

@@ -0,0 +1,201 @@
+[
+{
+    "model": "dcim.devicerole",
+    "pk": 1,
+    "fields": {
+        "name": "Console Server",
+        "slug": "console-server",
+        "color": "009688"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 2,
+    "fields": {
+        "name": "Core Switch",
+        "slug": "core-switch",
+        "color": "2196f3"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 3,
+    "fields": {
+        "name": "Distribution Switch",
+        "slug": "distribution-switch",
+        "color": "2196f3"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 4,
+    "fields": {
+        "name": "Access Switch",
+        "slug": "access-switch",
+        "color": "2196f3"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 5,
+    "fields": {
+        "name": "Management Switch",
+        "slug": "management-switch",
+        "color": "ff9800"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 6,
+    "fields": {
+        "name": "Firewall",
+        "slug": "firewall",
+        "color": "f44336"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 7,
+    "fields": {
+        "name": "Router",
+        "slug": "router",
+        "color": "9c27b0"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 8,
+    "fields": {
+        "name": "Server",
+        "slug": "server",
+        "color": "9e9e9e"
+    }
+},
+{
+    "model": "dcim.devicerole",
+    "pk": 9,
+    "fields": {
+        "name": "PDU",
+        "slug": "pdu",
+        "color": "607d8b"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 1,
+    "fields": {
+        "name": "APC",
+        "slug": "apc"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 2,
+    "fields": {
+        "name": "Cisco",
+        "slug": "cisco"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 3,
+    "fields": {
+        "name": "Dell",
+        "slug": "dell"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 4,
+    "fields": {
+        "name": "HP",
+        "slug": "hp"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 5,
+    "fields": {
+        "name": "Juniper",
+        "slug": "juniper"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 6,
+    "fields": {
+        "name": "Arista",
+        "slug": "arista"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 7,
+    "fields": {
+        "name": "Opengear",
+        "slug": "opengear"
+    }
+},
+{
+    "model": "dcim.manufacturer",
+    "pk": 8,
+    "fields": {
+        "name": "Super Micro",
+        "slug": "super-micro"
+    }
+},
+{
+    "model": "dcim.platform",
+    "pk": 1,
+    "fields": {
+        "name": "Cisco IOS",
+        "slug": "cisco-ios",
+        "rpc_client": "cisco-ios"
+    }
+},
+{
+    "model": "dcim.platform",
+    "pk": 2,
+    "fields": {
+        "name": "Cisco NX-OS",
+        "slug": "cisco-nx-os",
+        "rpc_client": ""
+    }
+},
+{
+    "model": "dcim.platform",
+    "pk": 3,
+    "fields": {
+        "name": "Juniper Junos",
+        "slug": "juniper-junos",
+        "rpc_client": "juniper-junos"
+    }
+},
+{
+    "model": "dcim.platform",
+    "pk": 4,
+    "fields": {
+        "name": "Arista EOS",
+        "slug": "arista-eos",
+        "rpc_client": ""
+    }
+},
+{
+    "model": "dcim.platform",
+    "pk": 5,
+    "fields": {
+        "name": "Linux",
+        "slug": "linux",
+        "rpc_client": ""
+    }
+},
+{
+    "model": "dcim.platform",
+    "pk": 6,
+    "fields": {
+        "name": "Opengear",
+        "slug": "opengear",
+        "rpc_client": "opengear"
+    }
+}
+]

netbox/dcim/formfields.py

@@ -0,0 +1,26 @@
+from netaddr import EUI, AddrFormatError
+
+from django import forms
+from django.core.exceptions import ValidationError
+
+
+#
+# Form fields
+#
+
+class MACAddressFormField(forms.Field):
+    default_error_messages = {
+        'invalid': "Enter a valid MAC address.",
+    }
+
+    def to_python(self, value):
+        if not value:
+            return None
+
+        if isinstance(value, EUI):
+            return value
+
+        try:
+            return EUI(value, version=48)
+        except AddrFormatError:
+            raise ValidationError("Please specify a valid MAC address.")

netbox/dcim/forms.py

@@ -1,19 +1,24 @@
 import re
 
 from django import forms
+from django.core.exceptions import ValidationError
 from django.db.models import Count, Q
 
+from extras.forms import CustomFieldForm, CustomFieldBulkEditForm, CustomFieldFilterForm
 from ipam.models import IPAddress
+from tenancy.models import Tenant
 from utilities.forms import (
-    APISelect, BootstrapMixin, BulkImportForm, CommentField, ConfirmationForm, CSVDataField, ExpandableNameField,
-    FlexibleModelChoiceField, Livesearch, SelectWithDisabled, SmallTextarea, SlugField,
+    APISelect, add_blank_choice, BootstrapMixin, BulkEditForm, BulkImportForm, CommentField, CSVDataField,
+    ExpandableNameField, FilterChoiceField, FlexibleModelChoiceField, Livesearch, SelectWithDisabled, SmallTextarea,
+    SlugField,
 )
 
 from .models import (
-    CONNECTION_STATUS_CHOICES, CONNECTION_STATUS_PLANNED, CONNECTION_STATUS_CONNECTED, ConsolePort, ConsolePortTemplate,
-    ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceRole, DeviceType, Interface, IFACE_FF_VIRTUAL,
-    InterfaceConnection, InterfaceTemplate, Manufacturer, Module, Platform, PowerOutlet, PowerOutletTemplate, PowerPort,
-    PowerPortTemplate, Rack, RackGroup, Site, STATUS_CHOICES
+    DeviceBay, DeviceBayTemplate, CONNECTION_STATUS_CHOICES, CONNECTION_STATUS_PLANNED, CONNECTION_STATUS_CONNECTED,
+    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceRole, DeviceType,
+    Interface, IFACE_FF_CHOICES, IFACE_FF_VIRTUAL, InterfaceConnection, InterfaceTemplate, Manufacturer, Module,
+    Platform, PowerOutlet, PowerOutletTemplate, PowerPort, PowerPortTemplate, RACK_TYPE_CHOICES, RACK_WIDTH_CHOICES,
+    Rack, RackGroup, RackRole, Site, STATUS_CHOICES, SUBDEVICE_ROLE_CHILD
 )
 
 
@@ -38,17 +43,25 @@ def get_device_by_name_or_pk(name):
     return device
 
 
+def validate_connection_status(value):
+    """
+    Custom validator for connection statuses. value must be either "planned" or "connected" (case-insensitive).
+    """
+    if value.lower() not in ['planned', 'connected']:
+        raise ValidationError('Invalid connection status ({}); must be either "planned" or "connected".'.format(value))
+
+
 #
 # Sites
 #
 
-class SiteForm(forms.ModelForm, BootstrapMixin):
+class SiteForm(BootstrapMixin, CustomFieldForm):
     slug = SlugField()
     comments = CommentField()
 
     class Meta:
         model = Site
-        fields = ['name', 'slug', 'facility', 'asn', 'physical_address', 'shipping_address', 'comments']
+        fields = ['name', 'slug', 'tenant', 'facility', 'asn', 'physical_address', 'shipping_address', 'comments']
         widgets = {
             'physical_address': SmallTextarea(attrs={'rows': 3}),
             'shipping_address': SmallTextarea(attrs={'rows': 3}),
@@ -63,16 +76,32 @@ class SiteForm(forms.ModelForm, BootstrapMixin):
 
 
 class SiteFromCSVForm(forms.ModelForm):
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
 
     class Meta:
         model = Site
-        fields = ['name', 'slug', 'facility', 'asn']
+        fields = ['name', 'slug', 'tenant', 'facility', 'asn']
 
 
 class SiteImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=SiteFromCSVForm)
 
 
+class SiteBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
+    pk = forms.ModelMultipleChoiceField(queryset=Site.objects.all(), widget=forms.MultipleHiddenInput)
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+
+    class Meta:
+        nullable_fields = ['tenant']
+
+
+class SiteFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Site
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('sites')), to_field_name='slug',
+                               null_option=(0, 'None'))
+
+
 #
 # Rack groups
 #
@@ -85,25 +114,27 @@ class RackGroupForm(forms.ModelForm, BootstrapMixin):
         fields = ['site', 'name', 'slug']
 
 
-class RackGroupBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=RackGroup.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def rackgroup_site_choices():
-    site_choices = Site.objects.annotate(rack_count=Count('rack_groups'))
-    return [(s.slug, '{} ({})'.format(s.name, s.rack_count)) for s in site_choices]
-
-
 class RackGroupFilterForm(forms.Form, BootstrapMixin):
-    site = forms.MultipleChoiceField(required=False, choices=rackgroup_site_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('rack_groups')), to_field_name='slug')
+
+
+#
+# Rack roles
+#
+
+class RackRoleForm(forms.ModelForm, BootstrapMixin):
+    slug = SlugField()
+
+    class Meta:
+        model = RackRole
+        fields = ['name', 'slug', 'color']
 
 
 #
 # Racks
 #
 
-class RackForm(forms.ModelForm, BootstrapMixin):
+class RackForm(BootstrapMixin, CustomFieldForm):
     group = forms.ModelChoiceField(queryset=RackGroup.objects.all(), required=False, label='Group', widget=APISelect(
         api_url='/api/dcim/rack-groups/?site_id={{site}}',
     ))
@@ -111,7 +142,8 @@ class RackForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = Rack
-        fields = ['site', 'group', 'name', 'facility_id', 'u_height', 'comments']
+        fields = ['site', 'group', 'name', 'facility_id', 'tenant', 'role', 'type', 'width', 'u_height', 'desc_units',
+                  'comments']
         help_texts = {
             'site': "The site at which the rack exists",
             'name': "Organizational rack name",
@@ -139,10 +171,16 @@ class RackFromCSVForm(forms.ModelForm):
     site = forms.ModelChoiceField(queryset=Site.objects.all(), to_field_name='name',
                                   error_messages={'invalid_choice': 'Site not found.'})
     group_name = forms.CharField(required=False)
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
+    role = forms.ModelChoiceField(RackRole.objects.all(), to_field_name='name', required=False,
+                                  error_messages={'invalid_choice': 'Role not found.'})
+    type = forms.CharField(required=False)
 
     class Meta:
         model = Rack
-        fields = ['site', 'group_name', 'name', 'facility_id', 'u_height']
+        fields = ['site', 'group_name', 'name', 'facility_id', 'tenant', 'role', 'type', 'width', 'u_height',
+                  'desc_units']
 
     def clean(self):
 
@@ -156,38 +194,48 @@ class RackFromCSVForm(forms.ModelForm):
             except RackGroup.DoesNotExist:
                 self.add_error('group_name', "Invalid rack group ({})".format(group))
 
+    def clean_type(self):
+        rack_type = self.cleaned_data['type']
+        if not rack_type:
+            return None
+        try:
+            choices = {v.lower(): k for k, v in RACK_TYPE_CHOICES}
+            return choices[rack_type.lower()]
+        except KeyError:
+            raise forms.ValidationError('Invalid rack type ({}). Valid choices are: {}.'.format(
+                rack_type,
+                ', '.join({v: k for k, v in RACK_TYPE_CHOICES}),
+            ))
+
 
 class RackImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=RackFromCSVForm)
 
 
-class RackBulkEditForm(forms.Form, BootstrapMixin):
+class RackBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Rack.objects.all(), widget=forms.MultipleHiddenInput)
-    site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False)
-    group = forms.ModelChoiceField(queryset=RackGroup.objects.all(), required=False)
+    site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, label='Site')
+    group = forms.ModelChoiceField(queryset=RackGroup.objects.all(), required=False, label='Group')
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+    role = forms.ModelChoiceField(queryset=RackRole.objects.all(), required=False)
+    type = forms.ChoiceField(choices=add_blank_choice(RACK_TYPE_CHOICES), required=False, label='Type')
+    width = forms.ChoiceField(choices=add_blank_choice(RACK_WIDTH_CHOICES), required=False, label='Width')
     u_height = forms.IntegerField(required=False, label='Height (U)')
-    comments = CommentField()
+    comments = CommentField(widget=SmallTextarea)
+
+    class Meta:
+        nullable_fields = ['group', 'tenant', 'role', 'comments']
 
 
-class RackBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Rack.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def rack_site_choices():
-    site_choices = Site.objects.annotate(rack_count=Count('racks'))
-    return [(s.slug, '{} ({})'.format(s.name, s.rack_count)) for s in site_choices]
-
-
-def rack_group_choices():
-    group_choices = RackGroup.objects.select_related('site').annotate(rack_count=Count('racks'))
-    return [(g.pk, '{} ({})'.format(g, g.rack_count)) for g in group_choices]
-
-
-class RackFilterForm(forms.Form, BootstrapMixin):
-    site = forms.MultipleChoiceField(required=False, choices=rack_site_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
-    group_id = forms.MultipleChoiceField(required=False, choices=rack_group_choices,
-                                         widget=forms.SelectMultiple(attrs={'size': 8}))
+class RackFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Rack
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('racks')), to_field_name='slug')
+    group_id = FilterChoiceField(queryset=RackGroup.objects.select_related('site')
+                                 .annotate(filter_count=Count('racks')), label='Rack group', null_option=(0, 'None'))
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('racks')), to_field_name='slug',
+                               null_option=(0, 'None'))
+    role = FilterChoiceField(queryset=RackRole.objects.annotate(filter_count=Count('racks')), to_field_name='slug',
+                             null_option=(0, 'None'))
 
 
 #
@@ -202,10 +250,6 @@ class ManufacturerForm(forms.ModelForm, BootstrapMixin):
         fields = ['name', 'slug']
 
 
-class ManufacturerBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Manufacturer.objects.all(), widget=forms.MultipleHiddenInput)
-
-
 #
 # Device types
 #
@@ -215,28 +259,22 @@ class DeviceTypeForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = DeviceType
-        fields = ['manufacturer', 'model', 'slug', 'u_height', 'is_full_depth', 'is_console_server', 'is_pdu',
-                  'is_network_device']
+        fields = ['manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth', 'is_console_server',
+                  'is_pdu', 'is_network_device', 'subdevice_role']
 
 
-class DeviceTypeBulkEditForm(forms.Form, BootstrapMixin):
+class DeviceTypeBulkEditForm(BulkEditForm, BootstrapMixin):
     pk = forms.ModelMultipleChoiceField(queryset=DeviceType.objects.all(), widget=forms.MultipleHiddenInput)
     manufacturer = forms.ModelChoiceField(queryset=Manufacturer.objects.all(), required=False)
     u_height = forms.IntegerField(min_value=1, required=False)
 
-
-class DeviceTypeBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=DeviceType.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def devicetype_manufacturer_choices():
-    manufacturer_choices = Manufacturer.objects.annotate(devicetype_count=Count('device_types'))
-    return [(m.slug, '{} ({})'.format(m.name, m.devicetype_count)) for m in manufacturer_choices]
+    class Meta:
+        nullable_fields = []
 
 
 class DeviceTypeFilterForm(forms.Form, BootstrapMixin):
-    manufacturer = forms.MultipleChoiceField(required=False, choices=devicetype_manufacturer_choices,
-                                             widget=forms.SelectMultiple(attrs={'size': 8}))
+    manufacturer = FilterChoiceField(queryset=Manufacturer.objects.annotate(filter_count=Count('device_types')),
+                                     to_field_name='slug')
 
 
 #
@@ -283,6 +321,22 @@ class InterfaceTemplateForm(forms.ModelForm, BootstrapMixin):
         fields = ['name_pattern', 'form_factor', 'mgmt_only']
 
 
+class InterfaceTemplateBulkEditForm(BootstrapMixin, BulkEditForm):
+    pk = forms.ModelMultipleChoiceField(queryset=InterfaceTemplate.objects.all(), widget=forms.MultipleHiddenInput)
+    form_factor = forms.ChoiceField(choices=add_blank_choice(IFACE_FF_CHOICES), required=False)
+
+    class Meta:
+        nullable_fields = []
+
+
+class DeviceBayTemplateForm(forms.ModelForm, BootstrapMixin):
+    name_pattern = ExpandableNameField(label='Name')
+
+    class Meta:
+        model = DeviceBayTemplate
+        fields = ['name_pattern']
+
+
 #
 # Device roles
 #
@@ -295,10 +349,6 @@ class DeviceRoleForm(forms.ModelForm, BootstrapMixin):
         fields = ['name', 'slug', 'color']
 
 
-class DeviceRoleBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=DeviceRole.objects.all(), widget=forms.MultipleHiddenInput)
-
-
 #
 # Platforms
 #
@@ -311,28 +361,24 @@ class PlatformForm(forms.ModelForm, BootstrapMixin):
         fields = ['name', 'slug']
 
 
-class PlatformBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Platform.objects.all(), widget=forms.MultipleHiddenInput)
-
-
 #
 # Devices
 #
 
-class DeviceForm(forms.ModelForm, BootstrapMixin):
+class DeviceForm(BootstrapMixin, CustomFieldForm):
     site = forms.ModelChoiceField(queryset=Site.objects.all(), widget=forms.Select(attrs={'filter-for': 'rack'}))
     rack = forms.ModelChoiceField(queryset=Rack.objects.all(), widget=APISelect(
         api_url='/api/dcim/racks/?site_id={{site}}',
         display_field='display_name',
         attrs={'filter-for': 'position'}
     ))
-    position = forms.TypedChoiceField(required=False, empty_value=None, widget=APISelect(
-        api_url='/api/dcim/racks/{{rack}}/rack-units/?face={{face}}',
-        disabled_indicator='device',
-    ))
+    position = forms.TypedChoiceField(required=False, empty_value=None,
+                                      help_text="The lowest-numbered unit occupied by the device",
+                                      widget=APISelect(api_url='/api/dcim/racks/{{rack}}/rack-units/?face={{face}}',
+                                                       disabled_indicator='device'))
     manufacturer = forms.ModelChoiceField(queryset=Manufacturer.objects.all(),
                                           widget=forms.Select(attrs={'filter-for': 'device_type'}))
-    device_type = forms.ModelChoiceField(queryset=DeviceType.objects.all(), label='Model', widget=APISelect(
+    device_type = forms.ModelChoiceField(queryset=DeviceType.objects.all(), label='Device type', widget=APISelect(
         api_url='/api/dcim/device-types/?manufacturer_id={{manufacturer}}',
         display_field='model'
     ))
@@ -340,8 +386,8 @@ class DeviceForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = Device
-        fields = ['name', 'device_role', 'device_type', 'serial', 'site', 'rack', 'position', 'face', 'status',
-                  'platform', 'primary_ip', 'comments']
+        fields = ['name', 'device_role', 'tenant', 'device_type', 'serial', 'asset_tag', 'site', 'rack', 'position',
+                  'face', 'status', 'platform', 'primary_ip4', 'primary_ip6', 'comments']
         help_texts = {
             'device_role': "The function this device serves",
             'serial': "Chassis serial number",
@@ -361,23 +407,26 @@ class DeviceForm(forms.ModelForm, BootstrapMixin):
             self.initial['site'] = self.instance.rack.site
             self.initial['manufacturer'] = self.instance.device_type.manufacturer
 
-            # Compile list of IPs assigned to this device
-            primary_ip_choices = []
-            interface_ips = IPAddress.objects.filter(interface__device=self.instance)
-            primary_ip_choices += [(ip.id, '{} ({})'.format(ip.address, ip.interface)) for ip in interface_ips]
-            nat_ips = IPAddress.objects.filter(nat_inside__interface__device=self.instance)\
-                .select_related('nat_inside__interface')
-            primary_ip_choices += [(ip.id, '{} ({} NAT)'.format(ip.address, ip.nat_inside.interface)) for ip in nat_ips]
-            self.fields['primary_ip'].choices = [(None, '---------')] + primary_ip_choices
+            # Compile list of choices for primary IPv4 and IPv6 addresses
+            for family in [4, 6]:
+                ip_choices = []
+                interface_ips = IPAddress.objects.filter(family=family, interface__device=self.instance)
+                ip_choices += [(ip.id, u'{} ({})'.format(ip.address, ip.interface)) for ip in interface_ips]
+                nat_ips = IPAddress.objects.filter(family=family, nat_inside__interface__device=self.instance)\
+                    .select_related('nat_inside__interface')
+                ip_choices += [(ip.id, u'{} ({} NAT)'.format(ip.address, ip.nat_inside.interface)) for ip in nat_ips]
+                self.fields['primary_ip{}'.format(family)].choices = [(None, '---------')] + ip_choices
 
         else:
 
             # An object that doesn't exist yet can't have any IPs assigned to it
-            self.fields['primary_ip'].choices = []
-            self.fields['primary_ip'].widget.attrs['readonly'] = True
+            self.fields['primary_ip4'].choices = []
+            self.fields['primary_ip4'].widget.attrs['readonly'] = True
+            self.fields['primary_ip6'].choices = []
+            self.fields['primary_ip6'].widget.attrs['readonly'] = True
 
         # Limit rack choices
-        if self.is_bound:
+        if self.is_bound and self.data.get('site'):
             self.fields['rack'].queryset = Rack.objects.filter(site__pk=self.data['site'])
         elif self.initial.get('site'):
             self.fields['rack'].queryset = Rack.objects.filter(site=self.initial['site'])
@@ -385,8 +434,8 @@ class DeviceForm(forms.ModelForm, BootstrapMixin):
             self.fields['rack'].choices = []
 
         # Rack position
+        pk = self.instance.pk if self.instance.pk else None
         try:
-            pk = self.instance.pk if self.instance.pk else None
             if self.is_bound and self.data.get('rack') and str(self.data.get('face')):
                 position_choices = Rack.objects.get(pk=self.data['rack'])\
                     .get_rack_units(face=self.data.get('face'), exclude=pk)
@@ -414,32 +463,33 @@ class DeviceForm(forms.ModelForm, BootstrapMixin):
         else:
             self.fields['device_type'].choices = []
 
+        # Disable rack assignment if this is a child device installed in a parent device
+        if pk and self.instance.device_type.is_child_device and hasattr(self.instance, 'parent_bay'):
+            self.fields['site'].disabled = True
+            self.fields['rack'].disabled = True
+            self.initial['site'] = self.instance.parent_bay.device.rack.site_id
+            self.initial['rack'] = self.instance.parent_bay.device.rack_id
 
-class DeviceFromCSVForm(forms.ModelForm):
+
+class BaseDeviceFromCSVForm(forms.ModelForm):
     device_role = forms.ModelChoiceField(queryset=DeviceRole.objects.all(), to_field_name='name',
                                          error_messages={'invalid_choice': 'Invalid device role.'})
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
     manufacturer = forms.ModelChoiceField(queryset=Manufacturer.objects.all(), to_field_name='name',
                                           error_messages={'invalid_choice': 'Invalid manufacturer.'})
     model_name = forms.CharField()
     platform = forms.ModelChoiceField(queryset=Platform.objects.all(), required=False, to_field_name='name',
                                       error_messages={'invalid_choice': 'Invalid platform.'})
-    site = forms.ModelChoiceField(queryset=Site.objects.all(), to_field_name='name', error_messages={
-        'invalid_choice': 'Invalid site name.',
-    })
-    rack_name = forms.CharField()
-    face = forms.CharField(required=False)
 
     class Meta:
+        fields = []
         model = Device
-        fields = ['name', 'device_role', 'manufacturer', 'model_name', 'platform', 'serial', 'site', 'rack_name',
-                  'position', 'face']
 
     def clean(self):
 
         manufacturer = self.cleaned_data.get('manufacturer')
         model_name = self.cleaned_data.get('model_name')
-        site = self.cleaned_data.get('site')
-        rack_name = self.cleaned_data.get('rack_name')
 
         # Validate device type
         if manufacturer and model_name:
@@ -448,6 +498,25 @@ class DeviceFromCSVForm(forms.ModelForm):
             except DeviceType.DoesNotExist:
                 self.add_error('model_name', "Invalid device type ({} {})".format(manufacturer, model_name))
 
+
+class DeviceFromCSVForm(BaseDeviceFromCSVForm):
+    site = forms.ModelChoiceField(queryset=Site.objects.all(), to_field_name='name', error_messages={
+        'invalid_choice': 'Invalid site name.',
+    })
+    rack_name = forms.CharField()
+    face = forms.CharField(required=False)
+
+    class Meta(BaseDeviceFromCSVForm.Meta):
+        fields = ['name', 'device_role', 'tenant', 'manufacturer', 'model_name', 'platform', 'serial', 'asset_tag',
+                  'site', 'rack_name', 'position', 'face']
+
+    def clean(self):
+
+        super(DeviceFromCSVForm, self).clean()
+
+        site = self.cleaned_data.get('site')
+        rack_name = self.cleaned_data.get('rack_name')
+
         # Validate rack
         if site and rack_name:
             try:
@@ -457,64 +526,93 @@ class DeviceFromCSVForm(forms.ModelForm):
 
     def clean_face(self):
         face = self.cleaned_data['face']
-        if face:
+        if not face:
+            return None
+        try:
+            return {
+                'front': 0,
+                'rear': 1,
+            }[face.lower()]
+        except KeyError:
+            raise forms.ValidationError('Invalid rack face ({}); must be "front" or "rear".'.format(face))
+
+
+class ChildDeviceFromCSVForm(BaseDeviceFromCSVForm):
+    parent = FlexibleModelChoiceField(queryset=Device.objects.all(), to_field_name='name', required=False,
+                                      error_messages={'invalid_choice': 'Parent device not found.'})
+    device_bay_name = forms.CharField(required=False)
+
+    class Meta(BaseDeviceFromCSVForm.Meta):
+        fields = ['name', 'device_role', 'tenant', 'manufacturer', 'model_name', 'platform', 'serial', 'asset_tag',
+                  'parent', 'device_bay_name']
+
+    def clean(self):
+
+        super(ChildDeviceFromCSVForm, self).clean()
+
+        parent = self.cleaned_data.get('parent')
+        device_bay_name = self.cleaned_data.get('device_bay_name')
+
+        # Validate device bay
+        if parent and device_bay_name:
             try:
-                return {
-                    'front': 0,
-                    'rear': 1,
-                }[face.lower()]
-            except KeyError:
-                raise forms.ValidationError('Invalid rack face ({}); must be "front" or "rear".'.format(face))
-        return face
+                device_bay = DeviceBay.objects.get(device=parent, name=device_bay_name)
+                if device_bay.installed_device:
+                    self.add_error('device_bay_name',
+                                   "Device bay ({} {}) is already occupied".format(parent, device_bay_name))
+                else:
+                    self.instance.parent_bay = device_bay
+            except DeviceBay.DoesNotExist:
+                self.add_error('device_bay_name', "Parent device/bay ({} {}) not found".format(parent, device_bay_name))
 
 
 class DeviceImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=DeviceFromCSVForm)
 
 
-class DeviceBulkEditForm(forms.Form, BootstrapMixin):
+class ChildDeviceImportForm(BulkImportForm, BootstrapMixin):
+    csv = CSVDataField(csv_form=ChildDeviceFromCSVForm)
+
+
+class DeviceBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Device.objects.all(), widget=forms.MultipleHiddenInput)
     device_type = forms.ModelChoiceField(queryset=DeviceType.objects.all(), required=False, label='Type')
     device_role = forms.ModelChoiceField(queryset=DeviceRole.objects.all(), required=False, label='Role')
-    platform = forms.ModelChoiceField(queryset=Platform.objects.all(), required=False, label='Platform')
-    platform_delete = forms.BooleanField(required=False, label='Set platform to "none"')
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+    platform = forms.ModelChoiceField(queryset=Platform.objects.all(), required=False)
     status = forms.ChoiceField(choices=FORM_STATUS_CHOICES, required=False, initial='', label='Status')
     serial = forms.CharField(max_length=50, required=False, label='Serial Number')
 
+    class Meta:
+        nullable_fields = ['tenant', 'platform']
 
-class DeviceBulkDeleteForm(ConfirmationForm):
+
+class DeviceBulkAddComponentForm(forms.Form, BootstrapMixin):
     pk = forms.ModelMultipleChoiceField(queryset=Device.objects.all(), widget=forms.MultipleHiddenInput)
+    name_pattern = ExpandableNameField(label='Name')
 
 
-def device_site_choices():
-    site_choices = Site.objects.annotate(device_count=Count('racks__devices'))
-    return [(s.slug, '{} ({})'.format(s.name, s.device_count)) for s in site_choices]
+class DeviceBulkAddInterfaceForm(forms.ModelForm, DeviceBulkAddComponentForm):
+
+    class Meta:
+        model = Interface
+        fields = ['name_pattern', 'form_factor', 'mgmt_only', 'description']
 
 
-def device_role_choices():
-    role_choices = DeviceRole.objects.annotate(device_count=Count('devices'))
-    return [(r.slug, '{} ({})'.format(r.name, r.device_count)) for r in role_choices]
-
-
-def device_type_choices():
-    type_choices = DeviceType.objects.select_related('manufacturer').annotate(device_count=Count('instances'))
-    return [(t.pk, '{} ({})'.format(t, t.device_count)) for t in type_choices]
-
-
-def device_platform_choices():
-    platform_choices = Platform.objects.annotate(device_count=Count('devices'))
-    return [(p.slug, '{} ({})'.format(p.name, p.device_count)) for p in platform_choices]
-
-
-class DeviceFilterForm(forms.Form, BootstrapMixin):
-    site = forms.MultipleChoiceField(required=False, choices=device_site_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
-    role = forms.MultipleChoiceField(required=False, choices=device_role_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
-    device_type_id = forms.MultipleChoiceField(required=False, choices=device_type_choices, label='Type',
-                                               widget=forms.SelectMultiple(attrs={'size': 8}))
-    platform = forms.MultipleChoiceField(required=False, choices=device_platform_choices)
+class DeviceFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Device
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('racks__devices')), to_field_name='slug')
+    rack_group_id = FilterChoiceField(queryset=RackGroup.objects.annotate(filter_count=Count('racks__devices')),
+                                      label='Rack Group')
+    role = FilterChoiceField(queryset=DeviceRole.objects.annotate(filter_count=Count('devices')), to_field_name='slug')
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('devices')), to_field_name='slug',
+                               null_option=(0, 'None'))
+    device_type_id = FilterChoiceField(queryset=DeviceType.objects.select_related('manufacturer')
+                                       .annotate(filter_count=Count('instances')), label='Type')
+    platform = FilterChoiceField(queryset=Platform.objects.annotate(filter_count=Count('devices')),
+                                 to_field_name='slug', null_option=(0, 'None'))
     status = forms.NullBooleanField(required=False, widget=forms.Select(choices=FORM_STATUS_CHOICES))
+    mac_address = forms.CharField(label='MAC address')
 
 
 #
@@ -543,7 +641,7 @@ class ConsoleConnectionCSVForm(forms.Form):
     device = FlexibleModelChoiceField(queryset=Device.objects.all(), to_field_name='name',
                                       error_messages={'invalid_choice': 'Device not found'})
     console_port = forms.CharField()
-    status = forms.ChoiceField(choices=[('planned', 'Planned'), ('connected', 'Connected')])
+    status = forms.CharField(validators=[validate_connection_status])
 
     def clean(self):
 
@@ -607,6 +705,7 @@ class ConsolePortConnectionForm(forms.ModelForm, BootstrapMixin):
                                   widget=forms.Select(attrs={'filter-for': 'console_server'}))
     console_server = forms.ModelChoiceField(queryset=Device.objects.all(), label='Console Server', required=False,
                                             widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack}}&is_console_server=True',
+                                                             display_field='display_name',
                                                              attrs={'filter-for': 'cs_port'}))
     livesearch = forms.CharField(required=False, label='Console Server', widget=Livesearch(
         query_key='q', query_url='dcim-api:device_list', field_to_update='console_server')
@@ -674,7 +773,7 @@ class ConsoleServerPortConnectionForm(forms.Form, BootstrapMixin):
                                   widget=forms.Select(attrs={'filter-for': 'device'}))
     device = forms.ModelChoiceField(queryset=Device.objects.all(), label='Device', required=False,
                                     widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack}}',
-                                                     attrs={'filter-for': 'port'}))
+                                                     display_field='display_name', attrs={'filter-for': 'port'}))
     livesearch = forms.CharField(required=False, label='Device', widget=Livesearch(
         query_key='q', query_url='dcim-api:device_list', field_to_update='device')
     )
@@ -738,7 +837,7 @@ class PowerConnectionCSVForm(forms.Form):
     device = FlexibleModelChoiceField(queryset=Device.objects.all(), to_field_name='name',
                                       error_messages={'invalid_choice': 'Device not found'})
     power_port = forms.CharField()
-    status = forms.ChoiceField(choices=[('planned', 'Planned'), ('connected', 'Connected')])
+    status = forms.CharField(validators=[validate_connection_status])
 
     def clean(self):
 
@@ -803,7 +902,7 @@ class PowerPortConnectionForm(forms.ModelForm, BootstrapMixin):
                                   widget=forms.Select(attrs={'filter-for': 'pdu'}))
     pdu = forms.ModelChoiceField(queryset=Device.objects.all(), label='PDU', required=False,
                                  widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack}}&is_pdu=True',
-                                                  attrs={'filter-for': 'power_outlet'}))
+                                                  display_field='display_name', attrs={'filter-for': 'power_outlet'}))
     livesearch = forms.CharField(required=False, label='PDU', widget=Livesearch(
         query_key='q', query_url='dcim-api:device_list', field_to_update='pdu')
     )
@@ -870,7 +969,7 @@ class PowerOutletConnectionForm(forms.Form, BootstrapMixin):
                                   widget=forms.Select(attrs={'filter-for': 'device'}))
     device = forms.ModelChoiceField(queryset=Device.objects.all(), label='Device', required=False,
                                     widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack}}',
-                                                     attrs={'filter-for': 'port'}))
+                                                     display_field='display_name', attrs={'filter-for': 'port'}))
     livesearch = forms.CharField(required=False, label='Device', widget=Livesearch(
         query_key='q', query_url='dcim-api:device_list', field_to_update='device')
     )
@@ -917,7 +1016,7 @@ class InterfaceForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = Interface
-        fields = ['device', 'name', 'form_factor', 'mgmt_only', 'description']
+        fields = ['device', 'name', 'form_factor', 'mac_address', 'mgmt_only', 'description']
         widgets = {
             'device': forms.HiddenInput(),
         }
@@ -928,11 +1027,16 @@ class InterfaceCreateForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = Interface
-        fields = ['name_pattern', 'form_factor', 'mgmt_only', 'description']
+        fields = ['name_pattern', 'form_factor', 'mac_address', 'mgmt_only', 'description']
 
 
-class InterfaceBulkCreateForm(InterfaceCreateForm, BootstrapMixin):
-    pk = forms.ModelMultipleChoiceField(queryset=Device.objects.all(), widget=forms.MultipleHiddenInput)
+class InterfaceBulkEditForm(BootstrapMixin, BulkEditForm):
+    pk = forms.ModelMultipleChoiceField(queryset=Interface.objects.all(), widget=forms.MultipleHiddenInput)
+    form_factor = forms.ChoiceField(choices=add_blank_choice(IFACE_FF_CHOICES), required=False)
+    description = forms.CharField(max_length=100, required=False)
+
+    class Meta:
+        nullable_fields = ['description']
 
 
 #
@@ -945,6 +1049,7 @@ class InterfaceConnectionForm(forms.ModelForm, BootstrapMixin):
                                     widget=forms.Select(attrs={'filter-for': 'device_b'}))
     device_b = forms.ModelChoiceField(queryset=Device.objects.all(), label='Device', required=False,
                                       widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack_b}}',
+                                                       display_field='display_name',
                                                        attrs={'filter-for': 'interface_b'}))
     livesearch = forms.CharField(required=False, label='Device', widget=Livesearch(
         query_key='q', query_url='dcim-api:device_list', field_to_update='device_b')
@@ -999,7 +1104,7 @@ class InterfaceConnectionCSVForm(forms.Form):
     device_b = FlexibleModelChoiceField(queryset=Device.objects.all(), to_field_name='name',
                                         error_messages={'invalid_choice': 'Device B not found.'})
     interface_b = forms.CharField()
-    status = forms.ChoiceField(choices=[('planned', 'Planned'), ('connected', 'Connected')])
+    status = forms.CharField(validators=[validate_connection_status])
 
     def clean(self):
 
@@ -1080,6 +1185,41 @@ class InterfaceConnectionDeletionForm(forms.Form, BootstrapMixin):
     device = forms.ModelChoiceField(queryset=Device.objects.all(), widget=forms.HiddenInput(), required=False)
 
 
+#
+# Device bays
+#
+
+class DeviceBayForm(forms.ModelForm, BootstrapMixin):
+
+    class Meta:
+        model = DeviceBay
+        fields = ['device', 'name']
+        widgets = {
+            'device': forms.HiddenInput(),
+        }
+
+
+class DeviceBayCreateForm(forms.Form, BootstrapMixin):
+    name_pattern = ExpandableNameField(label='Name')
+
+
+class PopulateDeviceBayForm(forms.Form, BootstrapMixin):
+    installed_device = forms.ModelChoiceField(queryset=Device.objects.all(), label='Child Device',
+                                              help_text="Child devices must first be created within the rack occupied "
+                                                        "by the parent device. Then they can be assigned to a bay.")
+
+    def __init__(self, device_bay, *args, **kwargs):
+
+        super(PopulateDeviceBayForm, self).__init__(*args, **kwargs)
+
+        children_queryset = Device.objects.filter(rack=device_bay.device.rack,
+                                                  parent_bay__isnull=True,
+                                                  device_type__u_height=0,
+                                                  device_type__subdevice_role=SUBDEVICE_ROLE_CHILD)\
+            .exclude(pk=device_bay.device.pk)
+        self.fields['installed_device'].queryset = children_queryset
+
+
 #
 # Connections
 #
@@ -1100,15 +1240,12 @@ class InterfaceConnectionFilterForm(forms.Form, BootstrapMixin):
 # IP addresses
 #
 
-class IPAddressForm(forms.ModelForm, BootstrapMixin):
+class IPAddressForm(BootstrapMixin, CustomFieldForm):
     set_as_primary = forms.BooleanField(label='Set as primary IP for device', required=False)
 
     class Meta:
         model = IPAddress
-        fields = ['address', 'vrf', 'interface', 'set_as_primary']
-        help_texts = {
-            'address': 'IPv4 or IPv6 address (with mask)'
-        }
+        fields = ['address', 'vrf', 'tenant', 'status', 'interface', 'description']
 
     def __init__(self, device, *args, **kwargs):
 
@@ -1116,20 +1253,25 @@ class IPAddressForm(forms.ModelForm, BootstrapMixin):
 
         self.fields['vrf'].empty_label = 'Global'
 
-        self.fields['interface'].queryset = device.interfaces.all()
+        interfaces = device.interfaces.all()
+        self.fields['interface'].queryset = interfaces
         self.fields['interface'].required = True
 
-        # If this device does not have any IP addresses assigned, default to setting the first IP as its primary
+        # If this device has only one interface, select it by default.
+        if len(interfaces) == 1:
+            self.fields['interface'].initial = interfaces[0]
+
+        # If this device does not have any IP addresses assigned, default to setting the first IP as its primary.
         if not IPAddress.objects.filter(interface__device=device).count():
             self.fields['set_as_primary'].initial = True
 
 
 #
-# Interfaces
+# Modules
 #
 
 class ModuleForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = Module
-        fields = ['name', 'part_id', 'serial']
+        fields = ['name', 'manufacturer', 'part_id', 'serial']

netbox/dcim/migrations/0004_auto_20160701_2049.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-01 20:49
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0003_auto_20160628_1721'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='DeviceBay',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=50, verbose_name=b'Name')),
+                ('device', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='device_bays', to='dcim.Device')),
+                ('installed_device', models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='parent_bay', to='dcim.Device')),
+            ],
+            options={
+                'ordering': ['device', 'name'],
+            },
+        ),
+        migrations.CreateModel(
+            name='DeviceBayTemplate',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=30)),
+            ],
+            options={
+                'ordering': ['device_type', 'name'],
+            },
+        ),
+        migrations.AddField(
+            model_name='devicetype',
+            name='subdevice_role',
+            field=models.NullBooleanField(choices=[(None, b'N/A'), (True, b'Parent'), (False, b'Child')], default=None, help_text=b'Parent devices house child devices in device bays. Select "None" if this device type is neither a parent nor a child.', verbose_name=b'Parent/child status'),
+        ),
+        migrations.AddField(
+            model_name='devicebaytemplate',
+            name='device_type',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='device_bay_templates', to='dcim.DeviceType'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='devicebaytemplate',
+            unique_together=set([('device_type', 'name')]),
+        ),
+        migrations.AlterUniqueTogether(
+            name='devicebay',
+            unique_together=set([('device', 'name')]),
+        ),
+    ]

netbox/dcim/migrations/0005_auto_20160706_1722.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-06 17:22
+from __future__ import unicode_literals
+
+import dcim.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0004_auto_20160701_2049'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='interface',
+            name='mac_address',
+            field=dcim.fields.MACAddressField(blank=True, null=True, verbose_name=b'MAC Address'),
+        ),
+        migrations.AlterField(
+            model_name='devicetype',
+            name='subdevice_role',
+            field=models.NullBooleanField(choices=[(None, b'None'), (True, b'Parent'), (False, b'Child')], default=None, help_text=b'Parent devices house child devices in device bays. Select "None" if this device type is neither a parent nor a child.', verbose_name=b'Parent/child status'),
+        ),
+    ]

netbox/dcim/migrations/0006_add_device_primary_ip4_ip6.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-11 18:40
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('ipam', '0001_initial'),
+        ('dcim', '0005_auto_20160706_1722'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='device',
+            name='primary_ip4',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='primary_ip4_for', to='ipam.IPAddress', verbose_name=b'Primary IPv4'),
+        ),
+        migrations.AddField(
+            model_name='device',
+            name='primary_ip6',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='primary_ip6_for', to='ipam.IPAddress', verbose_name=b'Primary IPv6'),
+        ),
+    ]

netbox/dcim/migrations/0007_device_copy_primary_ip.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-11 18:40
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+def copy_primary_ip(apps, schema_editor):
+    Device = apps.get_model('dcim', 'Device')
+    for d in Device.objects.select_related('primary_ip'):
+        if not d.primary_ip:
+            continue
+        if d.primary_ip.family == 4:
+            d.primary_ip4 = d.primary_ip
+        elif d.primary_ip.family == 6:
+            d.primary_ip6 = d.primary_ip
+        d.save()
+
+
+def restore_primary_ip(apps, schema_editor):
+    Device = apps.get_model('dcim', 'Device')
+    for d in Device.objects.select_related('primary_ip4', 'primary_ip6'):
+        if d.primary_ip:
+            continue
+        # Prefer IPv6 over IPv4
+        if d.primary_ip6:
+            d.primary_ip = d.primary_ip6
+        elif d.primary_ip4:
+            d.primary_ip = d.primary_ip4
+        d.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0006_add_device_primary_ip4_ip6'),
+    ]
+
+    operations = [
+        migrations.RunPython(copy_primary_ip, restore_primary_ip),
+    ]

netbox/dcim/migrations/0008_device_remove_primary_ip.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-11 19:01
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0007_device_copy_primary_ip'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='device',
+            name='primary_ip',
+        ),
+    ]

netbox/dcim/migrations/0009_site_32bit_asn_support.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-13 19:24
+from __future__ import unicode_literals
+
+import dcim.fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0008_device_remove_primary_ip'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='site',
+            name='asn',
+            field=dcim.fields.ASNField(blank=True, null=True, verbose_name=b'ASN'),
+        ),
+    ]

netbox/dcim/migrations/0010_devicebay_installed_device_set_null.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2016-07-14 21:38
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0009_site_32bit_asn_support'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='devicebay',
+            name='installed_device',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='parent_bay', to='dcim.Device'),
+        ),
+    ]

netbox/dcim/migrations/0011_devicetype_part_number.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-07-26 15:05
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0010_devicebay_installed_device_set_null'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='devicetype',
+            name='part_number',
+            field=models.CharField(blank=True, help_text=b'Discrete part number (optional)', max_length=50),
+        ),
+    ]

netbox/dcim/migrations/0012_site_rack_device_add_tenant.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-07-26 21:59
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('tenancy', '0001_initial'),
+        ('dcim', '0011_devicetype_part_number'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='device',
+            name='tenant',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='devices', to='tenancy.Tenant'),
+        ),
+        migrations.AddField(
+            model_name='rack',
+            name='tenant',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='racks', to='tenancy.Tenant'),
+        ),
+        migrations.AddField(
+            model_name='site',
+            name='tenant',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='sites', to='tenancy.Tenant'),
+        ),
+    ]

netbox/dcim/migrations/0013_add_interface_form_factors.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-08-06 20:24
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0012_site_rack_device_add_tenant'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='interface',
+            name='form_factor',
+            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual']]], [b'Ethernet', [[800, b'100BASE-TX (10/100M)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Modular', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1300, b'XFP (10GE)'], [1200, b'SFP+ (10GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus']]]], default=1200),
+        ),
+        migrations.AlterField(
+            model_name='interfacetemplate',
+            name='form_factor',
+            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual']]], [b'Ethernet', [[800, b'100BASE-TX (10/100M)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Modular', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1300, b'XFP (10GE)'], [1200, b'SFP+ (10GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus']]]], default=1200),
+        ),
+    ]

netbox/dcim/migrations/0014_rack_add_type_width.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-08-08 21:11
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0013_add_interface_form_factors'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='rack',
+            name='type',
+            field=models.PositiveSmallIntegerField(blank=True, choices=[(100, b'2-post frame'), (200, b'4-post frame'), (300, b'4-post cabinet'), (1000, b'Wall-mounted frame'), (1100, b'Wall-mounted cabinet')], null=True, verbose_name=b'Type'),
+        ),
+        migrations.AddField(
+            model_name='rack',
+            name='width',
+            field=models.PositiveSmallIntegerField(choices=[(19, b'19 inches'), (23, b'23 inches')], default=19, help_text=b'Rail-to-rail width', verbose_name=b'Width'),
+        ),
+    ]

netbox/dcim/migrations/0015_rack_add_u_height_validator.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-08-09 21:18
+from __future__ import unicode_literals
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0014_rack_add_type_width'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='rack',
+            name='u_height',
+            field=models.PositiveSmallIntegerField(default=42, validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(100)], verbose_name=b'Height (U)'),
+        ),
+    ]

netbox/dcim/migrations/0016_module_add_manufacturer.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-08-10 13:45
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0015_rack_add_u_height_validator'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='module',
+            name='manufacturer',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='modules', to='dcim.Manufacturer'),
+        ),
+    ]

netbox/dcim/migrations/0017_rack_add_role.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.8 on 2016-08-10 14:58
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0016_module_add_manufacturer'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='RackRole',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=50, unique=True)),
+                ('slug', models.SlugField(unique=True)),
+                ('color', models.CharField(choices=[[b'teal', b'Teal'], [b'green', b'Green'], [b'blue', b'Blue'], [b'purple', b'Purple'], [b'yellow', b'Yellow'], [b'orange', b'Orange'], [b'red', b'Red'], [b'light_gray', b'Light Gray'], [b'medium_gray', b'Medium Gray'], [b'dark_gray', b'Dark Gray']], max_length=30)),
+            ],
+            options={
+                'ordering': ['name'],
+            },
+        ),
+        migrations.AddField(
+            model_name='rack',
+            name='role',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='racks', to='dcim.RackRole'),
+        ),
+    ]

netbox/dcim/migrations/0018_device_add_asset_tag.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-08-11 15:42
+from __future__ import unicode_literals
+
+from django.db import migrations
+import utilities.fields
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0017_rack_add_role'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='device',
+            name='asset_tag',
+            field=utilities.fields.NullableCharField(blank=True, help_text=b'A unique tag used to identify this device', max_length=50, null=True, unique=True, verbose_name=b'Asset tag'),
+        ),
+    ]

netbox/dcim/migrations/0019_new_iface_form_factors.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-09-13 15:20
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0018_device_add_asset_tag'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='interface',
+            name='form_factor',
+            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual']]], [b'Ethernet (fixed)', [[800, b'100BASE-TX (10/100ME)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Ethernet (modular)', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1200, b'SFP+ (10GE)'], [1300, b'XFP (10GE)'], [1310, b'XENPAK (10GE)'], [1320, b'X2 (10GE)'], [1350, b'SFP28 (25GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'FibreChannel', [[3010, b'SFP (1GFC)'], [3020, b'SFP (2GFC)'], [3040, b'SFP (4GFC)'], [3080, b'SFP+ (8GFC)'], [3160, b'SFP+ (16GFC)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus']]], [b'Other', [[32767, b'Other']]]], default=1200),
+        ),
+        migrations.AlterField(
+            model_name='interfacetemplate',
+            name='form_factor',
+            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual']]], [b'Ethernet (fixed)', [[800, b'100BASE-TX (10/100ME)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Ethernet (modular)', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1200, b'SFP+ (10GE)'], [1300, b'XFP (10GE)'], [1310, b'XENPAK (10GE)'], [1320, b'X2 (10GE)'], [1350, b'SFP28 (25GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'FibreChannel', [[3010, b'SFP (1GFC)'], [3020, b'SFP (2GFC)'], [3040, b'SFP (4GFC)'], [3080, b'SFP+ (8GFC)'], [3160, b'SFP+ (16GFC)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus']]], [b'Other', [[32767, b'Other']]]], default=1200),
+        ),
+    ]

netbox/dcim/migrations/0020_rack_desc_units.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-10-28 15:01
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0019_new_iface_form_factors'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='rack',
+            name='desc_units',
+            field=models.BooleanField(default=False, help_text=b'Units are numbered top-to-bottom', verbose_name=b'Descending units'),
+        ),
+    ]

netbox/dcim/migrations/0021_add_ff_flexstack.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-10-31 18:47
+from __future__ import unicode_literals
+
+import django.core.validators
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0020_rack_desc_units'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='device',
+            name='position',
+            field=models.PositiveSmallIntegerField(blank=True, help_text=b'The lowest-numbered unit occupied by the device', null=True, validators=[django.core.validators.MinValueValidator(1)], verbose_name=b'Position (U)'),
+        ),
+        migrations.AlterField(
+            model_name='interface',
+            name='form_factor',
+            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual']]], [b'Ethernet (fixed)', [[800, b'100BASE-TX (10/100ME)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Ethernet (modular)', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1200, b'SFP+ (10GE)'], [1300, b'XFP (10GE)'], [1310, b'XENPAK (10GE)'], [1320, b'X2 (10GE)'], [1350, b'SFP28 (25GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'FibreChannel', [[3010, b'SFP (1GFC)'], [3020, b'SFP (2GFC)'], [3040, b'SFP (4GFC)'], [3080, b'SFP+ (8GFC)'], [3160, b'SFP+ (16GFC)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus'], [5100, b'Cisco FlexStack'], [5150, b'Cisco FlexStack Plus']]], [b'Other', [[32767, b'Other']]]], default=1200),
+        ),
+        migrations.AlterField(
+            model_name='interfacetemplate',
+            name='form_factor',
+            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual']]], [b'Ethernet (fixed)', [[800, b'100BASE-TX (10/100ME)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Ethernet (modular)', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1200, b'SFP+ (10GE)'], [1300, b'XFP (10GE)'], [1310, b'XENPAK (10GE)'], [1320, b'X2 (10GE)'], [1350, b'SFP28 (25GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'FibreChannel', [[3010, b'SFP (1GFC)'], [3020, b'SFP (2GFC)'], [3040, b'SFP (4GFC)'], [3080, b'SFP+ (8GFC)'], [3160, b'SFP+ (16GFC)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus'], [5100, b'Cisco FlexStack'], [5150, b'Cisco FlexStack Plus']]], [b'Other', [[32767, b'Other']]]], default=1200),
+        ),
+    ]

netbox/dcim/migrations/0022_color_names_to_rgb.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-12-06 16:35
+from __future__ import unicode_literals
+
+from django.db import migrations
+import utilities.fields
+
+
+COLOR_CONVERSION = {
+    'teal': '009688',
+    'green': '4caf50',
+    'blue': '2196f3',
+    'purple': '9c27b0',
+    'yellow': 'ffeb3b',
+    'orange': 'ff9800',
+    'red': 'f44336',
+    'light_gray': 'c0c0c0',
+    'medium_gray': '9e9e9e',
+    'dark_gray': '607d8b',
+}
+
+
+def color_names_to_rgb(apps, schema_editor):
+    RackRole = apps.get_model('dcim', 'RackRole')
+    DeviceRole = apps.get_model('dcim', 'DeviceRole')
+    for color_name, color_rgb in COLOR_CONVERSION.items():
+        RackRole.objects.filter(color=color_name).update(color=color_rgb)
+        DeviceRole.objects.filter(color=color_name).update(color=color_rgb)
+
+
+def color_rgb_to_name(apps, schema_editor):
+    RackRole = apps.get_model('dcim', 'RackRole')
+    DeviceRole = apps.get_model('dcim', 'DeviceRole')
+    for color_name, color_rgb in COLOR_CONVERSION.items():
+        RackRole.objects.filter(color=color_rgb).update(color=color_name)
+        DeviceRole.objects.filter(color=color_rgb).update(color=color_name)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0021_add_ff_flexstack'),
+    ]
+
+    operations = [
+        migrations.RunPython(color_names_to_rgb, color_rgb_to_name),
+        migrations.AlterField(
+            model_name='devicerole',
+            name='color',
+            field=utilities.fields.ColorField(max_length=6),
+        ),
+        migrations.AlterField(
+            model_name='rackrole',
+            name='color',
+            field=utilities.fields.ColorField(max_length=6),
+        ),
+    ]

netbox/dcim/models.py

@@ -1,15 +1,43 @@
 from collections import OrderedDict
 
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes.fields import GenericRelation
 from django.core.exceptions import ValidationError
 from django.core.urlresolvers import reverse
-from django.core.validators import MinValueValidator
+from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
-from django.db.models import Q, ObjectDoesNotExist
+from django.db.models import Count, Q, ObjectDoesNotExist
 
+from extras.models import CustomFieldModel, CustomField, CustomFieldValue
 from extras.rpc import RPC_CLIENTS
-from utilities.fields import NullableCharField
+from tenancy.models import Tenant
+from utilities.fields import ColorField, NullableCharField
+from utilities.managers import NaturalOrderByManager
 from utilities.models import CreatedUpdatedModel
 
+from .fields import ASNField, MACAddressField
+
+
+RACK_TYPE_2POST = 100
+RACK_TYPE_4POST = 200
+RACK_TYPE_CABINET = 300
+RACK_TYPE_WALLFRAME = 1000
+RACK_TYPE_WALLCABINET = 1100
+RACK_TYPE_CHOICES = (
+    (RACK_TYPE_2POST, '2-post frame'),
+    (RACK_TYPE_4POST, '4-post frame'),
+    (RACK_TYPE_CABINET, '4-post cabinet'),
+    (RACK_TYPE_WALLFRAME, 'Wall-mounted frame'),
+    (RACK_TYPE_WALLCABINET, 'Wall-mounted cabinet'),
+)
+
+RACK_WIDTH_19IN = 19
+RACK_WIDTH_23IN = 23
+RACK_WIDTH_CHOICES = (
+    (RACK_WIDTH_19IN, '19 inches'),
+    (RACK_WIDTH_23IN, '23 inches'),
+)
 
 RACK_FACE_FRONT = 0
 RACK_FACE_REAR = 1
@@ -18,46 +46,113 @@ RACK_FACE_CHOICES = [
     [RACK_FACE_REAR, 'Rear'],
 ]
 
-COLOR_TEAL = 'teal'
-COLOR_GREEN = 'green'
-COLOR_BLUE = 'blue'
-COLOR_PURPLE = 'purple'
-COLOR_YELLOW = 'yellow'
-COLOR_ORANGE = 'orange'
-COLOR_RED = 'red'
-COLOR_GRAY1 = 'light_gray'
-COLOR_GRAY2 = 'medium_gray'
-COLOR_GRAY3 = 'dark_gray'
-DEVICE_ROLE_COLOR_CHOICES = [
-    [COLOR_TEAL, 'Teal'],
-    [COLOR_GREEN, 'Green'],
-    [COLOR_BLUE, 'Blue'],
-    [COLOR_PURPLE, 'Purple'],
-    [COLOR_YELLOW, 'Yellow'],
-    [COLOR_ORANGE, 'Orange'],
-    [COLOR_RED, 'Red'],
-    [COLOR_GRAY1, 'Light Gray'],
-    [COLOR_GRAY2, 'Medium Gray'],
-    [COLOR_GRAY3, 'Dark Gray'],
-]
+SUBDEVICE_ROLE_PARENT = True
+SUBDEVICE_ROLE_CHILD = False
+SUBDEVICE_ROLE_CHOICES = (
+    (None, 'None'),
+    (SUBDEVICE_ROLE_PARENT, 'Parent'),
+    (SUBDEVICE_ROLE_CHILD, 'Child'),
+)
 
+# Virtual
 IFACE_FF_VIRTUAL = 0
-IFACE_FF_100M_COPPER = 800
-IFACE_FF_1GE_COPPER = 1000
-IFACE_FF_SFP = 1100
-IFACE_FF_10GE_COPPER = 1150
-IFACE_FF_SFP_PLUS = 1200
-IFACE_FF_XFP = 1300
-IFACE_FF_QSFP_PLUS = 1400
+# Ethernet
+IFACE_FF_100ME_FIXED = 800
+IFACE_FF_1GE_FIXED = 1000
+IFACE_FF_1GE_GBIC = 1050
+IFACE_FF_1GE_SFP = 1100
+IFACE_FF_10GE_FIXED = 1150
+IFACE_FF_10GE_SFP_PLUS = 1200
+IFACE_FF_10GE_XFP = 1300
+IFACE_FF_10GE_XENPAK = 1310
+IFACE_FF_10GE_X2 = 1320
+IFACE_FF_25GE_SFP28 = 1350
+IFACE_FF_40GE_QSFP_PLUS = 1400
+IFACE_FF_100GE_CFP = 1500
+IFACE_FF_100GE_QSFP28 = 1600
+# Fibrechannel
+IFACE_FF_1GFC_SFP = 3010
+IFACE_FF_2GFC_SFP = 3020
+IFACE_FF_4GFC_SFP = 3040
+IFACE_FF_8GFC_SFP_PLUS = 3080
+IFACE_FF_16GFC_SFP_PLUS = 3160
+# Serial
+IFACE_FF_T1 = 4000
+IFACE_FF_E1 = 4010
+IFACE_FF_T3 = 4040
+IFACE_FF_E3 = 4050
+# Stacking
+IFACE_FF_STACKWISE = 5000
+IFACE_FF_STACKWISE_PLUS = 5050
+IFACE_FF_FLEXSTACK = 5100
+IFACE_FF_FLEXSTACK_PLUS = 5150
+# Other
+IFACE_FF_OTHER = 32767
+
 IFACE_FF_CHOICES = [
-    [IFACE_FF_VIRTUAL, 'Virtual'],
-    [IFACE_FF_100M_COPPER, '10/100M (100BASE-TX)'],
-    [IFACE_FF_1GE_COPPER, '1GE (1000BASE-T)'],
-    [IFACE_FF_SFP, '1GE (SFP)'],
-    [IFACE_FF_10GE_COPPER, '10GE (10GBASE-T)'],
-    [IFACE_FF_SFP_PLUS, '10GE (SFP+)'],
-    [IFACE_FF_XFP, '10GE (XFP)'],
-    [IFACE_FF_QSFP_PLUS, '40GE (QSFP+)'],
+    [
+        'Virtual interfaces',
+        [
+            [IFACE_FF_VIRTUAL, 'Virtual'],
+        ]
+    ],
+    [
+        'Ethernet (fixed)',
+        [
+            [IFACE_FF_100ME_FIXED, '100BASE-TX (10/100ME)'],
+            [IFACE_FF_1GE_FIXED, '1000BASE-T (1GE)'],
+            [IFACE_FF_10GE_FIXED, '10GBASE-T (10GE)'],
+        ]
+    ],
+    [
+        'Ethernet (modular)',
+        [
+            [IFACE_FF_1GE_GBIC, 'GBIC (1GE)'],
+            [IFACE_FF_1GE_SFP, 'SFP (1GE)'],
+            [IFACE_FF_10GE_SFP_PLUS, 'SFP+ (10GE)'],
+            [IFACE_FF_10GE_XFP, 'XFP (10GE)'],
+            [IFACE_FF_10GE_XENPAK, 'XENPAK (10GE)'],
+            [IFACE_FF_10GE_X2, 'X2 (10GE)'],
+            [IFACE_FF_25GE_SFP28, 'SFP28 (25GE)'],
+            [IFACE_FF_40GE_QSFP_PLUS, 'QSFP+ (40GE)'],
+            [IFACE_FF_100GE_CFP, 'CFP (100GE)'],
+            [IFACE_FF_100GE_QSFP28, 'QSFP28 (100GE)'],
+        ]
+    ],
+    [
+        'FibreChannel',
+        [
+            [IFACE_FF_1GFC_SFP, 'SFP (1GFC)'],
+            [IFACE_FF_2GFC_SFP, 'SFP (2GFC)'],
+            [IFACE_FF_4GFC_SFP, 'SFP (4GFC)'],
+            [IFACE_FF_8GFC_SFP_PLUS, 'SFP+ (8GFC)'],
+            [IFACE_FF_16GFC_SFP_PLUS, 'SFP+ (16GFC)'],
+        ]
+    ],
+    [
+        'Serial',
+        [
+            [IFACE_FF_T1, 'T1 (1.544 Mbps)'],
+            [IFACE_FF_E1, 'E1 (2.048 Mbps)'],
+            [IFACE_FF_T3, 'T3 (45 Mbps)'],
+            [IFACE_FF_E3, 'E3 (34 Mbps)'],
+        ]
+    ],
+    [
+        'Stacking',
+        [
+            [IFACE_FF_STACKWISE, 'Cisco StackWise'],
+            [IFACE_FF_STACKWISE_PLUS, 'Cisco StackWise Plus'],
+            [IFACE_FF_FLEXSTACK, 'Cisco FlexStack'],
+            [IFACE_FF_FLEXSTACK_PLUS, 'Cisco FlexStack Plus'],
+        ]
+    ],
+    [
+        'Other',
+        [
+            [IFACE_FF_OTHER, 'Other'],
+        ]
+    ],
 ]
 
 STATUS_ACTIVE = True
@@ -127,18 +222,32 @@ def order_interfaces(queryset, sql_col, primary_ordering=tuple()):
     }).order_by(*ordering)
 
 
-class Site(CreatedUpdatedModel):
+#
+# Sites
+#
+
+class SiteManager(NaturalOrderByManager):
+
+    def get_queryset(self):
+        return self.natural_order_by('name')
+
+
+class Site(CreatedUpdatedModel, CustomFieldModel):
     """
     A Site represents a geographic location within a network; typically a building or campus. The optional facility
     field can be used to include an external designation, such as a data center name (e.g. Equinix SV6).
     """
     name = models.CharField(max_length=50, unique=True)
     slug = models.SlugField(unique=True)
+    tenant = models.ForeignKey(Tenant, blank=True, null=True, related_name='sites', on_delete=models.PROTECT)
     facility = models.CharField(max_length=50, blank=True)
-    asn = models.PositiveIntegerField(blank=True, null=True, verbose_name='ASN')
+    asn = ASNField(blank=True, null=True, verbose_name='ASN')
     physical_address = models.CharField(max_length=200, blank=True)
     shipping_address = models.CharField(max_length=200, blank=True)
     comments = models.TextField(blank=True)
+    custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
+
+    objects = SiteManager()
 
     class Meta:
         ordering = ['name']
@@ -153,6 +262,7 @@ class Site(CreatedUpdatedModel):
         return ','.join([
             self.name,
             self.slug,
+            self.tenant.name if self.tenant else '',
             self.facility,
             str(self.asn),
         ])
@@ -178,6 +288,10 @@ class Site(CreatedUpdatedModel):
         return self.circuits.count()
 
 
+#
+# Racks
+#
+
 class RackGroup(models.Model):
     """
     Racks can be grouped as subsets within a Site. The scope of a group will depend on how Sites are defined. For
@@ -196,13 +310,37 @@ class RackGroup(models.Model):
         ]
 
     def __unicode__(self):
-        return '{} - {}'.format(self.site.name, self.name)
+        return u'{} - {}'.format(self.site.name, self.name)
 
     def get_absolute_url(self):
         return "{}?group_id={}".format(reverse('dcim:rack_list'), self.pk)
 
 
-class Rack(CreatedUpdatedModel):
+class RackRole(models.Model):
+    """
+    Racks can be organized by functional role, similar to Devices.
+    """
+    name = models.CharField(max_length=50, unique=True)
+    slug = models.SlugField(unique=True)
+    color = ColorField()
+
+    class Meta:
+        ordering = ['name']
+
+    def __unicode__(self):
+        return self.name
+
+    def get_absolute_url(self):
+        return "{}?role={}".format(reverse('dcim:rack_list'), self.slug)
+
+
+class RackManager(NaturalOrderByManager):
+
+    def get_queryset(self):
+        return self.natural_order_by('site__name', 'name')
+
+
+class Rack(CreatedUpdatedModel, CustomFieldModel):
     """
     Devices are housed within Racks. Each rack has a defined height measured in rack units, and a front and rear face.
     Each Rack is assigned to a Site and (optionally) a RackGroup.
@@ -211,8 +349,19 @@ class Rack(CreatedUpdatedModel):
     facility_id = NullableCharField(max_length=30, blank=True, null=True, verbose_name='Facility ID')
     site = models.ForeignKey('Site', related_name='racks', on_delete=models.PROTECT)
     group = models.ForeignKey('RackGroup', related_name='racks', blank=True, null=True, on_delete=models.SET_NULL)
-    u_height = models.PositiveSmallIntegerField(default=42, verbose_name='Height (U)')
+    tenant = models.ForeignKey(Tenant, blank=True, null=True, related_name='racks', on_delete=models.PROTECT)
+    role = models.ForeignKey('RackRole', related_name='racks', blank=True, null=True, on_delete=models.PROTECT)
+    type = models.PositiveSmallIntegerField(choices=RACK_TYPE_CHOICES, blank=True, null=True, verbose_name='Type')
+    width = models.PositiveSmallIntegerField(choices=RACK_WIDTH_CHOICES, default=RACK_WIDTH_19IN, verbose_name='Width',
+                                             help_text='Rail-to-rail width')
+    u_height = models.PositiveSmallIntegerField(default=42, verbose_name='Height (U)',
+                                                validators=[MinValueValidator(1), MaxValueValidator(100)])
+    desc_units = models.BooleanField(default=False, verbose_name='Descending units',
+                                     help_text='Units are numbered top-to-bottom')
     comments = models.TextField(blank=True)
+    custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
+
+    objects = RackManager()
 
     class Meta:
         ordering = ['site', 'name']
@@ -235,8 +384,11 @@ class Rack(CreatedUpdatedModel):
             if top_device:
                 min_height = top_device.position + top_device.device_type.u_height - 1
                 if self.u_height < min_height:
-                    raise ValidationError("Rack must be at least {}U tall with currently installed devices."
-                                          .format(min_height))
+                    raise ValidationError({
+                        'u_height': "Rack must be at least {}U tall to house currently installed devices.".format(
+                            min_height
+                        )
+                    })
 
     def to_csv(self):
         return ','.join([
@@ -244,17 +396,24 @@ class Rack(CreatedUpdatedModel):
             self.group.name if self.group else '',
             self.name,
             self.facility_id or '',
+            self.tenant.name if self.tenant else '',
+            self.role.name if self.role else '',
+            self.get_type_display() if self.type else '',
+            str(self.width),
             str(self.u_height),
         ])
 
     @property
     def units(self):
-        return reversed(range(1, self.u_height + 1))
+        if self.desc_units:
+            return range(1, self.u_height + 1)
+        else:
+            return reversed(range(1, self.u_height + 1))
 
     @property
     def display_name(self):
         if self.facility_id:
-            return "{} ({})".format(self.name, self.facility_id)
+            return u"{} ({})".format(self.name, self.facility_id)
         return self.name
 
     def get_rack_units(self, face=RACK_FACE_FRONT, exclude=None, remove_redundant=False):
@@ -268,12 +427,13 @@ class Rack(CreatedUpdatedModel):
         """
 
         elevation = OrderedDict()
-        for u in reversed(range(1, self.u_height + 1)):
+        for u in self.units:
             elevation[u] = {'id': u, 'name': 'U{}'.format(u), 'face': face, 'device': None}
 
         # Add devices to rack units list
         if self.pk:
             for device in Device.objects.select_related('device_type__manufacturer', 'device_role')\
+                    .annotate(devicebay_count=Count('device_bays'))\
                     .exclude(pk=exclude)\
                     .filter(rack=self, position__gt=0)\
                     .filter(Q(face=face) | Q(device_type__is_full_depth=True)):
@@ -305,7 +465,7 @@ class Rack(CreatedUpdatedModel):
         """
 
         # Gather all devices which consume U space within the rack
-        devices = self.devices.select_related().filter(position__gte=1).exclude(pk__in=exclude)
+        devices = self.devices.select_related('device_type').filter(position__gte=1).exclude(pk__in=exclude)
 
         # Initialize the rack unit skeleton
         units = range(1, self.u_height + 1)
@@ -331,6 +491,13 @@ class Rack(CreatedUpdatedModel):
     def get_0u_devices(self):
         return self.devices.filter(position=0)
 
+    def get_utilization(self):
+        """
+        Determine the utilization rate of the rack and return it as a percentage.
+        """
+        u_available = len(self.get_available_units())
+        return int(float(self.u_height - u_available) / self.u_height * 100)
+
 
 #
 # Device Types
@@ -371,6 +538,7 @@ class DeviceType(models.Model):
     manufacturer = models.ForeignKey('Manufacturer', related_name='device_types', on_delete=models.PROTECT)
     model = models.CharField(max_length=50)
     slug = models.SlugField()
+    part_number = models.CharField(max_length=50, blank=True, help_text="Discrete part number (optional)")
     u_height = models.PositiveSmallIntegerField(verbose_name='Height (U)', default=1)
     is_full_depth = models.BooleanField(default=True, verbose_name="Is full depth",
                                         help_text="Device consumes both front and rear rack faces")
@@ -380,6 +548,10 @@ class DeviceType(models.Model):
                                  help_text="This type of device has power outlets")
     is_network_device = models.BooleanField(default=True, verbose_name='Is a network device',
                                             help_text="This type of device has network interfaces")
+    subdevice_role = models.NullBooleanField(default=None, verbose_name='Parent/child status',
+                                             choices=SUBDEVICE_ROLE_CHOICES,
+                                             help_text="Parent devices house child devices in device bays. Select "
+                                                       "\"None\" if this device type is neither a parent nor a child.")
 
     class Meta:
         ordering = ['manufacturer', 'model']
@@ -389,11 +561,70 @@ class DeviceType(models.Model):
         ]
 
     def __unicode__(self):
-        return "{0} {1}".format(self.manufacturer, self.model)
+        return u'{} {}'.format(self.manufacturer, self.model)
+
+    def __init__(self, *args, **kwargs):
+        super(DeviceType, self).__init__(*args, **kwargs)
+
+        # Save a copy of u_height for validation in clean()
+        self._original_u_height = self.u_height
 
     def get_absolute_url(self):
         return reverse('dcim:devicetype', args=[self.pk])
 
+    def clean(self):
+
+        # If editing an existing DeviceType to have a larger u_height, first validate that *all* instances of it have
+        # room to expand within their racks. This validation will impose a very high performance penalty when there are
+        # many instances to check, but increasing the u_height of a DeviceType should be a very rare occurrence.
+        if self.pk is not None and self.u_height > self._original_u_height:
+            for d in Device.objects.filter(device_type=self, position__isnull=False):
+                face_required = None if self.is_full_depth else d.face
+                u_available = d.rack.get_available_units(u_height=self.u_height, rack_face=face_required,
+                                                         exclude=[d.pk])
+                if d.position not in u_available:
+                    raise ValidationError({
+                        'u_height': "Device {} in rack {} does not have sufficient space to accommodate a height of "
+                                    "{}U".format(d, d.rack, self.u_height)
+                    })
+
+        if not self.is_console_server and self.cs_port_templates.count():
+            raise ValidationError({
+                'is_console_server': "Must delete all console server port templates associated with this device before "
+                                     "declassifying it as a console server."
+            })
+
+        if not self.is_pdu and self.power_outlet_templates.count():
+            raise ValidationError({
+                'is_pdu': "Must delete all power outlet templates associated with this device before declassifying it "
+                          "as a PDU."
+            })
+
+        if not self.is_network_device and self.interface_templates.filter(mgmt_only=False).count():
+            raise ValidationError({
+                'is_network_device': "Must delete all non-management-only interface templates associated with this "
+                                     "device before declassifying it as a network device."
+            })
+
+        if self.subdevice_role != SUBDEVICE_ROLE_PARENT and self.device_bay_templates.count():
+            raise ValidationError({
+                'subdevice_role': "Must delete all device bay templates associated with this device before "
+                                  "declassifying it as a parent device."
+            })
+
+        if self.u_height and self.subdevice_role == SUBDEVICE_ROLE_CHILD:
+            raise ValidationError({
+                'u_height': "Child device types must be 0U."
+            })
+
+    @property
+    def is_parent_device(self):
+        return bool(self.subdevice_role)
+
+    @property
+    def is_child_device(self):
+        return bool(self.subdevice_role is False)
+
 
 class ConsolePortTemplate(models.Model):
     """
@@ -468,7 +699,7 @@ class InterfaceTemplate(models.Model):
     """
     device_type = models.ForeignKey('DeviceType', related_name='interface_templates', on_delete=models.CASCADE)
     name = models.CharField(max_length=30)
-    form_factor = models.PositiveSmallIntegerField(choices=IFACE_FF_CHOICES, default=IFACE_FF_SFP_PLUS)
+    form_factor = models.PositiveSmallIntegerField(choices=IFACE_FF_CHOICES, default=IFACE_FF_10GE_SFP_PLUS)
     mgmt_only = models.BooleanField(default=False, verbose_name='Management only')
 
     objects = InterfaceTemplateManager()
@@ -481,6 +712,21 @@ class InterfaceTemplate(models.Model):
         return self.name
 
 
+class DeviceBayTemplate(models.Model):
+    """
+    A template for a DeviceBay to be created for a new parent Device.
+    """
+    device_type = models.ForeignKey('DeviceType', related_name='device_bay_templates', on_delete=models.CASCADE)
+    name = models.CharField(max_length=30)
+
+    class Meta:
+        ordering = ['device_type', 'name']
+        unique_together = ['device_type', 'name']
+
+    def __unicode__(self):
+        return self.name
+
+
 #
 # Devices
 #
@@ -492,7 +738,7 @@ class DeviceRole(models.Model):
     """
     name = models.CharField(max_length=50, unique=True)
     slug = models.SlugField(unique=True)
-    color = models.CharField(max_length=30, choices=DEVICE_ROLE_COLOR_CHOICES)
+    color = ColorField()
 
     class Meta:
         ordering = ['name']
@@ -524,7 +770,13 @@ class Platform(models.Model):
         return "{}?platform={}".format(reverse('dcim:device_list'), self.slug)
 
 
-class Device(CreatedUpdatedModel):
+class DeviceManager(NaturalOrderByManager):
+
+    def get_queryset(self):
+        return self.natural_order_by('name')
+
+
+class Device(CreatedUpdatedModel, CustomFieldModel):
     """
     A Device represents a piece of physical hardware mounted within a Rack. Each Device is assigned a DeviceType,
     DeviceRole, and (optionally) a Platform. Device names are not required, however if one is set it must be unique.
@@ -538,18 +790,26 @@ class Device(CreatedUpdatedModel):
     """
     device_type = models.ForeignKey('DeviceType', related_name='instances', on_delete=models.PROTECT)
     device_role = models.ForeignKey('DeviceRole', related_name='devices', on_delete=models.PROTECT)
+    tenant = models.ForeignKey(Tenant, blank=True, null=True, related_name='devices', on_delete=models.PROTECT)
     platform = models.ForeignKey('Platform', related_name='devices', blank=True, null=True, on_delete=models.SET_NULL)
     name = NullableCharField(max_length=50, blank=True, null=True, unique=True)
     serial = models.CharField(max_length=50, blank=True, verbose_name='Serial number')
+    asset_tag = NullableCharField(max_length=50, blank=True, null=True, unique=True, verbose_name='Asset tag',
+                                  help_text='A unique tag used to identify this device')
     rack = models.ForeignKey('Rack', related_name='devices', on_delete=models.PROTECT)
     position = models.PositiveSmallIntegerField(blank=True, null=True, validators=[MinValueValidator(1)],
                                                 verbose_name='Position (U)',
-                                                help_text='Number of the lowest U position occupied by the device')
+                                                help_text='The lowest-numbered unit occupied by the device')
     face = models.PositiveSmallIntegerField(blank=True, null=True, choices=RACK_FACE_CHOICES, verbose_name='Rack face')
     status = models.BooleanField(choices=STATUS_CHOICES, default=STATUS_ACTIVE, verbose_name='Status')
-    primary_ip = models.OneToOneField('ipam.IPAddress', related_name='primary_for', on_delete=models.SET_NULL,
-                                      blank=True, null=True, verbose_name='Primary IP')
+    primary_ip4 = models.OneToOneField('ipam.IPAddress', related_name='primary_ip4_for', on_delete=models.SET_NULL,
+                                       blank=True, null=True, verbose_name='Primary IPv4')
+    primary_ip6 = models.OneToOneField('ipam.IPAddress', related_name='primary_ip6_for', on_delete=models.SET_NULL,
+                                       blank=True, null=True, verbose_name='Primary IPv6')
     comments = models.TextField(blank=True)
+    custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
+
+    objects = DeviceManager()
 
     class Meta:
         ordering = ['name']
@@ -565,21 +825,38 @@ class Device(CreatedUpdatedModel):
 
         # Validate position/face combination
         if self.position and self.face is None:
-            raise ValidationError("Must specify rack face with rack position.")
+            raise ValidationError({
+                'face': "Must specify rack face when defining rack position."
+            })
 
-        # Validate rack space
         try:
+            # Child devices cannot be assigned to a rack face/unit
+            if self.device_type.is_child_device and self.face is not None:
+                raise ValidationError({
+                    'face': "Child device types cannot be assigned to a rack face. This is an attribute of the parent "
+                            "device."
+                })
+            if self.device_type.is_child_device and self.position:
+                raise ValidationError({
+                    'position': "Child device types cannot be assigned to a rack position. This is an attribute of the "
+                                "parent device."
+                })
+
+            # Validate rack space
             rack_face = self.face if not self.device_type.is_full_depth else None
+            exclude_list = [self.pk] if self.pk else []
+            try:
+                available_units = self.rack.get_available_units(u_height=self.device_type.u_height, rack_face=rack_face,
+                                                                exclude=exclude_list)
+                if self.position and self.position not in available_units:
+                    raise ValidationError({
+                        'position': "U{} is already occupied or does not have sufficient space to accommodate a(n) {} "
+                                    "({}U).".format(self.position, self.device_type, self.device_type.u_height)
+                    })
+            except Rack.DoesNotExist:
+                pass
+
         except DeviceType.DoesNotExist:
-            raise ValidationError("Must specify device type.")
-        exclude_list = [self.pk] if self.pk else []
-        try:
-            available_units = self.rack.get_available_units(u_height=self.device_type.u_height, rack_face=rack_face,
-                                                            exclude=exclude_list)
-            if self.position and self.position not in available_units:
-                raise ValidationError("U{} is already occupied or does not have sufficient space to accommodate a(n) "
-                                      "{} ({}U).".format(self.position, self.device_type, self.device_type.u_height))
-        except Rack.DoesNotExist:
             pass
 
     def save(self, *args, **kwargs):
@@ -610,15 +887,24 @@ class Device(CreatedUpdatedModel):
                 [Interface(device=self, name=template.name, form_factor=template.form_factor,
                            mgmt_only=template.mgmt_only) for template in self.device_type.interface_templates.all()]
             )
+            DeviceBay.objects.bulk_create(
+                [DeviceBay(device=self, name=template.name) for template in
+                 self.device_type.device_bay_templates.all()]
+            )
+
+        # Update Rack assignment for any child Devices
+        Device.objects.filter(parent_bay__device=self).update(rack=self.rack)
 
     def to_csv(self):
         return ','.join([
             self.name or '',
             self.device_role.name,
+            self.tenant.name if self.tenant else '',
             self.device_type.manufacturer.name,
             self.device_type.model,
             self.platform.name if self.platform else '',
             self.serial,
+            self.asset_tag if self.asset_tag else '',
             self.rack.site.name,
             self.rack.name,
             str(self.position) if self.position else '',
@@ -630,9 +916,9 @@ class Device(CreatedUpdatedModel):
         if self.name:
             return self.name
         elif self.position:
-            return "{} ({} U{})".format(self.device_type, self.rack.name, self.position)
+            return u"{} ({} U{})".format(self.device_type, self.rack.name, self.position)
         else:
-            return "{} ({})".format(self.device_type, self.rack.name)
+            return u"{} ({})".format(self.device_type, self.rack.name)
 
     @property
     def identifier(self):
@@ -643,6 +929,23 @@ class Device(CreatedUpdatedModel):
             return self.name
         return '{{{}}}'.format(self.pk)
 
+    @property
+    def primary_ip(self):
+        if settings.PREFER_IPV4 and self.primary_ip4:
+            return self.primary_ip4
+        elif self.primary_ip6:
+            return self.primary_ip6
+        elif self.primary_ip4:
+            return self.primary_ip4
+        else:
+            return None
+
+    def get_children(self):
+        """
+        Return the set of child Devices installed in DeviceBays within this Device.
+        """
+        return Device.objects.filter(parent_bay__device=self.pk)
+
     def get_rpc_client(self):
         """
         Return the appropriate RPC (e.g. NETCONF, ssh, etc.) client for this device's platform, if one is defined.
@@ -669,6 +972,9 @@ class ConsolePort(models.Model):
     def __unicode__(self):
         return self.name
 
+    def get_parent_url(self):
+        return self.device.get_absolute_url()
+
     # Used for connections export
     def to_csv(self):
         return ','.join([
@@ -710,6 +1016,9 @@ class ConsoleServerPort(models.Model):
     def __unicode__(self):
         return self.name
 
+    def get_parent_url(self):
+        return self.device.get_absolute_url()
+
 
 class PowerPort(models.Model):
     """
@@ -728,6 +1037,9 @@ class PowerPort(models.Model):
     def __unicode__(self):
         return self.name
 
+    def get_parent_url(self):
+        return self.device.get_absolute_url()
+
     # Used for connections export
     def to_csv(self):
         return ','.join([
@@ -763,6 +1075,9 @@ class PowerOutlet(models.Model):
     def __unicode__(self):
         return self.name
 
+    def get_parent_url(self):
+        return self.device.get_absolute_url()
+
 
 class InterfaceManager(models.Manager):
 
@@ -784,7 +1099,8 @@ class Interface(models.Model):
     """
     device = models.ForeignKey('Device', related_name='interfaces', on_delete=models.CASCADE)
     name = models.CharField(max_length=30)
-    form_factor = models.PositiveSmallIntegerField(choices=IFACE_FF_CHOICES, default=IFACE_FF_SFP_PLUS)
+    form_factor = models.PositiveSmallIntegerField(choices=IFACE_FF_CHOICES, default=IFACE_FF_10GE_SFP_PLUS)
+    mac_address = MACAddressField(null=True, blank=True, verbose_name='MAC Address')
     mgmt_only = models.BooleanField(default=False, verbose_name='OOB Management',
                                     help_text="This interface is used only for out-of-band management")
     description = models.CharField(max_length=100, blank=True)
@@ -798,6 +1114,17 @@ class Interface(models.Model):
     def __unicode__(self):
         return self.name
 
+    def get_parent_url(self):
+        return self.device.get_absolute_url()
+
+    def clean(self):
+
+        if self.form_factor == IFACE_FF_VIRTUAL and self.is_connected:
+            raise ValidationError({
+                'form_factor': "Virtual interfaces cannot be connected to another interface or circuit. Disconnect the "
+                               "interface or choose a physical form factor."
+            })
+
     @property
     def is_physical(self):
         return self.form_factor != IFACE_FF_VIRTUAL
@@ -823,16 +1150,13 @@ class Interface(models.Model):
         return None
 
     def get_connected_interface(self):
-        try:
-            connection = InterfaceConnection.objects.select_related().get(Q(interface_a=self) | Q(interface_b=self))
-            if connection.interface_a == self:
-                return connection.interface_b
-            else:
-                return connection.interface_a
-        except InterfaceConnection.DoesNotExist:
-            return None
-        except InterfaceConnection.MultipleObjectsReturned as e:
-            raise e("Multiple connections found for {0} interface {1}!".format(self.device, self))
+        connection = InterfaceConnection.objects.select_related().filter(Q(interface_a=self) | Q(interface_b=self))\
+            .first()
+        if connection and connection.interface_a == self:
+            return connection.interface_b
+        elif connection:
+            return connection.interface_a
+        return None
 
 
 class InterfaceConnection(models.Model):
@@ -847,7 +1171,9 @@ class InterfaceConnection(models.Model):
 
     def clean(self):
         if self.interface_a == self.interface_b:
-            raise ValidationError("Cannot connect an interface to itself")
+            raise ValidationError({
+                'interface_b': "Cannot connect an interface to itself."
+            })
 
     # Used for connections export
     def to_csv(self):
@@ -860,6 +1186,38 @@ class InterfaceConnection(models.Model):
         ])
 
 
+class DeviceBay(models.Model):
+    """
+    An empty space within a Device which can house a child device
+    """
+    device = models.ForeignKey('Device', related_name='device_bays', on_delete=models.CASCADE)
+    name = models.CharField(max_length=50, verbose_name='Name')
+    installed_device = models.OneToOneField('Device', related_name='parent_bay', on_delete=models.SET_NULL, blank=True,
+                                            null=True)
+
+    class Meta:
+        ordering = ['device', 'name']
+        unique_together = ['device', 'name']
+
+    def __unicode__(self):
+        return u'{} - {}'.format(self.device.name, self.name)
+
+    def get_parent_url(self):
+        return self.device.get_absolute_url()
+
+    def clean(self):
+
+        # Validate that the parent Device can have DeviceBays
+        if not self.device.device_type.is_parent_device:
+            raise ValidationError("This type of device ({}) does not support device bays.".format(
+                self.device.device_type
+            ))
+
+        # Cannot install a device into itself, obviously
+        if self.device == self.installed_device:
+            raise ValidationError("Cannot install a device into itself.")
+
+
 class Module(models.Model):
     """
     A Module represents a piece of hardware within a Device, such as a line card or power supply. Modules are used only
@@ -868,6 +1226,8 @@ class Module(models.Model):
     device = models.ForeignKey('Device', related_name='modules', on_delete=models.CASCADE)
     parent = models.ForeignKey('self', related_name='submodules', blank=True, null=True, on_delete=models.CASCADE)
     name = models.CharField(max_length=50, verbose_name='Name')
+    manufacturer = models.ForeignKey('Manufacturer', related_name='modules', blank=True, null=True,
+                                     on_delete=models.PROTECT)
     part_id = models.CharField(max_length=50, verbose_name='Part ID', blank=True)
     serial = models.CharField(max_length=50, verbose_name='Serial number', blank=True)
     discovered = models.BooleanField(default=False, verbose_name='Discovered')
@@ -878,3 +1238,6 @@ class Module(models.Model):
 
     def __unicode__(self):
         return self.name
+
+    def get_parent_url(self):
+        return reverse('dcim:device_inventory', args=[self.device.pk])

netbox/dcim/tables.py

@@ -4,41 +4,64 @@ from django_tables2.utils import Accessor
 from utilities.tables import BaseTable, ToggleColumn
 
 from .models import (
-    ConsolePort, ConsolePortTemplate, ConsoleServerPortTemplate, Device, DeviceRole, DeviceType, InterfaceTemplate,
-    Manufacturer, Platform, PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup, Site,
+    ConsolePort, ConsolePortTemplate, ConsoleServerPortTemplate, Device, DeviceBayTemplate, DeviceRole, DeviceType,
+    Interface, InterfaceTemplate, Manufacturer, Platform, PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack,
+    RackGroup, Site,
 )
 
 
+COLOR_LABEL = """
+<label class="label" style="background-color: #{{ record.color }}">{{ record }}</label>
+"""
+
 DEVICE_LINK = """
 <a href="{% url 'dcim:device' pk=record.pk %}">
     {{ record.name|default:'<span class="label label-info">Unnamed device</span>' }}
 </a>
 """
 
-RACKGROUP_EDIT_LINK = """
+RACKGROUP_ACTIONS = """
 {% if perms.dcim.change_rackgroup %}
-    <a href="{% url 'dcim:rackgroup_edit' pk=record.pk %}">Edit</a>
+    <a href="{% url 'dcim:rackgroup_edit' pk=record.pk %}" class="btn btn-xs btn-warning"><i class="glyphicon glyphicon-pencil" aria-hidden="true"></i></a>
 {% endif %}
 """
 
-DEVICEROLE_EDIT_LINK = """
+RACKROLE_ACTIONS = """
+{% if perms.dcim.change_rackrole %}
+    <a href="{% url 'dcim:rackrole_edit' pk=record.pk %}" class="btn btn-xs btn-warning"><i class="glyphicon glyphicon-pencil" aria-hidden="true"></i></a>
+{% endif %}
+"""
+
+RACK_ROLE = """
+{% if record.role %}
+    <label class="label" style="background-color: #{{ record.role.color }}">{{ value }}</label>
+{% else %}
+    &mdash;
+{% endif %}
+"""
+
+DEVICEROLE_ACTIONS = """
 {% if perms.dcim.change_devicerole %}
-    <a href="{% url 'dcim:devicerole_edit' slug=record.slug %}">Edit</a>
+    <a href="{% url 'dcim:devicerole_edit' slug=record.slug %}" class="btn btn-xs btn-warning"><i class="glyphicon glyphicon-pencil" aria-hidden="true"></i></a>
 {% endif %}
 """
 
-MANUFACTURER_EDIT_LINK = """
+MANUFACTURER_ACTIONS = """
 {% if perms.dcim.change_manufacturer %}
-    <a href="{% url 'dcim:manufacturer_edit' slug=record.slug %}">Edit</a>
+    <a href="{% url 'dcim:manufacturer_edit' slug=record.slug %}" class="btn btn-xs btn-warning"><i class="glyphicon glyphicon-pencil" aria-hidden="true"></i></a>
 {% endif %}
 """
 
-PLATFORM_EDIT_LINK = """
+PLATFORM_ACTIONS = """
 {% if perms.dcim.change_platform %}
-    <a href="{% url 'dcim:platform_edit' slug=record.slug %}">Edit</a>
+    <a href="{% url 'dcim:platform_edit' slug=record.slug %}" class="btn btn-xs btn-warning"><i class="glyphicon glyphicon-pencil" aria-hidden="true"></i></a>
 {% endif %}
 """
 
+DEVICE_ROLE = """
+<label class="label" style="background-color: #{{ record.device_role.color }}">{{ value }}</label>
+"""
+
 STATUS_ICON = """
 {% if record.status %}
     <span class="glyphicon glyphicon-ok-sign text-success" title="Active" aria-hidden="true"></span>
@@ -47,14 +70,21 @@ STATUS_ICON = """
 {% endif %}
 """
 
+UTILIZATION_GRAPH = """
+{% load helpers %}
+{% utilization_graph value %}
+"""
+
 
 #
 # Sites
 #
 
 class SiteTable(BaseTable):
+    pk = ToggleColumn()
     name = tables.LinkColumn('dcim:site', args=[Accessor('slug')], verbose_name='Name')
     facility = tables.Column(verbose_name='Facility')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
     asn = tables.Column(verbose_name='ASN')
     rack_count = tables.Column(accessor=Accessor('count_racks'), orderable=False, verbose_name='Racks')
     device_count = tables.Column(accessor=Accessor('count_devices'), orderable=False, verbose_name='Devices')
@@ -64,8 +94,8 @@ class SiteTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = Site
-        fields = ('name', 'facility', 'asn', 'rack_count', 'device_count', 'prefix_count', 'vlan_count',
-                  'circuit_count')
+        fields = ('pk', 'name', 'facility', 'tenant', 'asn', 'rack_count', 'device_count', 'prefix_count',
+                  'vlan_count', 'circuit_count')
 
 
 #
@@ -78,11 +108,30 @@ class RackGroupTable(BaseTable):
     site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
     rack_count = tables.Column(verbose_name='Racks')
     slug = tables.Column(verbose_name='Slug')
-    edit = tables.TemplateColumn(template_code=RACKGROUP_EDIT_LINK, verbose_name='')
+    actions = tables.TemplateColumn(template_code=RACKGROUP_ACTIONS, attrs={'td': {'class': 'text-right'}},
+                                    verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = RackGroup
-        fields = ('pk', 'name', 'site', 'rack_count', 'slug', 'edit')
+        fields = ('pk', 'name', 'site', 'rack_count', 'slug', 'actions')
+
+
+#
+# Rack roles
+#
+
+class RackRoleTable(BaseTable):
+    pk = ToggleColumn()
+    name = tables.LinkColumn(verbose_name='Name')
+    rack_count = tables.Column(verbose_name='Racks')
+    color = tables.TemplateColumn(COLOR_LABEL, verbose_name='Color')
+    slug = tables.Column(verbose_name='Slug')
+    actions = tables.TemplateColumn(template_code=RACKROLE_ACTIONS, attrs={'td': {'class': 'text-right'}},
+                                    verbose_name='')
+
+    class Meta(BaseTable.Meta):
+        model = RackGroup
+        fields = ('pk', 'name', 'rack_count', 'color', 'slug', 'actions')
 
 
 #
@@ -95,12 +144,29 @@ class RackTable(BaseTable):
     site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
     group = tables.Column(accessor=Accessor('group.name'), verbose_name='Group')
     facility_id = tables.Column(verbose_name='Facility ID')
-    u_height = tables.Column(verbose_name='Height (U)')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
+    role = tables.TemplateColumn(RACK_ROLE, verbose_name='Role')
+    u_height = tables.TemplateColumn("{{ record.u_height }}U", verbose_name='Height')
     devices = tables.Column(accessor=Accessor('device_count'), verbose_name='Devices')
+    get_utilization = tables.TemplateColumn(UTILIZATION_GRAPH, orderable=False, verbose_name='Utilization')
 
     class Meta(BaseTable.Meta):
         model = Rack
-        fields = ('pk', 'name', 'site', 'group', 'facility_id', 'u_height', 'devices')
+        fields = ('pk', 'name', 'site', 'group', 'facility_id', 'tenant', 'role', 'u_height', 'devices',
+                  'get_utilization')
+
+
+class RackImportTable(BaseTable):
+    name = tables.LinkColumn('dcim:rack', args=[Accessor('pk')], verbose_name='Name')
+    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
+    group = tables.Column(accessor=Accessor('group.name'), verbose_name='Group')
+    facility_id = tables.Column(verbose_name='Facility ID')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
+    u_height = tables.Column(verbose_name='Height (U)')
+
+    class Meta(BaseTable.Meta):
+        model = Rack
+        fields = ('site', 'group', 'name', 'facility_id', 'tenant', 'u_height')
 
 
 #
@@ -112,11 +178,12 @@ class ManufacturerTable(BaseTable):
     name = tables.LinkColumn(verbose_name='Name')
     devicetype_count = tables.Column(verbose_name='Device Types')
     slug = tables.Column(verbose_name='Slug')
-    edit = tables.TemplateColumn(template_code=MANUFACTURER_EDIT_LINK, verbose_name='')
+    actions = tables.TemplateColumn(template_code=MANUFACTURER_ACTIONS, attrs={'td': {'class': 'text-right'}},
+                                    verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = Manufacturer
-        fields = ('pk', 'name', 'devicetype_count', 'slug', 'edit')
+        fields = ('pk', 'name', 'devicetype_count', 'slug', 'actions')
 
 
 #
@@ -125,80 +192,79 @@ class ManufacturerTable(BaseTable):
 
 class DeviceTypeTable(BaseTable):
     pk = ToggleColumn()
+    manufacturer = tables.Column(verbose_name='Manufacturer')
     model = tables.LinkColumn('dcim:devicetype', args=[Accessor('pk')], verbose_name='Device Type')
+    part_number = tables.Column(verbose_name='Part Number')
+    is_full_depth = tables.BooleanColumn(verbose_name='Full Depth')
+    instance_count = tables.Column(verbose_name='Instances')
 
     class Meta(BaseTable.Meta):
         model = DeviceType
-        fields = ('pk', 'model', 'manufacturer', 'u_height')
+        fields = ('pk', 'model', 'manufacturer', 'part_number', 'u_height', 'is_full_depth', 'instance_count')
 
 
 #
 # Device type components
 #
 
-class ConsolePortTemplateTable(tables.Table):
+class ConsolePortTemplateTable(BaseTable):
     pk = ToggleColumn()
 
-    class Meta:
+    class Meta(BaseTable.Meta):
         model = ConsolePortTemplate
         fields = ('pk', 'name')
         empty_text = "None"
         show_header = False
-        attrs = {
-            'class': 'table table-hover',
-        }
 
 
-class ConsoleServerPortTemplateTable(tables.Table):
+class ConsoleServerPortTemplateTable(BaseTable):
     pk = ToggleColumn()
 
-    class Meta:
+    class Meta(BaseTable.Meta):
         model = ConsoleServerPortTemplate
         fields = ('pk', 'name')
         empty_text = "None"
         show_header = False
-        attrs = {
-            'class': 'table table-hover',
-        }
 
 
-class PowerPortTemplateTable(tables.Table):
+class PowerPortTemplateTable(BaseTable):
     pk = ToggleColumn()
 
-    class Meta:
+    class Meta(BaseTable.Meta):
         model = PowerPortTemplate
         fields = ('pk', 'name')
         empty_text = "None"
         show_header = False
-        attrs = {
-            'class': 'table table-hover',
-        }
 
 
-class PowerOutletTemplateTable(tables.Table):
+class PowerOutletTemplateTable(BaseTable):
     pk = ToggleColumn()
 
-    class Meta:
+    class Meta(BaseTable.Meta):
         model = PowerOutletTemplate
         fields = ('pk', 'name')
         empty_text = "None"
         show_header = False
-        attrs = {
-            'class': 'table table-hover',
-        }
 
 
-class InterfaceTemplateTable(tables.Table):
+class InterfaceTemplateTable(BaseTable):
     pk = ToggleColumn()
 
-    class Meta:
+    class Meta(BaseTable.Meta):
         model = InterfaceTemplate
+        fields = ('pk', 'name', 'form_factor')
+        empty_text = "None"
+        show_header = False
+
+
+class DeviceBayTemplateTable(BaseTable):
+    pk = ToggleColumn()
+
+    class Meta(BaseTable.Meta):
+        model = DeviceBayTemplate
         fields = ('pk', 'name')
         empty_text = "None"
         show_header = False
-        attrs = {
-            'class': 'table table-hover panel-body',
-        }
 
 
 #
@@ -209,13 +275,14 @@ class DeviceRoleTable(BaseTable):
     pk = ToggleColumn()
     name = tables.LinkColumn(verbose_name='Name')
     device_count = tables.Column(verbose_name='Devices')
+    color = tables.TemplateColumn(COLOR_LABEL, verbose_name='Color')
     slug = tables.Column(verbose_name='Slug')
-    color = tables.Column(verbose_name='Color')
-    edit = tables.TemplateColumn(template_code=DEVICEROLE_EDIT_LINK, verbose_name='')
+    actions = tables.TemplateColumn(template_code=DEVICEROLE_ACTIONS, attrs={'td': {'class': 'text-right'}},
+                                    verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = DeviceRole
-        fields = ('pk', 'name', 'device_count', 'slug', 'color')
+        fields = ('pk', 'name', 'device_count', 'color', 'slug', 'actions')
 
 
 #
@@ -227,11 +294,11 @@ class PlatformTable(BaseTable):
     name = tables.LinkColumn(verbose_name='Name')
     device_count = tables.Column(verbose_name='Devices')
     slug = tables.Column(verbose_name='Slug')
-    edit = tables.TemplateColumn(template_code=PLATFORM_EDIT_LINK, verbose_name='')
+    actions = tables.TemplateColumn(template_code=PLATFORM_ACTIONS, attrs={'td': {'class': 'text-right'}}, verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = Platform
-        fields = ('pk', 'name', 'device_count', 'slug', 'edit')
+        fields = ('pk', 'name', 'device_count', 'slug', 'actions')
 
 
 #
@@ -242,20 +309,22 @@ class DeviceTable(BaseTable):
     pk = ToggleColumn()
     status = tables.TemplateColumn(template_code=STATUS_ICON, verbose_name='')
     name = tables.TemplateColumn(template_code=DEVICE_LINK, verbose_name='Name')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
     site = tables.Column(accessor=Accessor('rack.site'), verbose_name='Site')
     rack = tables.LinkColumn('dcim:rack', args=[Accessor('rack.pk')], verbose_name='Rack')
-    device_role = tables.Column(verbose_name='Role')
+    device_role = tables.TemplateColumn(DEVICE_ROLE, verbose_name='Role')
     device_type = tables.Column(verbose_name='Type')
     primary_ip = tables.TemplateColumn(orderable=False, verbose_name='IP Address',
                                        template_code="{{ record.primary_ip.address.ip }}")
 
     class Meta(BaseTable.Meta):
         model = Device
-        fields = ('pk', 'name', 'status', 'site', 'rack', 'device_role', 'device_type', 'primary_ip')
+        fields = ('pk', 'name', 'status', 'tenant', 'site', 'rack', 'device_role', 'device_type', 'primary_ip')
 
 
 class DeviceImportTable(BaseTable):
     name = tables.TemplateColumn(template_code=DEVICE_LINK, verbose_name='Name')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
     site = tables.Column(accessor=Accessor('rack.site'), verbose_name='Site')
     rack = tables.LinkColumn('dcim:rack', args=[Accessor('rack.pk')], verbose_name='Rack')
     position = tables.Column(verbose_name='Position')
@@ -264,7 +333,7 @@ class DeviceImportTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = Device
-        fields = ('name', 'site', 'rack', 'position', 'device_role', 'device_type')
+        fields = ('name', 'tenant', 'site', 'rack', 'position', 'device_role', 'device_type')
         empty_text = False
 
 
@@ -289,7 +358,7 @@ class PowerConnectionTable(BaseTable):
                             args=[Accessor('power_outlet.device.pk')], verbose_name='PDU')
     power_outlet = tables.Column(verbose_name='Outlet')
     device = tables.LinkColumn('dcim:device', args=[Accessor('device.pk')], verbose_name='Device')
-    name = tables.Column(verbose_name='Console port')
+    name = tables.Column(verbose_name='Power Port')
 
     class Meta(BaseTable.Meta):
         model = PowerPort
@@ -305,5 +374,5 @@ class InterfaceConnectionTable(BaseTable):
     interface_b = tables.Column(verbose_name='Interface B')
 
     class Meta(BaseTable.Meta):
-        model = PowerPort
+        model = Interface
         fields = ('device_a', 'interface_a', 'device_b', 'interface_b')

netbox/dcim/tests/test_apis.py

@@ -2,6 +2,8 @@ import json
 from rest_framework import status
 from rest_framework.test import APITestCase
 
+from django.conf import settings
+
 
 class SiteTest(APITestCase):
 
@@ -15,11 +17,13 @@ class SiteTest(APITestCase):
         'id',
         'name',
         'slug',
+        'tenant',
         'facility',
         'asn',
         'physical_address',
         'shipping_address',
         'comments',
+        'custom_fields',
         'count_prefixes',
         'count_vlans',
         'count_racks',
@@ -40,8 +44,14 @@ class SiteTest(APITestCase):
         'display_name',
         'site',
         'group',
+        'tenant',
+        'role',
+        'type',
+        'width',
         'u_height',
-        'comments'
+        'desc_units',
+        'comments',
+        'custom_fields',
     ]
 
     graph_fields = [
@@ -50,7 +60,7 @@ class SiteTest(APITestCase):
         'embed_link',
     ]
 
-    def test_get_list(self, endpoint='/api/dcim/sites/'):
+    def test_get_list(self, endpoint='/{}api/dcim/sites/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -60,7 +70,7 @@ class SiteTest(APITestCase):
                 sorted(self.standard_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/sites/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/sites/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -69,7 +79,7 @@ class SiteTest(APITestCase):
             sorted(self.standard_fields),
         )
 
-    def test_get_site_list_rack(self, endpoint='/api/dcim/sites/1/racks/'):
+    def test_get_site_list_rack(self, endpoint='/{}api/dcim/sites/1/racks/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -84,7 +94,7 @@ class SiteTest(APITestCase):
                 sorted(self.nested_fields),
             )
 
-    def test_get_site_list_graphs(self, endpoint='/api/dcim/sites/1/graphs/'):
+    def test_get_site_list_graphs(self, endpoint='/{}api/dcim/sites/1/graphs/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -115,8 +125,14 @@ class RackTest(APITestCase):
         'display_name',
         'site',
         'group',
+        'tenant',
+        'role',
+        'type',
+        'width',
         'u_height',
-        'comments'
+        'desc_units',
+        'comments',
+        'custom_fields',
     ]
 
     detail_fields = [
@@ -126,13 +142,19 @@ class RackTest(APITestCase):
         'display_name',
         'site',
         'group',
+        'tenant',
+        'role',
+        'type',
+        'width',
         'u_height',
+        'desc_units',
         'comments',
+        'custom_fields',
         'front_units',
         'rear_units'
     ]
 
-    def test_get_list(self, endpoint='/api/dcim/racks/'):
+    def test_get_list(self, endpoint='/{}api/dcim/racks/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -146,7 +168,7 @@ class RackTest(APITestCase):
                 sorted(SiteTest.nested_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/racks/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/racks/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -175,7 +197,7 @@ class ManufacturersTest(APITestCase):
 
     nested_fields = standard_fields
 
-    def test_get_list(self, endpoint='/api/dcim/manufacturers/'):
+    def test_get_list(self, endpoint='/{}api/dcim/manufacturers/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -185,7 +207,7 @@ class ManufacturersTest(APITestCase):
                 sorted(self.standard_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/manufacturers/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/manufacturers/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -204,11 +226,13 @@ class DeviceTypeTest(APITestCase):
         'manufacturer',
         'model',
         'slug',
+        'part_number',
         'u_height',
         'is_full_depth',
         'is_console_server',
         'is_pdu',
         'is_network_device',
+        'subdevice_role',
     ]
 
     nested_fields = [
@@ -218,7 +242,7 @@ class DeviceTypeTest(APITestCase):
         'slug'
     ]
 
-    def test_get_list(self, endpoint='/api/dcim/device-types/'):
+    def test_get_list(self, endpoint='/{}api/dcim/device-types/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -228,7 +252,7 @@ class DeviceTypeTest(APITestCase):
                 sorted(self.standard_fields),
             )
 
-    def test_detail_list(self, endpoint='/api/dcim/device-types/1/'):
+    def test_detail_list(self, endpoint='/{}api/dcim/device-types/1/'.format(settings.BASE_PATH)):
         # TODO: details returns list view.
         # response = self.client.get(endpoint)
         # content = json.loads(response.content)
@@ -252,7 +276,7 @@ class DeviceRolesTest(APITestCase):
 
     nested_fields = ['id', 'name', 'slug']
 
-    def test_get_list(self, endpoint='/api/dcim/device-roles/'):
+    def test_get_list(self, endpoint='/{}api/dcim/device-roles/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -262,7 +286,7 @@ class DeviceRolesTest(APITestCase):
                 sorted(self.standard_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/device-roles/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/device-roles/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -280,7 +304,7 @@ class PlatformsTest(APITestCase):
 
     nested_fields = ['id', 'name', 'slug']
 
-    def test_get_list(self, endpoint='/api/dcim/platforms/'):
+    def test_get_list(self, endpoint='/{}api/dcim/platforms/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -290,7 +314,7 @@ class PlatformsTest(APITestCase):
                 sorted(self.standard_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/platforms/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/platforms/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -310,19 +334,25 @@ class DeviceTest(APITestCase):
         'display_name',
         'device_type',
         'device_role',
+        'tenant',
         'platform',
         'serial',
+        'asset_tag',
         'rack',
         'position',
         'face',
+        'parent_device',
         'status',
         'primary_ip',
+        'primary_ip4',
+        'primary_ip6',
         'comments',
+        'custom_fields',
     ]
 
     nested_fields = ['id', 'name', 'display_name']
 
-    def test_get_list(self, endpoint='/api/dcim/devices/'):
+    def test_get_list(self, endpoint='/{}api/dcim/devices/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -349,9 +379,10 @@ class DeviceTest(APITestCase):
                 sorted(RackTest.nested_fields),
             )
 
-    def test_get_list_flat(self, endpoint='/api/dcim/devices/?format=json_flat'):
+    def test_get_list_flat(self, endpoint='/{}api/dcim/devices/?format=json_flat'.format(settings.BASE_PATH)):
 
         flat_fields = [
+            'asset_tag',
             'comments',
             'device_role_id',
             'device_role_name',
@@ -366,6 +397,7 @@ class DeviceTest(APITestCase):
             'face',
             'id',
             'name',
+            'parent_device',
             'platform_id',
             'platform_name',
             'platform_slug',
@@ -373,12 +405,17 @@ class DeviceTest(APITestCase):
             'primary_ip_address',
             'primary_ip_family',
             'primary_ip_id',
+            'primary_ip4_address',
+            'primary_ip4_family',
+            'primary_ip4_id',
+            'primary_ip6',
             'rack_display_name',
             'rack_facility_id',
             'rack_id',
             'rack_name',
             'serial',
             'status',
+            'tenant',
         ]
 
         response = self.client.get(endpoint)
@@ -390,7 +427,7 @@ class DeviceTest(APITestCase):
             sorted(flat_fields),
         )
 
-    def test_get_detail(self, endpoint='/api/dcim/devices/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/devices/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -408,7 +445,7 @@ class ConsoleServerPortsTest(APITestCase):
 
     nested_fields = ['id', 'device', 'name']
 
-    def test_get_list(self, endpoint='/api/dcim/devices/9/console-server-ports/'):
+    def test_get_list(self, endpoint='/{}api/dcim/devices/9/console-server-ports/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -430,7 +467,7 @@ class ConsolePortsTest(APITestCase):
 
     nested_fields = ['id', 'device', 'name']
 
-    def test_get_list(self, endpoint='/api/dcim/devices/1/console-ports/'):
+    def test_get_list(self, endpoint='/{}api/dcim/devices/1/console-ports/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -448,7 +485,7 @@ class ConsolePortsTest(APITestCase):
                 sorted(ConsoleServerPortsTest.nested_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/console-ports/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/console-ports/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -469,7 +506,7 @@ class PowerPortsTest(APITestCase):
 
     nested_fields = ['id', 'device', 'name']
 
-    def test_get_list(self, endpoint='/api/dcim/devices/1/power-ports/'):
+    def test_get_list(self, endpoint='/{}api/dcim/devices/1/power-ports/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -483,7 +520,7 @@ class PowerPortsTest(APITestCase):
                 sorted(DeviceTest.nested_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/power-ports/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/power-ports/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -504,7 +541,7 @@ class PowerOutletsTest(APITestCase):
 
     nested_fields = ['id', 'device', 'name']
 
-    def test_get_list(self, endpoint='/api/dcim/devices/11/power-outlets/'):
+    def test_get_list(self, endpoint='/{}api/dcim/devices/11/power-outlets/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -527,6 +564,7 @@ class InterfaceTest(APITestCase):
         'device',
         'name',
         'form_factor',
+        'mac_address',
         'mgmt_only',
         'description',
         'is_connected'
@@ -539,6 +577,7 @@ class InterfaceTest(APITestCase):
         'device',
         'name',
         'form_factor',
+        'mac_address',
         'mgmt_only',
         'description',
         'is_connected',
@@ -552,7 +591,7 @@ class InterfaceTest(APITestCase):
         'connection_status',
     ]
 
-    def test_get_list(self, endpoint='/api/dcim/devices/1/interfaces/'):
+    def test_get_list(self, endpoint='/{}api/dcim/devices/1/interfaces/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -566,7 +605,7 @@ class InterfaceTest(APITestCase):
                 sorted(DeviceTest.nested_fields),
             )
 
-    def test_get_detail(self, endpoint='/api/dcim/interfaces/1/'):
+    def test_get_detail(self, endpoint='/{}api/dcim/interfaces/1/'.format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -579,7 +618,7 @@ class InterfaceTest(APITestCase):
             sorted(DeviceTest.nested_fields),
         )
 
-    def test_get_graph_list(self, endpoint='/api/dcim/interfaces/1/graphs/'):
+    def test_get_graph_list(self, endpoint='/{}api/dcim/interfaces/1/graphs/'.format(settings.BASE_PATH)):
             response = self.client.get(endpoint)
             content = json.loads(response.content)
             self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -589,7 +628,8 @@ class InterfaceTest(APITestCase):
                     sorted(SiteTest.graph_fields),
                 )
 
-    def test_get_interface_connections(self, endpoint='/api/dcim/interface-connections/4/'):
+    def test_get_interface_connections(self, endpoint='/{}api/dcim/interface-connections/4/'
+                                       .format(settings.BASE_PATH)):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)
@@ -610,9 +650,8 @@ class RelatedConnectionsTest(APITestCase):
         'interfaces',
     ]
 
-    def test_get_list(self, endpoint=(
-            '/api/dcim/related-connections/'
-            '?peer-device=test1-edge1&peer-interface=xe-0/0/3')):
+    def test_get_list(self, endpoint=('/{}api/dcim/related-connections/?peer-device=test1-edge1&peer-interface=xe-0/0/3'
+                                      .format(settings.BASE_PATH))):
         response = self.client.get(endpoint)
         content = json.loads(response.content)
         self.assertEqual(response.status_code, status.HTTP_200_OK)

netbox/dcim/tests/test_forms.py

@@ -13,59 +13,67 @@ class DeviceTestCase(TestCase):
 
     def test_racked_device(self):
         test = DeviceForm(data={
-            'device_role': get_id(DeviceRole, 'leaf-switch'),
             'name': 'test',
-            'site': get_id(Site, 'test1'),
-            'face': RACK_FACE_FRONT,
-            'platform': get_id(Platform, 'juniper-junos'),
-            'device_type': get_id(DeviceType, 'qfx5100-48s'),
-            'position': 41,
-            'rack': '1',
+            'device_role': get_id(DeviceRole, 'leaf-switch'),
+            'tenant': None,
             'manufacturer': get_id(Manufacturer, 'juniper'),
+            'device_type': get_id(DeviceType, 'qfx5100-48s'),
+            'site': get_id(Site, 'test1'),
+            'rack': '1',
+            'face': RACK_FACE_FRONT,
+            'position': 41,
+            'platform': get_id(Platform, 'juniper-junos'),
+            'status': STATUS_ACTIVE,
         })
         self.assertTrue(test.is_valid(), test.fields['position'].choices)
         self.assertTrue(test.save())
 
     def test_racked_device_occupied(self):
         test = DeviceForm(data={
-            'device_role': get_id(DeviceRole, 'leaf-switch'),
             'name': 'test',
-            'site': get_id(Site, 'test1'),
-            'face': RACK_FACE_FRONT,
-            'platform': get_id(Platform, 'juniper-junos'),
-            'device_type': get_id(DeviceType, 'qfx5100-48s'),
-            'position': 1,
-            'rack': '1',
+            'device_role': get_id(DeviceRole, 'leaf-switch'),
+            'tenant': None,
             'manufacturer': get_id(Manufacturer, 'juniper'),
+            'device_type': get_id(DeviceType, 'qfx5100-48s'),
+            'site': get_id(Site, 'test1'),
+            'rack': '1',
+            'face': RACK_FACE_FRONT,
+            'position': 1,
+            'platform': get_id(Platform, 'juniper-junos'),
+            'status': STATUS_ACTIVE,
         })
         self.assertFalse(test.is_valid())
 
     def test_non_racked_device(self):
         test = DeviceForm(data={
-            'device_role': get_id(DeviceRole, 'pdu'),
             'name': 'test',
-            'site': get_id(Site, 'test1'),
-            'face': None,
-            'platform': None,
-            'device_type': get_id(DeviceType, 'cwg-24vym415c9'),
-            'position': None,
-            'rack': '1',
+            'device_role': get_id(DeviceRole, 'pdu'),
+            'tenant': None,
             'manufacturer': get_id(Manufacturer, 'servertech'),
+            'device_type': get_id(DeviceType, 'cwg-24vym415c9'),
+            'site': get_id(Site, 'test1'),
+            'rack': '1',
+            'face': None,
+            'position': None,
+            'platform': None,
+            'status': STATUS_ACTIVE,
         })
         self.assertTrue(test.is_valid())
         self.assertTrue(test.save())
 
     def test_non_racked_device_with_face(self):
         test = DeviceForm(data={
-            'device_role': get_id(DeviceRole, 'pdu'),
             'name': 'test',
-            'site': get_id(Site, 'test1'),
-            'face': RACK_FACE_REAR,
-            'platform': None,
-            'device_type': get_id(DeviceType, 'cwg-24vym415c9'),
-            'position': None,
-            'rack': '1',
+            'device_role': get_id(DeviceRole, 'pdu'),
+            'tenant': None,
             'manufacturer': get_id(Manufacturer, 'servertech'),
+            'device_type': get_id(DeviceType, 'cwg-24vym415c9'),
+            'site': get_id(Site, 'test1'),
+            'rack': '1',
+            'face': RACK_FACE_REAR,
+            'position': None,
+            'platform': None,
+            'status': STATUS_ACTIVE,
         })
         self.assertTrue(test.is_valid())
         self.assertTrue(test.save())

netbox/dcim/urls.py

@@ -3,9 +3,6 @@ from django.conf.urls import url
 from secrets.views import secret_add
 
 from . import views
-from .models import (
-    ConsolePortTemplate, ConsoleServerPortTemplate, PowerPortTemplate, PowerOutletTemplate, InterfaceTemplate,
-)
 
 
 urlpatterns = [
@@ -14,6 +11,7 @@ urlpatterns = [
     url(r'^sites/$', views.SiteListView.as_view(), name='site_list'),
     url(r'^sites/add/$', views.SiteEditView.as_view(), name='site_add'),
     url(r'^sites/import/$', views.SiteBulkImportView.as_view(), name='site_import'),
+    url(r'^sites/edit/$', views.SiteBulkEditView.as_view(), name='site_bulk_edit'),
     url(r'^sites/(?P<slug>[\w-]+)/$', views.site, name='site'),
     url(r'^sites/(?P<slug>[\w-]+)/edit/$', views.SiteEditView.as_view(), name='site_edit'),
     url(r'^sites/(?P<slug>[\w-]+)/delete/$', views.SiteDeleteView.as_view(), name='site_delete'),
@@ -24,6 +22,12 @@ urlpatterns = [
     url(r'^rack-groups/delete/$', views.RackGroupBulkDeleteView.as_view(), name='rackgroup_bulk_delete'),
     url(r'^rack-groups/(?P<pk>\d+)/edit/$', views.RackGroupEditView.as_view(), name='rackgroup_edit'),
 
+    # Rack roles
+    url(r'^rack-roles/$', views.RackRoleListView.as_view(), name='rackrole_list'),
+    url(r'^rack-roles/add/$', views.RackRoleEditView.as_view(), name='rackrole_add'),
+    url(r'^rack-roles/delete/$', views.RackRoleBulkDeleteView.as_view(), name='rackrole_bulk_delete'),
+    url(r'^rack-roles/(?P<pk>\d+)/edit/$', views.RackRoleEditView.as_view(), name='rackrole_edit'),
+
     # Racks
     url(r'^racks/$', views.RackListView.as_view(), name='rack_list'),
     url(r'^racks/add/$', views.RackEditView.as_view(), name='rack_add'),
@@ -49,27 +53,30 @@ urlpatterns = [
     url(r'^device-types/(?P<pk>\d+)/edit/$', views.DeviceTypeEditView.as_view(), name='devicetype_edit'),
     url(r'^device-types/(?P<pk>\d+)/delete/$', views.DeviceTypeDeleteView.as_view(), name='devicetype_delete'),
 
-    # Component templates
-    url(r'^device-types/(?P<pk>\d+)/console-ports/add/$', views.ConsolePortTemplateAddView.as_view(),
-        name='devicetype_add_consoleport'),
-    url(r'^device-types/(?P<pk>\d+)/console-ports/delete/$', views.component_template_delete,
-        {'model': ConsolePortTemplate}, name='devicetype_delete_consoleport'),
-    url(r'^device-types/(?P<pk>\d+)/console-server-ports/add/$', views.ConsoleServerPortTemplateAddView.as_view(),
-        name='devicetype_add_consoleserverport'),
-    url(r'^device-types/(?P<pk>\d+)/console-server-ports/delete/$', views.component_template_delete,
-        {'model': ConsoleServerPortTemplate}, name='devicetype_delete_consoleserverport'),
-    url(r'^device-types/(?P<pk>\d+)/power-ports/add/$', views.PowerPortTemplateAddView.as_view(),
-        name='devicetype_add_powerport'),
-    url(r'^device-types/(?P<pk>\d+)/power-ports/delete/$', views.component_template_delete,
-        {'model': PowerPortTemplate}, name='devicetype_delete_powerport'),
-    url(r'^device-types/(?P<pk>\d+)/power-outlets/add/$', views.PowerOutletTemplateAddView.as_view(),
-        name='devicetype_add_poweroutlet'),
-    url(r'^device-types/(?P<pk>\d+)/power-outlets/delete/$', views.component_template_delete,
-        {'model': PowerOutletTemplate}, name='devicetype_delete_poweroutlet'),
-    url(r'^device-types/(?P<pk>\d+)/interfaces/add/$', views.InterfaceTemplateAddView.as_view(),
-        name='devicetype_add_interface'),
-    url(r'^device-types/(?P<pk>\d+)/interfaces/delete/$', views.component_template_delete,
-        {'model': InterfaceTemplate}, name='devicetype_delete_interface'),
+    # Console port templates
+    url(r'^device-types/(?P<pk>\d+)/console-ports/add/$', views.ConsolePortTemplateAddView.as_view(), name='devicetype_add_consoleport'),
+    url(r'^device-types/(?P<pk>\d+)/console-ports/delete/$', views.ConsolePortTemplateBulkDeleteView.as_view(), name='devicetype_delete_consoleport'),
+
+    # Console server port templates
+    url(r'^device-types/(?P<pk>\d+)/console-server-ports/add/$', views.ConsoleServerPortTemplateAddView.as_view(), name='devicetype_add_consoleserverport'),
+    url(r'^device-types/(?P<pk>\d+)/console-server-ports/delete/$', views.ConsoleServerPortTemplateBulkDeleteView.as_view(), name='devicetype_delete_consoleserverport'),
+
+    # Power port templates
+    url(r'^device-types/(?P<pk>\d+)/power-ports/add/$', views.PowerPortTemplateAddView.as_view(), name='devicetype_add_powerport'),
+    url(r'^device-types/(?P<pk>\d+)/power-ports/delete/$', views.PowerPortTemplateBulkDeleteView.as_view(), name='devicetype_delete_powerport'),
+
+    # Power outlet templates
+    url(r'^device-types/(?P<pk>\d+)/power-outlets/add/$', views.PowerOutletTemplateAddView.as_view(), name='devicetype_add_poweroutlet'),
+    url(r'^device-types/(?P<pk>\d+)/power-outlets/delete/$', views.PowerOutletTemplateBulkDeleteView.as_view(), name='devicetype_delete_poweroutlet'),
+
+    # Interface templates
+    url(r'^device-types/(?P<pk>\d+)/interfaces/add/$', views.InterfaceTemplateAddView.as_view(), name='devicetype_add_interface'),
+    url(r'^device-types/(?P<pk>\d+)/interfaces/edit/$', views.InterfaceTemplateBulkEditView.as_view(), name='devicetype_bulkedit_interface'),
+    url(r'^device-types/(?P<pk>\d+)/interfaces/delete/$', views.InterfaceTemplateBulkDeleteView.as_view(), name='devicetype_delete_interface'),
+
+    # Device bay templates
+    url(r'^device-types/(?P<pk>\d+)/device-bays/add/$', views.DeviceBayTemplateAddView.as_view(), name='devicetype_add_devicebay'),
+    url(r'^device-types/(?P<pk>\d+)/device-bays/delete/$', views.DeviceBayTemplateBulkDeleteView.as_view(), name='devicetype_delete_devicebay'),
 
     # Device roles
     url(r'^device-roles/$', views.DeviceRoleListView.as_view(), name='devicerole_list'),
@@ -87,6 +94,7 @@ urlpatterns = [
     url(r'^devices/$', views.DeviceListView.as_view(), name='device_list'),
     url(r'^devices/add/$', views.DeviceEditView.as_view(), name='device_add'),
     url(r'^devices/import/$', views.DeviceBulkImportView.as_view(), name='device_import'),
+    url(r'^devices/import/child-devices/$', views.ChildDeviceBulkImportView.as_view(), name='device_import_child'),
     url(r'^devices/edit/$', views.DeviceBulkEditView.as_view(), name='device_bulk_edit'),
     url(r'^devices/delete/$', views.DeviceBulkDeleteView.as_view(), name='device_bulk_delete'),
     url(r'^devices/(?P<pk>\d+)/$', views.device, name='device'),
@@ -99,31 +107,43 @@ urlpatterns = [
 
     # Console ports
     url(r'^devices/(?P<pk>\d+)/console-ports/add/$', views.consoleport_add, name='consoleport_add'),
+    url(r'^devices/(?P<pk>\d+)/console-ports/delete/$', views.ConsolePortBulkDeleteView.as_view(), name='consoleport_bulk_delete'),
     url(r'^console-ports/(?P<pk>\d+)/connect/$', views.consoleport_connect, name='consoleport_connect'),
     url(r'^console-ports/(?P<pk>\d+)/disconnect/$', views.consoleport_disconnect, name='consoleport_disconnect'),
-    url(r'^console-ports/(?P<pk>\d+)/edit/$', views.consoleport_edit, name='consoleport_edit'),
-    url(r'^console-ports/(?P<pk>\d+)/delete/$', views.consoleport_delete, name='consoleport_delete'),
+    url(r'^console-ports/(?P<pk>\d+)/edit/$', views.ConsolePortEditView.as_view(), name='consoleport_edit'),
+    url(r'^console-ports/(?P<pk>\d+)/delete/$', views.ConsolePortDeleteView.as_view(), name='consoleport_delete'),
 
     # Console server ports
     url(r'^devices/(?P<pk>\d+)/console-server-ports/add/$', views.consoleserverport_add, name='consoleserverport_add'),
+    url(r'^devices/(?P<pk>\d+)/console-server-ports/delete/$', views.ConsoleServerPortBulkDeleteView.as_view(), name='consoleserverport_bulk_delete'),
     url(r'^console-server-ports/(?P<pk>\d+)/connect/$', views.consoleserverport_connect, name='consoleserverport_connect'),
     url(r'^console-server-ports/(?P<pk>\d+)/disconnect/$', views.consoleserverport_disconnect, name='consoleserverport_disconnect'),
-    url(r'^console-server-ports/(?P<pk>\d+)/edit/$', views.consoleserverport_edit, name='consoleserverport_edit'),
-    url(r'^console-server-ports/(?P<pk>\d+)/delete/$', views.consoleserverport_delete, name='consoleserverport_delete'),
+    url(r'^console-server-ports/(?P<pk>\d+)/edit/$', views.ConsoleServerPortEditView.as_view(), name='consoleserverport_edit'),
+    url(r'^console-server-ports/(?P<pk>\d+)/delete/$', views.ConsoleServerPortDeleteView.as_view(), name='consoleserverport_delete'),
 
     # Power ports
     url(r'^devices/(?P<pk>\d+)/power-ports/add/$', views.powerport_add, name='powerport_add'),
+    url(r'^devices/(?P<pk>\d+)/power-ports/delete/$', views.PowerPortBulkDeleteView.as_view(), name='powerport_bulk_delete'),
     url(r'^power-ports/(?P<pk>\d+)/connect/$', views.powerport_connect, name='powerport_connect'),
     url(r'^power-ports/(?P<pk>\d+)/disconnect/$', views.powerport_disconnect, name='powerport_disconnect'),
-    url(r'^power-ports/(?P<pk>\d+)/edit/$', views.powerport_edit, name='powerport_edit'),
-    url(r'^power-ports/(?P<pk>\d+)/delete/$', views.powerport_delete, name='powerport_delete'),
+    url(r'^power-ports/(?P<pk>\d+)/edit/$', views.PowerPortEditView.as_view(), name='powerport_edit'),
+    url(r'^power-ports/(?P<pk>\d+)/delete/$', views.PowerPortDeleteView.as_view(), name='powerport_delete'),
 
     # Power outlets
     url(r'^devices/(?P<pk>\d+)/power-outlets/add/$', views.poweroutlet_add, name='poweroutlet_add'),
+    url(r'^devices/(?P<pk>\d+)/power-outlets/delete/$', views.PowerOutletBulkDeleteView.as_view(), name='poweroutlet_bulk_delete'),
     url(r'^power-outlets/(?P<pk>\d+)/connect/$', views.poweroutlet_connect, name='poweroutlet_connect'),
     url(r'^power-outlets/(?P<pk>\d+)/disconnect/$', views.poweroutlet_disconnect, name='poweroutlet_disconnect'),
-    url(r'^power-outlets/(?P<pk>\d+)/edit/$', views.poweroutlet_edit, name='poweroutlet_edit'),
-    url(r'^power-outlets/(?P<pk>\d+)/delete/$', views.poweroutlet_delete, name='poweroutlet_delete'),
+    url(r'^power-outlets/(?P<pk>\d+)/edit/$', views.PowerOutletEditView.as_view(), name='poweroutlet_edit'),
+    url(r'^power-outlets/(?P<pk>\d+)/delete/$', views.PowerOutletDeleteView.as_view(), name='poweroutlet_delete'),
+
+    # Device bays
+    url(r'^devices/(?P<pk>\d+)/bays/add/$', views.devicebay_add, name='devicebay_add'),
+    url(r'^devices/(?P<pk>\d+)/bays/delete/$', views.DeviceBayBulkDeleteView.as_view(), name='devicebay_bulk_delete'),
+    url(r'^device-bays/(?P<pk>\d+)/edit/$', views.DeviceBayEditView.as_view(), name='devicebay_edit'),
+    url(r'^device-bays/(?P<pk>\d+)/delete/$', views.DeviceBayDeleteView.as_view(), name='devicebay_delete'),
+    url(r'^device-bays/(?P<pk>\d+)/populate/$', views.devicebay_populate, name='devicebay_populate'),
+    url(r'^device-bays/(?P<pk>\d+)/depopulate/$', views.devicebay_depopulate, name='devicebay_depopulate'),
 
     # Console/power/interface connections
     url(r'^console-connections/$', views.ConsoleConnectionsListView.as_view(), name='console_connections_list'),
@@ -134,16 +154,18 @@ urlpatterns = [
     url(r'^interface-connections/import/$', views.InterfaceConnectionsBulkImportView.as_view(), name='interface_connections_import'),
 
     # Interfaces
-    url(r'^devices/interfaces/add/$', views.InterfaceBulkAddView.as_view(), name='interface_bulk_add'),
+    url(r'^devices/interfaces/add/$', views.DeviceBulkAddInterfaceView.as_view(), name='device_bulk_add_interface'),
     url(r'^devices/(?P<pk>\d+)/interfaces/add/$', views.interface_add, name='interface_add'),
+    url(r'^devices/(?P<pk>\d+)/interfaces/edit/$', views.InterfaceBulkEditView.as_view(), name='interface_bulk_edit'),
+    url(r'^devices/(?P<pk>\d+)/interfaces/delete/$', views.InterfaceBulkDeleteView.as_view(), name='interface_bulk_delete'),
     url(r'^devices/(?P<pk>\d+)/interface-connections/add/$', views.interfaceconnection_add, name='interfaceconnection_add'),
     url(r'^interface-connections/(?P<pk>\d+)/delete/$', views.interfaceconnection_delete, name='interfaceconnection_delete'),
-    url(r'^interfaces/(?P<pk>\d+)/edit/$', views.interface_edit, name='interface_edit'),
-    url(r'^interfaces/(?P<pk>\d+)/delete/$', views.interface_delete, name='interface_delete'),
+    url(r'^interfaces/(?P<pk>\d+)/edit/$', views.InterfaceEditView.as_view(), name='interface_edit'),
+    url(r'^interfaces/(?P<pk>\d+)/delete/$', views.InterfaceDeleteView.as_view(), name='interface_delete'),
 
     # Modules
     url(r'^devices/(?P<pk>\d+)/modules/add/$', views.module_add, name='module_add'),
-    url(r'^modules/(?P<pk>\d+)/edit/$', views.module_edit, name='module_edit'),
-    url(r'^modules/(?P<pk>\d+)/delete/$', views.module_delete, name='module_delete'),
+    url(r'^modules/(?P<pk>\d+)/edit/$', views.ModuleEditView.as_view(), name='module_edit'),
+    url(r'^modules/(?P<pk>\d+)/delete/$', views.ModuleDeleteView.as_view(), name='module_delete'),
 
 ]

netbox/extras/admin.py

@@ -1,6 +1,37 @@
+from django import forms
 from django.contrib import admin
+from django.utils.safestring import mark_safe
 
-from .models import Graph, ExportTemplate, TopologyMap, UserAction
+from .models import CustomField, CustomFieldChoice, Graph, ExportTemplate, TopologyMap, UserAction
+
+
+class CustomFieldForm(forms.ModelForm):
+
+    class Meta:
+        model = CustomField
+        exclude = []
+
+    def __init__(self, *args, **kwargs):
+        super(CustomFieldForm, self).__init__(*args, **kwargs)
+
+        # Organize the available ContentTypes
+        queryset = self.fields['obj_type'].queryset.order_by('app_label', 'model')
+        self.fields['obj_type'].choices = [(ct.pk, '{} > {}'.format(ct.app_label, ct.name)) for ct in queryset]
+
+
+class CustomFieldChoiceAdmin(admin.TabularInline):
+    model = CustomFieldChoice
+    extra = 5
+
+
+@admin.register(CustomField)
+class CustomFieldAdmin(admin.ModelAdmin):
+    inlines = [CustomFieldChoiceAdmin]
+    list_display = ['name', 'models', 'type', 'required', 'default', 'weight', 'description']
+    form = CustomFieldForm
+
+    def models(self, obj):
+        return ', '.join([ct.name for ct in obj.obj_type.all()])
 
 
 @admin.register(Graph)
@@ -10,7 +41,7 @@ class GraphAdmin(admin.ModelAdmin):
 
 @admin.register(ExportTemplate)
 class ExportTemplateAdmin(admin.ModelAdmin):
-    list_display = ['content_type', 'name', 'mime_type', 'file_extension']
+    list_display = ['name', 'content_type', 'description', 'mime_type', 'file_extension']
 
 
 @admin.register(TopologyMap)
@@ -19,3 +50,12 @@ class TopologyMapAdmin(admin.ModelAdmin):
     prepopulated_fields = {
         'slug': ['name'],
     }
+
+
+@admin.register(UserAction)
+class UserActionAdmin(admin.ModelAdmin):
+    actions = None
+    list_display = ['user', 'action', 'content_type', 'object_id', '_message']
+
+    def _message(self, obj):
+        return mark_safe(obj.message)

netbox/extras/api/serializers.py

@@ -1,6 +1,44 @@
 from rest_framework import serializers
 
-from extras.models import Graph
+from extras.models import CF_TYPE_SELECT, CustomFieldChoice, Graph
+
+
+class CustomFieldSerializer(serializers.Serializer):
+    """
+    Extends a ModelSerializer to render any CustomFields and their values associated with an object.
+    """
+    custom_fields = serializers.SerializerMethodField()
+
+    def get_custom_fields(self, obj):
+
+        # Gather all CustomFields applicable to this object
+        fields = {cf.name: None for cf in self.context['view'].custom_fields}
+
+        # Attach any defined CustomFieldValues to their respective CustomFields
+        for cfv in obj.custom_field_values.all():
+
+            # Attempt to suppress database lookups for CustomFieldChoices by using the cached choice set from the view
+            # context.
+            if cfv.field.type == CF_TYPE_SELECT and hasattr(self, 'custom_field_choices'):
+                cfc = {
+                    'id': int(cfv.serialized_value),
+                    'value': self.context['view'].custom_field_choices[int(cfv.serialized_value)]
+                }
+                fields[cfv.field.name] = CustomFieldChoiceSerializer(instance=cfc).data
+            # Fall back to hitting the database in case we're in a view that doesn't inherit CustomFieldModelAPIView.
+            elif cfv.field.type == CF_TYPE_SELECT:
+                fields[cfv.field.name] = CustomFieldChoiceSerializer(instance=cfv.value).data
+            else:
+                fields[cfv.field.name] = cfv.value
+
+        return fields
+
+
+class CustomFieldChoiceSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = CustomFieldChoice
+        fields = ['id', 'value']
 
 
 class GraphSerializer(serializers.ModelSerializer):

netbox/extras/api/views.py

@@ -1,9 +1,8 @@
 import graphviz
 from rest_framework import generics
 from rest_framework.views import APIView
-import tempfile
-from wsgiref.util import FileWrapper
 
+from django.contrib.contenttypes.models import ContentType
 from django.db.models import Q
 from django.http import Http404, HttpResponse
 from django.shortcuts import get_object_or_404
@@ -15,6 +14,24 @@ from extras.models import Graph, TopologyMap, GRAPH_TYPE_INTERFACE, GRAPH_TYPE_P
 from .serializers import GraphSerializer
 
 
+class CustomFieldModelAPIView(object):
+    """
+    Include the applicable set of CustomField in the view context.
+    """
+
+    def __init__(self):
+        super(CustomFieldModelAPIView, self).__init__()
+        self.content_type = ContentType.objects.get_for_model(self.queryset.model)
+        self.custom_fields = self.content_type.custom_fields.prefetch_related('choices')
+
+        # Cache all relevant CustomFieldChoices. This saves us from having to do a lookup per select field per object.
+        custom_field_choices = {}
+        for field in self.custom_fields:
+            for cfc in field.choices.all():
+                custom_field_choices[cfc.id] = cfc.value
+        self.custom_field_choices = custom_field_choices
+
+
 class GraphListView(generics.ListAPIView):
     """
     Returns a list of relevant graphs
@@ -63,7 +80,7 @@ class TopologyMapView(APIView):
 
             # Add each device to the graph
             devices = []
-            for query in device_set.split(','):
+            for query in device_set.split(';'):  # Split regexes on semicolons
                 devices += Device.objects.filter(name__regex=query)
             for d in devices:
                 subgraph.node(d.name)
@@ -77,7 +94,7 @@ class TopologyMapView(APIView):
         # Compile list of all devices
         device_superset = Q()
         for device_set in tmap.device_sets:
-            for query in device_set.split(','):
+            for query in device_set.split(';'):  # Split regexes on semicolons
                 device_superset = device_superset | Q(name__regex=query)
 
         # Add all connections to the graph

netbox/extras/filters.py

@@ -0,0 +1,46 @@
+import django_filters
+
+from django.contrib.contenttypes.models import ContentType
+
+from .models import CF_TYPE_SELECT, CustomField
+
+
+class CustomFieldFilter(django_filters.Filter):
+    """
+    Filter objects by the presence of a CustomFieldValue. The filter's name is used as the CustomField name.
+    """
+
+    def __init__(self, cf_type, *args, **kwargs):
+        self.cf_type = cf_type
+        super(CustomFieldFilter, self).__init__(*args, **kwargs)
+
+    def filter(self, queryset, value):
+        # Skip filter on empty value
+        if not value.strip():
+            return queryset
+        # Treat 0 as None for Select fields
+        try:
+            if self.cf_type == CF_TYPE_SELECT and int(value) == 0:
+                return queryset.exclude(
+                    custom_field_values__field__name=self.name,
+                )
+        except ValueError:
+            pass
+        return queryset.filter(
+            custom_field_values__field__name=self.name,
+            custom_field_values__serialized_value=value,
+        )
+
+
+class CustomFieldFilterSet(django_filters.FilterSet):
+    """
+    Dynamically add a Filter for each CustomField applicable to the parent model.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(CustomFieldFilterSet, self).__init__(*args, **kwargs)
+
+        obj_type = ContentType.objects.get_for_model(self._meta.model)
+        custom_fields = CustomField.objects.filter(obj_type=obj_type, is_filterable=True)
+        for cf in custom_fields:
+            self.filters['cf_{}'.format(cf.name)] = CustomFieldFilter(name=cf.name, cf_type=cf.type)

netbox/extras/forms.py

@@ -0,0 +1,159 @@
+from collections import OrderedDict
+
+from django import forms
+from django.contrib.contenttypes.models import ContentType
+
+from utilities.forms import BulkEditForm, LaxURLField
+from .models import (
+    CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_INTEGER, CF_TYPE_SELECT, CF_TYPE_URL, CustomField, CustomFieldValue
+)
+
+
+def get_custom_fields_for_model(content_type, filterable_only=False, bulk_edit=False):
+    """
+    Retrieve all CustomFields applicable to the given ContentType
+    """
+    field_dict = OrderedDict()
+    kwargs = {'obj_type': content_type}
+    if filterable_only:
+        kwargs['is_filterable'] = True
+    custom_fields = CustomField.objects.filter(**kwargs)
+
+    for cf in custom_fields:
+        field_name = 'cf_{}'.format(str(cf.name))
+
+        # Integer
+        if cf.type == CF_TYPE_INTEGER:
+            field = forms.IntegerField(required=cf.required, initial=cf.default)
+
+        # Boolean
+        elif cf.type == CF_TYPE_BOOLEAN:
+            choices = (
+                (None, '---------'),
+                (1, 'True'),
+                (0, 'False'),
+            )
+            if cf.default.lower() in ['true', 'yes', '1']:
+                initial = True
+            elif cf.default.lower() in ['false', 'no', '0']:
+                initial = False
+            else:
+                initial = None
+            field = forms.NullBooleanField(required=cf.required, initial=initial,
+                                           widget=forms.Select(choices=choices))
+
+        # Date
+        elif cf.type == CF_TYPE_DATE:
+            field = forms.DateField(required=cf.required, initial=cf.default)
+
+        # Select
+        elif cf.type == CF_TYPE_SELECT:
+            choices = [(cfc.pk, cfc) for cfc in cf.choices.all()]
+            if bulk_edit or filterable_only:
+                choices = [(None, '---------')] + choices
+            field = forms.TypedChoiceField(choices=choices, coerce=int, required=cf.required)
+
+        # URL
+        elif cf.type == CF_TYPE_URL:
+            field = LaxURLField(required=cf.required, initial=cf.default)
+
+        # Text
+        else:
+            field = forms.CharField(max_length=255, required=cf.required, initial=cf.default)
+
+        field.model = cf
+        field.label = cf.label if cf.label else cf.name.replace('_', ' ').capitalize()
+        field.help_text = cf.description
+
+        field_dict[field_name] = field
+
+    return field_dict
+
+
+class CustomFieldForm(forms.ModelForm):
+
+    def __init__(self, *args, **kwargs):
+
+        self.custom_fields = []
+        self.obj_type = ContentType.objects.get_for_model(self._meta.model)
+
+        super(CustomFieldForm, self).__init__(*args, **kwargs)
+
+        # Add all applicable CustomFields to the form
+        custom_fields = []
+        for name, field in get_custom_fields_for_model(self.obj_type).items():
+            self.fields[name] = field
+            custom_fields.append(name)
+        self.custom_fields = custom_fields
+
+        # If editing an existing object, initialize values for all custom fields
+        if self.instance.pk:
+            existing_values = CustomFieldValue.objects.filter(obj_type=self.obj_type, obj_id=self.instance.pk)\
+                .select_related('field')
+            for cfv in existing_values:
+                self.initial['cf_{}'.format(str(cfv.field.name))] = cfv.serialized_value
+
+    def _save_custom_fields(self):
+
+        for field_name in self.custom_fields:
+            try:
+                cfv = CustomFieldValue.objects.select_related('field').get(field=self.fields[field_name].model,
+                                                                           obj_type=self.obj_type,
+                                                                           obj_id=self.instance.pk)
+            except CustomFieldValue.DoesNotExist:
+                # Skip this field if none exists already and its value is empty
+                if self.cleaned_data[field_name] in [None, u'']:
+                    continue
+                cfv = CustomFieldValue(
+                    field=self.fields[field_name].model,
+                    obj_type=self.obj_type,
+                    obj_id=self.instance.pk
+                )
+            cfv.value = self.cleaned_data[field_name]
+            cfv.save()
+
+    def save(self, commit=True):
+        obj = super(CustomFieldForm, self).save(commit)
+
+        # Handle custom fields the same way we do M2M fields
+        if commit:
+            self._save_custom_fields()
+        else:
+            self.save_custom_fields = self._save_custom_fields
+
+        return obj
+
+
+class CustomFieldBulkEditForm(BulkEditForm):
+
+    def __init__(self, *args, **kwargs):
+        super(CustomFieldBulkEditForm, self).__init__(*args, **kwargs)
+
+        self.custom_fields = []
+        self.obj_type = ContentType.objects.get_for_model(self.model)
+
+        # Add all applicable CustomFields to the form
+        custom_fields = get_custom_fields_for_model(self.obj_type, bulk_edit=True).items()
+        for name, field in custom_fields:
+            # Annotate non-required custom fields as nullable
+            if not field.required:
+                self.nullable_fields.append(name)
+            field.required = False
+            self.fields[name] = field
+            # Annotate this as a custom field
+            self.custom_fields.append(name)
+
+
+class CustomFieldFilterForm(forms.Form):
+
+    def __init__(self, *args, **kwargs):
+
+        self.obj_type = ContentType.objects.get_for_model(self.model)
+
+        super(CustomFieldFilterForm, self).__init__(*args, **kwargs)
+
+        # Add all applicable CustomFields to the form
+        custom_fields = get_custom_fields_for_model(self.obj_type, filterable_only=True).items()
+        for name, field in custom_fields:
+            field.required = False
+            self.fields[name] = field

netbox/extras/migrations/0002_custom_fields.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-08-23 20:33
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('extras', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CustomField',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('type', models.PositiveSmallIntegerField(choices=[(100, b'Text'), (200, b'Integer'), (300, b'Boolean (true/false)'), (400, b'Date'), (500, b'URL'), (600, b'Selection')], default=100)),
+                ('name', models.CharField(max_length=50, unique=True)),
+                ('label', models.CharField(blank=True, help_text=b"Name of the field as displayed to users (if not provided, the field's name will be used)", max_length=50)),
+                ('description', models.CharField(blank=True, max_length=100)),
+                ('required', models.BooleanField(default=False, help_text=b'Determines whether this field is required when creating new objects or editing an existing object.')),
+                ('is_filterable', models.BooleanField(default=True, help_text=b'This field can be used to filter objects.')),
+                ('default', models.CharField(blank=True, help_text=b'Default value for the field. Use "true" or "false" for booleans. N/A for selection fields.', max_length=100)),
+                ('weight', models.PositiveSmallIntegerField(default=100, help_text=b'Fields with higher weights appear lower in a form')),
+                ('obj_type', models.ManyToManyField(help_text=b'The object(s) to which this field applies.', related_name='custom_fields', to='contenttypes.ContentType', verbose_name=b'Object(s)')),
+            ],
+            options={
+                'ordering': ['weight', 'name'],
+            },
+        ),
+        migrations.CreateModel(
+            name='CustomFieldChoice',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('value', models.CharField(max_length=100)),
+                ('weight', models.PositiveSmallIntegerField(default=100, help_text=b'Higher weights appear lower in the list')),
+                ('field', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='choices', to='extras.CustomField')),
+            ],
+            options={
+                'ordering': ['field', 'weight', 'value'],
+            },
+        ),
+        migrations.CreateModel(
+            name='CustomFieldValue',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('obj_id', models.PositiveIntegerField()),
+                ('serialized_value', models.CharField(max_length=255)),
+                ('field', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='values', to='extras.CustomField')),
+                ('obj_type', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='+', to='contenttypes.ContentType')),
+            ],
+            options={
+                'ordering': ['obj_type', 'obj_id'],
+            },
+        ),
+        migrations.AlterUniqueTogether(
+            name='customfieldvalue',
+            unique_together=set([('field', 'obj_type', 'obj_id')]),
+        ),
+        migrations.AlterUniqueTogether(
+            name='customfieldchoice',
+            unique_together=set([('field', 'value')]),
+        ),
+    ]

netbox/extras/migrations/0003_exporttemplate_add_description.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-09-27 20:20
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('extras', '0002_custom_fields'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='exporttemplate',
+            name='description',
+            field=models.CharField(blank=True, max_length=200),
+        ),
+        migrations.AlterField(
+            model_name='exporttemplate',
+            name='name',
+            field=models.CharField(max_length=100),
+        ),
+    ]

netbox/extras/migrations/0004_topologymap_change_comma_to_semicolon.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10 on 2016-11-03 18:33
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+from extras.models import TopologyMap
+
+
+def commas_to_semicolons(apps, schema_editor):
+    for tm in TopologyMap.objects.filter(device_patterns__contains=','):
+        tm.device_patterns = tm.device_patterns.replace(',', ';')
+        tm.save()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('extras', '0003_exporttemplate_add_description'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='topologymap',
+            name='device_patterns',
+            field=models.TextField(help_text=b'Identify devices to include in the diagram using regular expressions, one per line. Each line will result in a new tier of the drawing. Separate multiple regexes within a line using semicolons. Devices will be rendered in the order they are defined.'),
+        ),
+        migrations.RunPython(commas_to_semicolons),
+    ]

netbox/extras/models.py

@@ -1,12 +1,37 @@
+from collections import OrderedDict
+from datetime import date
+
 from django.contrib.auth.models import User
+from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
+from django.core.validators import ValidationError
 from django.db import models
 from django.http import HttpResponse
 from django.template import Template, Context
 from django.utils.safestring import mark_safe
 
-from dcim.models import Site
 
+CUSTOMFIELD_MODELS = (
+    'site', 'rack', 'device',                               # DCIM
+    'aggregate', 'prefix', 'ipaddress', 'vlan', 'vrf',      # IPAM
+    'provider', 'circuit',                                  # Circuits
+    'tenant',                                               # Tenants
+)
+
+CF_TYPE_TEXT = 100
+CF_TYPE_INTEGER = 200
+CF_TYPE_BOOLEAN = 300
+CF_TYPE_DATE = 400
+CF_TYPE_URL = 500
+CF_TYPE_SELECT = 600
+CUSTOMFIELD_TYPE_CHOICES = (
+    (CF_TYPE_TEXT, 'Text'),
+    (CF_TYPE_INTEGER, 'Integer'),
+    (CF_TYPE_BOOLEAN, 'Boolean (true/false)'),
+    (CF_TYPE_DATE, 'Date'),
+    (CF_TYPE_URL, 'URL'),
+    (CF_TYPE_SELECT, 'Selection'),
+)
 
 GRAPH_TYPE_INTERFACE = 100
 GRAPH_TYPE_PROVIDER = 200
@@ -18,9 +43,10 @@ GRAPH_TYPE_CHOICES = (
 )
 
 EXPORTTEMPLATE_MODELS = [
-    'site', 'rack', 'device', 'consoleport', 'powerport', 'interfaceconnection',
-    'aggregate', 'prefix', 'ipaddress', 'vlan',
-    'provider', 'circuit'
+    'site', 'rack', 'device', 'consoleport', 'powerport', 'interfaceconnection',    # DCIM
+    'aggregate', 'prefix', 'ipaddress', 'vlan',                                     # IPAM
+    'provider', 'circuit',                                                          # Circuits
+    'tenant',                                                                       # Tenants
 ]
 
 ACTION_CREATE = 1
@@ -39,6 +65,148 @@ ACTION_CHOICES = (
 )
 
 
+class CustomFieldModel(object):
+
+    def cf(self):
+        """
+        Name-based CustomFieldValue accessor for use in templates
+        """
+        if not hasattr(self, 'get_custom_fields'):
+            return dict()
+        return {field.name: value for field, value in self.get_custom_fields().items()}
+
+    def get_custom_fields(self):
+        """
+        Return a dictionary of custom fields for a single object in the form {<field>: value}.
+        """
+
+        # Find all custom fields applicable to this type of object
+        content_type = ContentType.objects.get_for_model(self)
+        fields = CustomField.objects.filter(obj_type=content_type)
+
+        # If the object exists, populate its custom fields with values
+        if hasattr(self, 'pk'):
+            values = CustomFieldValue.objects.filter(obj_type=content_type, obj_id=self.pk).select_related('field')
+            values_dict = {cfv.field_id: cfv.value for cfv in values}
+            return OrderedDict([(field, values_dict.get(field.pk)) for field in fields])
+        else:
+            return OrderedDict([(field, None) for field in fields])
+
+
+class CustomField(models.Model):
+    obj_type = models.ManyToManyField(ContentType, related_name='custom_fields', verbose_name='Object(s)',
+                                      limit_choices_to={'model__in': CUSTOMFIELD_MODELS},
+                                      help_text="The object(s) to which this field applies.")
+    type = models.PositiveSmallIntegerField(choices=CUSTOMFIELD_TYPE_CHOICES, default=CF_TYPE_TEXT)
+    name = models.CharField(max_length=50, unique=True)
+    label = models.CharField(max_length=50, blank=True, help_text="Name of the field as displayed to users (if not "
+                                                                  "provided, the field's name will be used)")
+    description = models.CharField(max_length=100, blank=True)
+    required = models.BooleanField(default=False, help_text="Determines whether this field is required when creating "
+                                                            "new objects or editing an existing object.")
+    is_filterable = models.BooleanField(default=True, help_text="This field can be used to filter objects.")
+    default = models.CharField(max_length=100, blank=True, help_text="Default value for the field. Use \"true\" or "
+                                                                     "\"false\" for booleans. N/A for selection "
+                                                                     "fields.")
+    weight = models.PositiveSmallIntegerField(default=100, help_text="Fields with higher weights appear lower in a "
+                                                                     "form")
+
+    class Meta:
+        ordering = ['weight', 'name']
+
+    def __unicode__(self):
+        return self.label or self.name.replace('_', ' ').capitalize()
+
+    def serialize_value(self, value):
+        """
+        Serialize the given value to a string suitable for storage as a CustomFieldValue
+        """
+        if value is None:
+            return ''
+        if self.type == CF_TYPE_BOOLEAN:
+            return str(int(bool(value)))
+        if self.type == CF_TYPE_DATE:
+            return value.strftime('%Y-%m-%d')
+        if self.type == CF_TYPE_SELECT:
+            # Could be ModelChoiceField or TypedChoiceField
+            return str(value.id) if hasattr(value, 'id') else str(value)
+        return value
+
+    def deserialize_value(self, serialized_value):
+        """
+        Convert a string into the object it represents depending on the type of field
+        """
+        if serialized_value is '':
+            return None
+        if self.type == CF_TYPE_INTEGER:
+            return int(serialized_value)
+        if self.type == CF_TYPE_BOOLEAN:
+            return bool(int(serialized_value))
+        if self.type == CF_TYPE_DATE:
+            # Read date as YYYY-MM-DD
+            return date(*[int(n) for n in serialized_value.split('-')])
+        if self.type == CF_TYPE_SELECT:
+            try:
+                return self.choices.get(pk=int(serialized_value))
+            except CustomFieldChoice.DoesNotExist:
+                return None
+        return serialized_value
+
+
+class CustomFieldValue(models.Model):
+    field = models.ForeignKey('CustomField', related_name='values')
+    obj_type = models.ForeignKey(ContentType, related_name='+', on_delete=models.PROTECT)
+    obj_id = models.PositiveIntegerField()
+    obj = GenericForeignKey('obj_type', 'obj_id')
+    serialized_value = models.CharField(max_length=255)
+
+    class Meta:
+        ordering = ['obj_type', 'obj_id']
+        unique_together = ['field', 'obj_type', 'obj_id']
+
+    def __unicode__(self):
+        return u'{} {}'.format(self.obj, self.field)
+
+    @property
+    def value(self):
+        return self.field.deserialize_value(self.serialized_value)
+
+    @value.setter
+    def value(self, value):
+        self.serialized_value = self.field.serialize_value(value)
+
+    def save(self, *args, **kwargs):
+        # Delete this object if it no longer has a value to store
+        if self.pk and self.value is None:
+            self.delete()
+        else:
+            super(CustomFieldValue, self).save(*args, **kwargs)
+
+
+class CustomFieldChoice(models.Model):
+    field = models.ForeignKey('CustomField', related_name='choices', limit_choices_to={'type': CF_TYPE_SELECT},
+                              on_delete=models.CASCADE)
+    value = models.CharField(max_length=100)
+    weight = models.PositiveSmallIntegerField(default=100, help_text="Higher weights appear lower in the list")
+
+    class Meta:
+        ordering = ['field', 'weight', 'value']
+        unique_together = ['field', 'value']
+
+    def __unicode__(self):
+        return self.value
+
+    def clean(self):
+        if self.field.type != CF_TYPE_SELECT:
+            raise ValidationError("Custom field choices can only be assigned to selection fields.")
+
+    def delete(self, using=None, keep_parents=False):
+        # When deleting a CustomFieldChoice, delete all CustomFieldValues which point to it
+        pk = self.pk
+        super(CustomFieldChoice, self).delete(using, keep_parents)
+        CustomFieldValue.objects.filter(field__type=CF_TYPE_SELECT, serialized_value=str(pk)).delete()
+
+
 class Graph(models.Model):
     type = models.PositiveSmallIntegerField(choices=GRAPH_TYPE_CHOICES)
     weight = models.PositiveSmallIntegerField(default=1000)
@@ -65,7 +233,8 @@ class Graph(models.Model):
 
 class ExportTemplate(models.Model):
     content_type = models.ForeignKey(ContentType, limit_choices_to={'model__in': EXPORTTEMPLATE_MODELS})
-    name = models.CharField(max_length=200)
+    name = models.CharField(max_length=100)
+    description = models.CharField(max_length=200, blank=True)
     template_code = models.TextField()
     mime_type = models.CharField(max_length=15, blank=True)
     file_extension = models.CharField(max_length=15, blank=True)
@@ -77,7 +246,7 @@ class ExportTemplate(models.Model):
         ]
 
     def __unicode__(self):
-        return "{}: {}".format(self.content_type, self.name)
+        return u'{}: {}'.format(self.content_type, self.name)
 
     def to_response(self, context_dict, filename):
         """
@@ -85,10 +254,10 @@ class ExportTemplate(models.Model):
         """
         template = Template(self.template_code)
         mime_type = 'text/plain' if not self.mime_type else self.mime_type
-        response = HttpResponse(
-            template.render(Context(context_dict)),
-            content_type=mime_type
-        )
+        output = template.render(Context(context_dict))
+        # Replace CRLF-style line terminators
+        output = output.replace('\r\n', '\n')
+        response = HttpResponse(output, content_type=mime_type)
         if self.file_extension:
             filename += '.{}'.format(self.file_extension)
         response['Content-Disposition'] = 'attachment; filename="{}"'.format(filename)
@@ -98,11 +267,12 @@ class ExportTemplate(models.Model):
 class TopologyMap(models.Model):
     name = models.CharField(max_length=50, unique=True)
     slug = models.SlugField(unique=True)
-    site = models.ForeignKey(Site, related_name='topology_maps', blank=True, null=True)
-    device_patterns = models.TextField(help_text="Identify devices to include in the diagram using regular expressions,"
-                                                 "one per line. Each line will result in a new tier of the drawing. "
-                                                 "Separate multiple regexes on a line using commas. Devices will be "
-                                                 "rendered in the order they are defined.")
+    site = models.ForeignKey('dcim.Site', related_name='topology_maps', blank=True, null=True)
+    device_patterns = models.TextField(
+        help_text="Identify devices to include in the diagram using regular expressions, one per line. Each line will "
+                  "result in a new tier of the drawing. Separate multiple regexes within a line using semicolons. "
+                  "Devices will be rendered in the order they are defined."
+    )
     description = models.CharField(max_length=100, blank=True)
 
     class Meta:
@@ -176,8 +346,8 @@ class UserAction(models.Model):
 
     def __unicode__(self):
         if self.message:
-            return ' '.join([self.user, self.message])
-        return ' '.join([self.user, self.get_action_display(), self.content_type])
+            return u'{} {}'.format(self.user, self.message)
+        return u'{} {} {}'.format(self.user, self.get_action_display(), self.content_type)
 
     def icon(self):
         if self.action in [ACTION_CREATE, ACTION_IMPORT]:

netbox/extras/tests/test_customfields.py

@@ -0,0 +1,97 @@
+from datetime import date
+
+from django.contrib.contenttypes.models import ContentType
+from django.test import TestCase
+
+from dcim.models import Site
+
+from extras.models import (
+    CustomField, CustomFieldValue, CustomFieldChoice, CF_TYPE_TEXT, CF_TYPE_INTEGER, CF_TYPE_BOOLEAN, CF_TYPE_DATE,
+    CF_TYPE_SELECT, CF_TYPE_URL,
+)
+
+
+class CustomFieldTestCase(TestCase):
+
+    def setUp(self):
+
+        Site.objects.bulk_create([
+            Site(name='Site A', slug='site-a'),
+            Site(name='Site B', slug='site-b'),
+            Site(name='Site C', slug='site-c'),
+        ])
+
+    def test_simple_fields(self):
+
+        DATA = (
+            {'field_type': CF_TYPE_TEXT, 'field_value': 'Foobar!', 'empty_value': ''},
+            {'field_type': CF_TYPE_INTEGER, 'field_value': 0, 'empty_value': None},
+            {'field_type': CF_TYPE_INTEGER, 'field_value': 42, 'empty_value': None},
+            {'field_type': CF_TYPE_BOOLEAN, 'field_value': True, 'empty_value': None},
+            {'field_type': CF_TYPE_BOOLEAN, 'field_value': False, 'empty_value': None},
+            {'field_type': CF_TYPE_DATE, 'field_value': date(2016, 6, 23), 'empty_value': None},
+            {'field_type': CF_TYPE_URL, 'field_value': 'http://example.com/', 'empty_value': ''},
+        )
+
+        obj_type = ContentType.objects.get_for_model(Site)
+
+        for data in DATA:
+
+            # Create a custom field
+            cf = CustomField(type=data['field_type'], name='my_field', required=False)
+            cf.save()
+            cf.obj_type = [obj_type]
+            cf.save()
+
+            # Assign a value to the first Site
+            site = Site.objects.first()
+            cfv = CustomFieldValue(field=cf, obj_type=obj_type, obj_id=site.id)
+            cfv.value = data['field_value']
+            cfv.save()
+
+            # Retrieve the stored value
+            cfv = CustomFieldValue.objects.filter(obj_type=obj_type, obj_id=site.pk).first()
+            self.assertEqual(cfv.value, data['field_value'])
+
+            # Delete the stored value
+            cfv.value = data['empty_value']
+            cfv.save()
+            self.assertEqual(CustomFieldValue.objects.filter(obj_type=obj_type, obj_id=site.pk).count(), 0)
+
+            # Delete the custom field
+            cf.delete()
+
+    def test_select_field(self):
+
+        obj_type = ContentType.objects.get_for_model(Site)
+
+        # Create a custom field
+        cf = CustomField(type=CF_TYPE_SELECT, name='my_field', required=False)
+        cf.save()
+        cf.obj_type = [obj_type]
+        cf.save()
+
+        # Create some choices for the field
+        CustomFieldChoice.objects.bulk_create([
+            CustomFieldChoice(field=cf, value='Option A'),
+            CustomFieldChoice(field=cf, value='Option B'),
+            CustomFieldChoice(field=cf, value='Option C'),
+        ])
+
+        # Assign a value to the first Site
+        site = Site.objects.first()
+        cfv = CustomFieldValue(field=cf, obj_type=obj_type, obj_id=site.id)
+        cfv.value = cf.choices.first()
+        cfv.save()
+
+        # Retrieve the stored value
+        cfv = CustomFieldValue.objects.filter(obj_type=obj_type, obj_id=site.pk).first()
+        self.assertEqual(str(cfv.value), 'Option A')
+
+        # Delete the stored value
+        cfv.value = None
+        cfv.save()
+        self.assertEqual(CustomFieldValue.objects.filter(obj_type=obj_type, obj_id=site.pk).count(), 0)
+
+        # Delete the custom field
+        cf.delete()

netbox/ipam/admin.py

@@ -1,13 +1,18 @@
 from django.contrib import admin
 
 from .models import (
-    Aggregate, IPAddress, Prefix, RIR, Role, VLAN, VRF,
+    Aggregate, IPAddress, Prefix, RIR, Role, VLAN, VLANGroup, VRF,
 )
 
 
 @admin.register(VRF)
 class VRFAdmin(admin.ModelAdmin):
-    list_display = ['name', 'rd']
+    list_display = ['name', 'rd', 'tenant', 'enforce_unique']
+    list_filter = ['tenant']
+
+    def get_queryset(self, request):
+        qs = super(VRFAdmin, self).get_queryset(request)
+        return qs.select_related('tenant')
 
 
 @admin.register(Role)
@@ -23,7 +28,7 @@ class RIRAdmin(admin.ModelAdmin):
     prepopulated_fields = {
         'slug': ['name'],
     }
-    list_display = ['name', 'slug']
+    list_display = ['name', 'slug', 'is_private']
 
 
 @admin.register(Aggregate)
@@ -35,7 +40,7 @@ class AggregateAdmin(admin.ModelAdmin):
 
 @admin.register(Prefix)
 class PrefixAdmin(admin.ModelAdmin):
-    list_display = ['prefix', 'vrf', 'site', 'status', 'role', 'vlan']
+    list_display = ['prefix', 'vrf', 'tenant', 'site', 'status', 'role', 'vlan']
     list_filter = ['family', 'site', 'status', 'role']
     search_fields = ['prefix']
 
@@ -46,7 +51,7 @@ class PrefixAdmin(admin.ModelAdmin):
 
 @admin.register(IPAddress)
 class IPAddressAdmin(admin.ModelAdmin):
-    list_display = ['address', 'vrf', 'nat_inside']
+    list_display = ['address', 'vrf', 'tenant', 'nat_inside']
     list_filter = ['family']
     fields = ['address', 'vrf', 'device', 'interface', 'nat_inside']
     readonly_fields = ['interface', 'device', 'nat_inside']
@@ -57,12 +62,20 @@ class IPAddressAdmin(admin.ModelAdmin):
         return qs.select_related('vrf', 'nat_inside')
 
 
+@admin.register(VLANGroup)
+class VLANGroupAdmin(admin.ModelAdmin):
+    list_display = ['name', 'site', 'slug']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
 @admin.register(VLAN)
 class VLANAdmin(admin.ModelAdmin):
-    list_display = ['site', 'vid', 'name', 'status', 'role']
-    list_filter = ['site', 'status', 'role']
+    list_display = ['site', 'vid', 'name', 'tenant', 'status', 'role']
+    list_filter = ['site', 'tenant', 'status', 'role']
     search_fields = ['vid', 'name']
 
     def get_queryset(self, request):
         qs = super(VLANAdmin, self).get_queryset(request)
-        return qs.select_related('site', 'role')
+        return qs.select_related('site', 'tenant', 'role')

netbox/ipam/api/serializers.py

@@ -1,18 +1,21 @@
 from rest_framework import serializers
 
 from dcim.api.serializers import SiteNestedSerializer, InterfaceNestedSerializer
-from ipam.models import VRF, Role, RIR, Aggregate, Prefix, IPAddress, VLAN
+from extras.api.serializers import CustomFieldSerializer
+from ipam.models import VRF, Role, RIR, Aggregate, Prefix, IPAddress, VLAN, VLANGroup
+from tenancy.api.serializers import TenantNestedSerializer
 
 
 #
 # VRFs
 #
 
-class VRFSerializer(serializers.ModelSerializer):
+class VRFSerializer(CustomFieldSerializer, serializers.ModelSerializer):
+    tenant = TenantNestedSerializer()
 
     class Meta:
         model = VRF
-        fields = ['id', 'name', 'rd', 'description']
+        fields = ['id', 'name', 'rd', 'tenant', 'enforce_unique', 'description', 'custom_fields']
 
 
 class VRFNestedSerializer(VRFSerializer):
@@ -21,6 +24,15 @@ class VRFNestedSerializer(VRFSerializer):
         fields = ['id', 'name', 'rd']
 
 
+class VRFTenantSerializer(VRFSerializer):
+    """
+    Include tenant serializer. Useful for determining tenant inheritance for Prefixes and IPAddresses.
+    """
+
+    class Meta(VRFSerializer.Meta):
+        fields = ['id', 'name', 'rd', 'tenant']
+
+
 #
 # Roles
 #
@@ -46,25 +58,25 @@ class RIRSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = RIR
-        fields = ['id', 'name', 'slug']
+        fields = ['id', 'name', 'slug', 'is_private']
 
 
 class RIRNestedSerializer(RIRSerializer):
 
     class Meta(RIRSerializer.Meta):
-        pass
+        fields = ['id', 'name', 'slug']
 
 
 #
 # Aggregates
 #
 
-class AggregateSerializer(serializers.ModelSerializer):
+class AggregateSerializer(CustomFieldSerializer, serializers.ModelSerializer):
     rir = RIRNestedSerializer()
 
     class Meta:
         model = Aggregate
-        fields = ['id', 'family', 'prefix', 'rir', 'date_added', 'description']
+        fields = ['id', 'family', 'prefix', 'rir', 'date_added', 'description', 'custom_fields']
 
 
 class AggregateNestedSerializer(AggregateSerializer):
@@ -73,17 +85,38 @@ class AggregateNestedSerializer(AggregateSerializer):
         fields = ['id', 'family', 'prefix']
 
 
+#
+# VLAN groups
+#
+
+class VLANGroupSerializer(serializers.ModelSerializer):
+    site = SiteNestedSerializer()
+
+    class Meta:
+        model = VLANGroup
+        fields = ['id', 'name', 'slug', 'site']
+
+
+class VLANGroupNestedSerializer(VLANGroupSerializer):
+
+    class Meta(VLANGroupSerializer.Meta):
+        fields = ['id', 'name', 'slug']
+
+
 #
 # VLANs
 #
 
-class VLANSerializer(serializers.ModelSerializer):
+class VLANSerializer(CustomFieldSerializer, serializers.ModelSerializer):
     site = SiteNestedSerializer()
+    group = VLANGroupNestedSerializer()
+    tenant = TenantNestedSerializer()
     role = RoleNestedSerializer()
 
     class Meta:
         model = VLAN
-        fields = ['id', 'site', 'vid', 'name', 'status', 'role', 'display_name']
+        fields = ['id', 'site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description', 'display_name',
+                  'custom_fields']
 
 
 class VLANNestedSerializer(VLANSerializer):
@@ -96,15 +129,17 @@ class VLANNestedSerializer(VLANSerializer):
 # Prefixes
 #
 
-class PrefixSerializer(serializers.ModelSerializer):
+class PrefixSerializer(CustomFieldSerializer, serializers.ModelSerializer):
     site = SiteNestedSerializer()
-    vrf = VRFNestedSerializer()
+    vrf = VRFTenantSerializer()
+    tenant = TenantNestedSerializer()
     vlan = VLANNestedSerializer()
     role = RoleNestedSerializer()
 
     class Meta:
         model = Prefix
-        fields = ['id', 'family', 'prefix', 'site', 'vrf', 'vlan', 'status', 'role', 'description']
+        fields = ['id', 'family', 'prefix', 'site', 'vrf', 'tenant', 'vlan', 'status', 'role', 'description',
+                  'custom_fields']
 
 
 class PrefixNestedSerializer(PrefixSerializer):
@@ -117,13 +152,15 @@ class PrefixNestedSerializer(PrefixSerializer):
 # IP addresses
 #
 
-class IPAddressSerializer(serializers.ModelSerializer):
-    vrf = VRFNestedSerializer()
+class IPAddressSerializer(CustomFieldSerializer, serializers.ModelSerializer):
+    vrf = VRFTenantSerializer()
+    tenant = TenantNestedSerializer()
     interface = InterfaceNestedSerializer()
 
     class Meta:
         model = IPAddress
-        fields = ['id', 'family', 'address', 'vrf', 'interface', 'description', 'nat_inside', 'nat_outside']
+        fields = ['id', 'family', 'address', 'vrf', 'tenant', 'status', 'interface', 'description', 'nat_inside',
+                  'nat_outside', 'custom_fields']
 
 
 class IPAddressNestedSerializer(IPAddressSerializer):

netbox/ipam/api/urls.py

@@ -29,6 +29,10 @@ urlpatterns = [
     url(r'^ip-addresses/$', IPAddressListView.as_view(), name='ipaddress_list'),
     url(r'^ip-addresses/(?P<pk>\d+)/$', IPAddressDetailView.as_view(), name='ipaddress_detail'),
 
+    # VLAN groups
+    url(r'^vlan-groups/$', VLANGroupListView.as_view(), name='vlangroup_list'),
+    url(r'^vlan-groups/(?P<pk>\d+)/$', VLANGroupDetailView.as_view(), name='vlangroup_detail'),
+
     # VLANs
     url(r'^vlans/$', VLANListView.as_view(), name='vlan_list'),
     url(r'^vlans/(?P<pk>\d+)/$', VLANDetailView.as_view(), name='vlan_detail'),

netbox/ipam/api/views.py

@@ -1,28 +1,37 @@
 from rest_framework import generics
 
-from ipam.models import VRF, Role, RIR, Aggregate, Prefix, IPAddress, VLAN
-from ipam.filters import AggregateFilter, PrefixFilter, IPAddressFilter, VLANFilter, VRFFilter
+from ipam.models import VRF, Role, RIR, Aggregate, Prefix, IPAddress, VLAN, VLANGroup
+from ipam import filters
 
+from extras.api.views import CustomFieldModelAPIView
 from . import serializers
 
 
-class VRFListView(generics.ListAPIView):
+#
+# VRFs
+#
+
+class VRFListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List all VRFs
     """
-    queryset = VRF.objects.all()
+    queryset = VRF.objects.select_related('tenant').prefetch_related('custom_field_values__field')
     serializer_class = serializers.VRFSerializer
-    filter_class = VRFFilter
+    filter_class = filters.VRFFilter
 
 
-class VRFDetailView(generics.RetrieveAPIView):
+class VRFDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single VRF
     """
-    queryset = VRF.objects.all()
+    queryset = VRF.objects.select_related('tenant').prefetch_related('custom_field_values__field')
     serializer_class = serializers.VRFSerializer
 
 
+#
+# Roles
+#
+
 class RoleListView(generics.ListAPIView):
     """
     List all roles
@@ -39,6 +48,10 @@ class RoleDetailView(generics.RetrieveAPIView):
     serializer_class = serializers.RoleSerializer
 
 
+#
+# RIRs
+#
+
 class RIRListView(generics.ListAPIView):
     """
     List all RIRs
@@ -55,71 +68,112 @@ class RIRDetailView(generics.RetrieveAPIView):
     serializer_class = serializers.RIRSerializer
 
 
-class AggregateListView(generics.ListAPIView):
+#
+# Aggregates
+#
+
+class AggregateListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List aggregates (filterable)
     """
-    queryset = Aggregate.objects.select_related('rir')
+    queryset = Aggregate.objects.select_related('rir').prefetch_related('custom_field_values__field')
     serializer_class = serializers.AggregateSerializer
-    filter_class = AggregateFilter
+    filter_class = filters.AggregateFilter
 
 
-class AggregateDetailView(generics.RetrieveAPIView):
+class AggregateDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single aggregate
     """
-    queryset = Aggregate.objects.select_related('rir')
+    queryset = Aggregate.objects.select_related('rir').prefetch_related('custom_field_values__field')
     serializer_class = serializers.AggregateSerializer
 
 
-class PrefixListView(generics.ListAPIView):
+#
+# Prefixes
+#
+
+class PrefixListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List prefixes (filterable)
     """
-    queryset = Prefix.objects.select_related('site', 'vrf', 'vlan', 'role')
+    queryset = Prefix.objects.select_related('site', 'vrf__tenant', 'tenant', 'vlan', 'role')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.PrefixSerializer
-    filter_class = PrefixFilter
+    filter_class = filters.PrefixFilter
 
 
-class PrefixDetailView(generics.RetrieveAPIView):
+class PrefixDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single prefix
     """
-    queryset = Prefix.objects.select_related('site', 'vrf', 'vlan', 'role')
+    queryset = Prefix.objects.select_related('site', 'vrf__tenant', 'tenant', 'vlan', 'role')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.PrefixSerializer
 
 
-class IPAddressListView(generics.ListAPIView):
+#
+# IP addresses
+#
+
+class IPAddressListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List IP addresses (filterable)
     """
-    queryset = IPAddress.objects.select_related('vrf', 'interface__device', 'nat_inside')\
-        .prefetch_related('nat_outside')
+    queryset = IPAddress.objects.select_related('vrf__tenant', 'tenant', 'interface__device', 'nat_inside')\
+        .prefetch_related('nat_outside', 'custom_field_values__field')
     serializer_class = serializers.IPAddressSerializer
-    filter_class = IPAddressFilter
+    filter_class = filters.IPAddressFilter
 
 
-class IPAddressDetailView(generics.RetrieveAPIView):
+class IPAddressDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single IP address
     """
-    queryset = IPAddress.objects.select_related('vrf', 'interface__device', 'nat_inside')\
-        .prefetch_related('nat_outside')
+    queryset = IPAddress.objects.select_related('vrf__tenant', 'tenant', 'interface__device', 'nat_inside')\
+        .prefetch_related('nat_outside', 'custom_field_values__field')
     serializer_class = serializers.IPAddressSerializer
 
 
-class VLANListView(generics.ListAPIView):
+#
+# VLAN groups
+#
+
+class VLANGroupListView(generics.ListAPIView):
+    """
+    List all VLAN groups
+    """
+    queryset = VLANGroup.objects.select_related('site')
+    serializer_class = serializers.VLANGroupSerializer
+    filter_class = filters.VLANGroupFilter
+
+
+class VLANGroupDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single VLAN group
+    """
+    queryset = VLANGroup.objects.select_related('site')
+    serializer_class = serializers.VLANGroupSerializer
+
+
+#
+# VLANs
+#
+
+class VLANListView(CustomFieldModelAPIView, generics.ListAPIView):
     """
     List VLANs (filterable)
     """
-    queryset = VLAN.objects.select_related('site', 'role')
+    queryset = VLAN.objects.select_related('site', 'group', 'tenant', 'role')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.VLANSerializer
-    filter_class = VLANFilter
+    filter_class = filters.VLANFilter
 
 
-class VLANDetailView(generics.RetrieveAPIView):
+class VLANDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
     Retrieve a single VLAN
     """
-    queryset = VLAN.objects.select_related('site', 'role')
+    queryset = VLAN.objects.select_related('site', 'group', 'tenant', 'role')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.VLANSerializer

netbox/ipam/fields.py

@@ -10,6 +10,11 @@ from .lookups import (
 )
 
 
+def prefix_validator(prefix):
+    if prefix.ip != prefix.cidr.ip:
+        raise ValidationError("{} is not a valid prefix. Did you mean {}?".format(prefix, prefix.cidr))
+
+
 class BaseIPField(models.Field):
 
     def python_type(self):
@@ -45,6 +50,7 @@ class IPNetworkField(BaseIPField):
     IP prefix (network and mask)
     """
     description = "PostgreSQL CIDR field"
+    default_validators = [prefix_validator]
 
     def db_type(self, connection):
         return 'cidr'

netbox/ipam/filters.py

@@ -2,24 +2,62 @@ import django_filters
 from netaddr import IPNetwork
 from netaddr.core import AddrFormatError
 
+from django.db.models import Q
+
 from dcim.models import Site, Device, Interface
+from extras.filters import CustomFieldFilterSet
+from tenancy.models import Tenant
+from utilities.filters import NullableModelMultipleChoiceFilter
 
-from .models import RIR, Aggregate, VRF, Prefix, IPAddress, VLAN, Role
+from .models import RIR, Aggregate, VRF, Prefix, IPAddress, VLAN, VLANGroup, Role
 
 
-class VRFFilter(django_filters.FilterSet):
+class VRFFilter(CustomFieldFilterSet, django_filters.FilterSet):
+    q = django_filters.MethodFilter(
+        action='search',
+        label='Search',
+    )
     name = django_filters.CharFilter(
         name='name',
         lookup_type='icontains',
         label='Name',
     )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
+
+    def search(self, queryset, value):
+        return queryset.filter(
+            Q(name__icontains=value) |
+            Q(rd__icontains=value) |
+            Q(description__icontains=value)
+        )
 
     class Meta:
         model = VRF
         fields = ['name', 'rd']
 
 
-class AggregateFilter(django_filters.FilterSet):
+class RIRFilter(django_filters.FilterSet):
+
+    class Meta:
+        model = RIR
+        fields = ['is_private']
+
+
+class AggregateFilter(CustomFieldFilterSet, django_filters.FilterSet):
+    q = django_filters.MethodFilter(
+        action='search',
+        label='Search',
+    )
     rir_id = django_filters.ModelMultipleChoiceFilter(
         name='rir',
         queryset=RIR.objects.all(),
@@ -36,8 +74,17 @@ class AggregateFilter(django_filters.FilterSet):
         model = Aggregate
         fields = ['family', 'rir_id', 'rir', 'date_added']
 
+    def search(self, queryset, value):
+        qs_filter = Q(description__icontains=value)
+        try:
+            prefix = str(IPNetwork(value.strip()).cidr)
+            qs_filter |= Q(prefix__net_contains_or_equals=prefix)
+        except AddrFormatError:
+            pass
+        return queryset.filter(qs_filter)
 
-class PrefixFilter(django_filters.FilterSet):
+
+class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
     q = django_filters.MethodFilter(
         action='search',
         label='Search',
@@ -46,21 +93,34 @@ class PrefixFilter(django_filters.FilterSet):
         action='search_by_parent',
         label='Parent prefix',
     )
-    vrf = django_filters.MethodFilter(
-        action='_vrf',
+    vrf_id = NullableModelMultipleChoiceFilter(
+        name='vrf_id',
+        queryset=VRF.objects.all(),
         label='VRF',
     )
-    # Duplicate of `vrf` for backward-compatibility
-    vrf_id = django_filters.MethodFilter(
-        action='_vrf',
-        label='VRF',
+    vrf = NullableModelMultipleChoiceFilter(
+        name='vrf',
+        queryset=VRF.objects.all(),
+        to_field_name='rd',
+        label='VRF (RD)',
     )
-    site_id = django_filters.ModelMultipleChoiceFilter(
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
+    site_id = NullableModelMultipleChoiceFilter(
         name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
-    site = django_filters.ModelMultipleChoiceFilter(
+    site = NullableModelMultipleChoiceFilter(
         name='site',
         queryset=Site.objects.all(),
         to_field_name='slug',
@@ -75,12 +135,12 @@ class PrefixFilter(django_filters.FilterSet):
         name='vlan__vid',
         label='VLAN number (1-4095)',
     )
-    role_id = django_filters.ModelMultipleChoiceFilter(
+    role_id = NullableModelMultipleChoiceFilter(
         name='role',
         queryset=Role.objects.all(),
         label='Role (ID)',
     )
-    role = django_filters.ModelMultipleChoiceFilter(
+    role = NullableModelMultipleChoiceFilter(
         name='role',
         queryset=Role.objects.all(),
         to_field_name='slug',
@@ -89,15 +149,16 @@ class PrefixFilter(django_filters.FilterSet):
 
     class Meta:
         model = Prefix
-        fields = ['family', 'site_id', 'site', 'vrf', 'vrf_id', 'vlan_id', 'vlan_vid', 'status', 'role_id', 'role']
+        fields = ['family', 'site_id', 'site', 'vlan_id', 'vlan_vid', 'status', 'role_id', 'role']
 
     def search(self, queryset, value):
-        value = value.strip()
+        qs_filter = Q(description__icontains=value)
         try:
-            query = str(IPNetwork(value).cidr)
-            return queryset.filter(prefix__net_contains_or_equals=query)
+            prefix = str(IPNetwork(value.strip()).cidr)
+            qs_filter |= Q(prefix__net_contains_or_equals=prefix)
         except AddrFormatError:
-            return queryset.none()
+            pass
+        return queryset.filter(qs_filter)
 
     def search_by_parent(self, queryset, value):
         value = value.strip()
@@ -109,31 +170,55 @@ class PrefixFilter(django_filters.FilterSet):
         except AddrFormatError:
             return queryset.none()
 
-    def _vrf(self, queryset, value):
+    def _tenant(self, queryset, value):
         if str(value) == '':
             return queryset
+        return queryset.filter(
+            Q(tenant__slug=value) |
+            Q(tenant__isnull=True, vrf__tenant__slug=value)
+        )
+
+    def _tenant_id(self, queryset, value):
         try:
-            vrf_id = int(value)
+            value = int(value)
         except ValueError:
             return queryset.none()
-        if vrf_id == 0:
-            return queryset.filter(vrf__isnull=True)
-        return queryset.filter(vrf__pk=value)
+        return queryset.filter(
+            Q(tenant__pk=value) |
+            Q(tenant__isnull=True, vrf__tenant__pk=value)
+        )
 
 
-class IPAddressFilter(django_filters.FilterSet):
+class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
     q = django_filters.MethodFilter(
         action='search',
         label='Search',
     )
-    vrf = django_filters.MethodFilter(
-        action='_vrf',
+    parent = django_filters.MethodFilter(
+        action='search_by_parent',
+        label='Parent prefix',
+    )
+    vrf_id = NullableModelMultipleChoiceFilter(
+        name='vrf_id',
+        queryset=VRF.objects.all(),
         label='VRF',
     )
-    # Duplicate of `vrf` for backward-compatibility
-    vrf_id = django_filters.MethodFilter(
-        action='_vrf',
-        label='VRF',
+    vrf = NullableModelMultipleChoiceFilter(
+        name='vrf',
+        queryset=VRF.objects.all(),
+        to_field_name='rd',
+        label='VRF (RD)',
+    )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
     )
     device_id = django_filters.ModelMultipleChoiceFilter(
         name='interface__device',
@@ -154,29 +239,29 @@ class IPAddressFilter(django_filters.FilterSet):
 
     class Meta:
         model = IPAddress
-        fields = ['q', 'family', 'vrf_id', 'vrf', 'device_id', 'device', 'interface_id']
+        fields = ['q', 'family', 'status', 'device_id', 'device', 'interface_id']
 
     def search(self, queryset, value):
-        value = value.strip()
+        qs_filter = Q(description__icontains=value)
         try:
-            query = str(IPNetwork(value))
-            return queryset.filter(address__net_host=query)
+            ipaddress = str(IPNetwork(value.strip()))
+            qs_filter |= Q(address__net_host=ipaddress)
+        except AddrFormatError:
+            pass
+        return queryset.filter(qs_filter)
+
+    def search_by_parent(self, queryset, value):
+        value = value.strip()
+        if not value:
+            return queryset
+        try:
+            query = str(IPNetwork(value).cidr)
+            return queryset.filter(address__net_contained_or_equal=query)
         except AddrFormatError:
             return queryset.none()
 
-    def _vrf(self, queryset, value):
-        if str(value) == '':
-            return queryset
-        try:
-            vrf_id = int(value)
-        except ValueError:
-            return queryset.none()
-        if vrf_id == 0:
-            return queryset.filter(vrf__isnull=True)
-        return queryset.filter(vrf__pk=value)
 
-
-class VLANFilter(django_filters.FilterSet):
+class VLANGroupFilter(django_filters.FilterSet):
     site_id = django_filters.ModelMultipleChoiceFilter(
         name='site',
         queryset=Site.objects.all(),
@@ -188,6 +273,39 @@ class VLANFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Site (slug)',
     )
+
+    class Meta:
+        model = VLANGroup
+        fields = ['site_id', 'site']
+
+
+class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
+    q = django_filters.MethodFilter(
+        action='search',
+        label='Search',
+    )
+    site_id = django_filters.ModelMultipleChoiceFilter(
+        name='site',
+        queryset=Site.objects.all(),
+        label='Site (ID)',
+    )
+    site = django_filters.ModelMultipleChoiceFilter(
+        name='site',
+        queryset=Site.objects.all(),
+        to_field_name='slug',
+        label='Site (slug)',
+    )
+    group_id = NullableModelMultipleChoiceFilter(
+        name='group',
+        queryset=VLANGroup.objects.all(),
+        label='Group (ID)',
+    )
+    group = NullableModelMultipleChoiceFilter(
+        name='group',
+        queryset=VLANGroup.objects.all(),
+        to_field_name='slug',
+        label='Group',
+    )
     name = django_filters.CharFilter(
         name='name',
         lookup_type='icontains',
@@ -197,12 +315,23 @@ class VLANFilter(django_filters.FilterSet):
         name='vid',
         label='VLAN number (1-4095)',
     )
-    role_id = django_filters.ModelMultipleChoiceFilter(
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
+    role_id = NullableModelMultipleChoiceFilter(
         name='role',
         queryset=Role.objects.all(),
         label='Role (ID)',
     )
-    role = django_filters.ModelMultipleChoiceFilter(
+    role = NullableModelMultipleChoiceFilter(
         name='role',
         queryset=Role.objects.all(),
         to_field_name='slug',
@@ -212,3 +341,11 @@ class VLANFilter(django_filters.FilterSet):
     class Meta:
         model = VLAN
         fields = ['site_id', 'site', 'vid', 'name', 'status', 'role_id', 'role']
+
+    def search(self, queryset, value):
+        qs_filter = Q(name__icontains=value) | Q(description__icontains=value)
+        try:
+            qs_filter |= Q(vid=int(value))
+        except ValueError:
+            pass
+        return queryset.filter(qs_filter)

netbox/ipam/fixtures/initial_data.json

@@ -0,0 +1,131 @@
+[
+{
+    "model": "ipam.aggregate",
+    "pk": 1,
+    "fields": {
+        "created": "2016-08-01",
+        "last_updated": "2016-08-01T15:22:20.938Z",
+        "family": 4,
+        "prefix": "10.0.0.0/8",
+        "rir": 6,
+        "date_added": null,
+        "description": "Private IPv4 space"
+    }
+},
+{
+    "model": "ipam.aggregate",
+    "pk": 2,
+    "fields": {
+        "created": "2016-08-01",
+        "last_updated": "2016-08-01T15:22:32.679Z",
+        "family": 4,
+        "prefix": "172.16.0.0/12",
+        "rir": 6,
+        "date_added": null,
+        "description": "Private IPv4 space"
+    }
+},
+{
+    "model": "ipam.aggregate",
+    "pk": 3,
+    "fields": {
+        "created": "2016-08-01",
+        "last_updated": "2016-08-01T15:22:42.289Z",
+        "family": 4,
+        "prefix": "192.168.0.0/16",
+        "rir": 6,
+        "date_added": null,
+        "description": "Private IPv4 space"
+    }
+},
+{
+    "model": "ipam.rir",
+    "pk": 1,
+    "fields": {
+        "name": "ARIN",
+        "slug": "arin",
+        "is_private": false
+    }
+},
+{
+    "model": "ipam.rir",
+    "pk": 2,
+    "fields": {
+        "name": "RIPE",
+        "slug": "ripe",
+        "is_private": false
+    }
+},
+{
+    "model": "ipam.rir",
+    "pk": 3,
+    "fields": {
+        "name": "APNIC",
+        "slug": "apnic",
+        "is_private": false
+    }
+},
+{
+    "model": "ipam.rir",
+    "pk": 4,
+    "fields": {
+        "name": "LACNIC",
+        "slug": "lacnic",
+        "is_private": false
+    }
+},
+{
+    "model": "ipam.rir",
+    "pk": 5,
+    "fields": {
+        "name": "AFRINIC",
+        "slug": "afrinic",
+        "is_private": false
+    }
+},
+{
+    "model": "ipam.rir",
+    "pk": 6,
+    "fields": {
+        "name": "RFC 1918",
+        "slug": "rfc-1918",
+        "is_private": true
+    }
+},
+{
+    "model": "ipam.role",
+    "pk": 1,
+    "fields": {
+        "name": "Production",
+        "slug": "production",
+        "weight": 1000
+    }
+},
+{
+    "model": "ipam.role",
+    "pk": 2,
+    "fields": {
+        "name": "Development",
+        "slug": "development",
+        "weight": 1000
+    }
+},
+{
+    "model": "ipam.role",
+    "pk": 3,
+    "fields": {
+        "name": "Management",
+        "slug": "management",
+        "weight": 1000
+    }
+},
+{
+    "model": "ipam.role",
+    "pk": 4,
+    "fields": {
+        "name": "Backup",
+        "slug": "backup",
+        "weight": 1000
+    }
+}
+]

netbox/ipam/forms.py

@@ -1,31 +1,35 @@
-from netaddr import IPNetwork
-
 from django import forms
 from django.db.models import Count
 
-from dcim.models import Site, Device, Interface
+from dcim.models import Site, Rack, Device, Interface
+from extras.forms import CustomFieldForm, CustomFieldBulkEditForm, CustomFieldFilterForm
+from tenancy.models import Tenant
 from utilities.forms import (
-    BootstrapMixin, ConfirmationForm, APISelect, Livesearch, CSVDataField, BulkImportForm, SlugField,
+    APISelect, BootstrapMixin, CSVDataField, BulkImportForm, FilterChoiceField, Livesearch, SlugField, add_blank_choice,
 )
 
 from .models import (
-    Aggregate, IPAddress, Prefix, PREFIX_STATUS_CHOICES, RIR, Role, VLAN, VLAN_STATUS_CHOICES, VRF,
+    Aggregate, IPAddress, IPADDRESS_STATUS_CHOICES, Prefix, PREFIX_STATUS_CHOICES, RIR, Role, VLAN, VLANGroup,
+    VLAN_STATUS_CHOICES, VRF,
 )
 
 
-FORM_PREFIX_STATUS_CHOICES = (('', '---------'),) + PREFIX_STATUS_CHOICES
-FORM_VLAN_STATUS_CHOICES = (('', '---------'),) + VLAN_STATUS_CHOICES
+IP_FAMILY_CHOICES = [
+    ('', 'All'),
+    (4, 'IPv4'),
+    (6, 'IPv6'),
+]
 
 
 #
 # VRFs
 #
 
-class VRFForm(forms.ModelForm, BootstrapMixin):
+class VRFForm(BootstrapMixin, CustomFieldForm):
 
     class Meta:
         model = VRF
-        fields = ['name', 'rd', 'description']
+        fields = ['name', 'rd', 'tenant', 'enforce_unique', 'description']
         labels = {
             'rd': "RD",
         }
@@ -35,23 +39,31 @@ class VRFForm(forms.ModelForm, BootstrapMixin):
 
 
 class VRFFromCSVForm(forms.ModelForm):
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
 
     class Meta:
         model = VRF
-        fields = ['name', 'rd', 'description']
+        fields = ['name', 'rd', 'tenant', 'enforce_unique', 'description']
 
 
 class VRFImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=VRFFromCSVForm)
 
 
-class VRFBulkEditForm(forms.Form, BootstrapMixin):
+class VRFBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=VRF.objects.all(), widget=forms.MultipleHiddenInput)
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
     description = forms.CharField(max_length=100, required=False)
 
+    class Meta:
+        nullable_fields = ['tenant', 'description']
 
-class VRFBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=VRF.objects.all(), widget=forms.MultipleHiddenInput)
+
+class VRFFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = VRF
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('vrfs')), to_field_name='slug',
+                               null_option=(0, None))
 
 
 #
@@ -63,18 +75,22 @@ class RIRForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = RIR
-        fields = ['name', 'slug']
+        fields = ['name', 'slug', 'is_private']
 
 
-class RIRBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=RIR.objects.all(), widget=forms.MultipleHiddenInput)
+class RIRFilterForm(forms.Form, BootstrapMixin):
+    is_private = forms.NullBooleanField(required=False, label='Private', widget=forms.Select(choices=[
+        ('', '---------'),
+        ('True', 'Yes'),
+        ('False', 'No'),
+    ]))
 
 
 #
 # Aggregates
 #
 
-class AggregateForm(forms.ModelForm, BootstrapMixin):
+class AggregateForm(BootstrapMixin, CustomFieldForm):
 
     class Meta:
         model = Aggregate
@@ -99,25 +115,21 @@ class AggregateImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=AggregateFromCSVForm)
 
 
-class AggregateBulkEditForm(forms.Form, BootstrapMixin):
+class AggregateBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Aggregate.objects.all(), widget=forms.MultipleHiddenInput)
     rir = forms.ModelChoiceField(queryset=RIR.objects.all(), required=False, label='RIR')
     date_added = forms.DateField(required=False)
-    description = forms.CharField(max_length=50, required=False)
+    description = forms.CharField(max_length=100, required=False)
+
+    class Meta:
+        nullable_fields = ['date_added', 'description']
 
 
-class AggregateBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Aggregate.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def aggregate_rir_choices():
-    rir_choices = RIR.objects.annotate(aggregate_count=Count('aggregates'))
-    return [(r.slug, '{} ({})'.format(r.name, r.aggregate_count)) for r in rir_choices]
-
-
-class AggregateFilterForm(forms.Form, BootstrapMixin):
-    rir = forms.MultipleChoiceField(required=False, choices=aggregate_rir_choices, label='RIR',
-                                    widget=forms.SelectMultiple(attrs={'size': 8}))
+class AggregateFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Aggregate
+    family = forms.ChoiceField(required=False, choices=IP_FAMILY_CHOICES, label='Address Family')
+    rir = FilterChoiceField(queryset=RIR.objects.annotate(filter_count=Count('aggregates')), to_field_name='slug',
+                            label='RIR')
 
 
 #
@@ -132,15 +144,11 @@ class RoleForm(forms.ModelForm, BootstrapMixin):
         fields = ['name', 'slug']
 
 
-class RoleBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Role.objects.all(), widget=forms.MultipleHiddenInput)
-
-
 #
 # Prefixes
 #
 
-class PrefixForm(forms.ModelForm, BootstrapMixin):
+class PrefixForm(BootstrapMixin, CustomFieldForm):
     site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, label='Site',
                                   widget=forms.Select(attrs={'filter-for': 'vlan'}))
     vlan = forms.ModelChoiceField(queryset=VLAN.objects.all(), required=False, label='VLAN',
@@ -149,7 +157,7 @@ class PrefixForm(forms.ModelForm, BootstrapMixin):
 
     class Meta:
         model = Prefix
-        fields = ['prefix', 'vrf', 'site', 'vlan', 'status', 'role', 'description']
+        fields = ['prefix', 'vrf', 'tenant', 'site', 'vlan', 'status', 'role', 'description']
         help_texts = {
             'prefix': "IPv4 or IPv6 network",
             'vrf': "VRF (if applicable)",
@@ -172,93 +180,100 @@ class PrefixForm(forms.ModelForm, BootstrapMixin):
         else:
             self.fields['vlan'].choices = []
 
-    def clean_prefix(self):
-        data = self.cleaned_data['prefix']
-        try:
-            prefix = IPNetwork(data)
-        except:
-            raise
-        if prefix.version == 4 and prefix.prefixlen == 32:
-            raise forms.ValidationError("Cannot create host addresses (/32) as prefixes. These should be IPv4 "
-                                        "addresses instead.")
-        elif prefix.version == 6 and prefix.prefixlen == 128:
-            raise forms.ValidationError("Cannot create host addresses (/128) as prefixes. These should be IPv6 "
-                                        "addresses instead.")
-        return data
-
 
 class PrefixFromCSVForm(forms.ModelForm):
     vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, to_field_name='rd',
                                  error_messages={'invalid_choice': 'VRF not found.'})
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
     site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, to_field_name='name',
                                   error_messages={'invalid_choice': 'Site not found.'})
+    vlan_group_name = forms.CharField(required=False)
+    vlan_vid = forms.IntegerField(required=False)
     status_name = forms.ChoiceField(choices=[(s[1], s[0]) for s in PREFIX_STATUS_CHOICES])
     role = forms.ModelChoiceField(queryset=Role.objects.all(), required=False, to_field_name='name',
                                   error_messages={'invalid_choice': 'Invalid role.'})
 
     class Meta:
         model = Prefix
-        fields = ['prefix', 'vrf', 'site', 'status_name', 'role', 'description']
+        fields = ['prefix', 'vrf', 'tenant', 'site', 'vlan_group_name', 'vlan_vid', 'status_name', 'role',
+                  'description']
+
+    def clean(self):
+
+        super(PrefixFromCSVForm, self).clean()
+
+        site = self.cleaned_data.get('site')
+        vlan_group_name = self.cleaned_data.get('vlan_group_name')
+        vlan_vid = self.cleaned_data.get('vlan_vid')
+
+        # Validate VLAN
+        vlan_group = None
+        if vlan_group_name:
+            try:
+                vlan_group = VLANGroup.objects.get(site=site, name=vlan_group_name)
+            except VLANGroup.DoesNotExist:
+                self.add_error('vlan_group_name', "Invalid VLAN group ({} - {}).".format(site, vlan_group_name))
+        if vlan_vid and vlan_group:
+            try:
+                self.instance.vlan = VLAN.objects.get(group=vlan_group, vid=vlan_vid)
+            except VLAN.DoesNotExist:
+                self.add_error('vlan_vid', "Invalid VLAN ID ({} - {}).".format(vlan_group, vlan_vid))
+        elif vlan_vid and site:
+            try:
+                self.instance.vlan = VLAN.objects.get(site=site, vid=vlan_vid)
+            except VLAN.MultipleObjectsReturned:
+                self.add_error('vlan_vid', "Multiple VLANs found ({} - VID {})".format(site, vlan_vid))
+        elif vlan_vid:
+            self.add_error('vlan_vid', "Must specify site and/or VLAN group when assigning a VLAN.")
 
     def save(self, *args, **kwargs):
-        m = super(PrefixFromCSVForm, self).save(commit=False)
+
         # Assign Prefix status by name
-        m.status = dict(self.fields['status_name'].choices)[self.cleaned_data['status_name']]
-        if kwargs.get('commit'):
-            m.save()
-        return m
+        self.instance.status = dict(self.fields['status_name'].choices)[self.cleaned_data['status_name']]
+
+        return super(PrefixFromCSVForm, self).save(*args, **kwargs)
 
 
 class PrefixImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=PrefixFromCSVForm)
 
 
-class PrefixBulkEditForm(forms.Form, BootstrapMixin):
+class PrefixBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Prefix.objects.all(), widget=forms.MultipleHiddenInput)
     site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False)
-    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, label='VRF',
-                                 help_text="Select the VRF to assign, or check below to remove VRF assignment")
-    vrf_global = forms.BooleanField(required=False, label='Set VRF to global')
-    status = forms.ChoiceField(choices=FORM_PREFIX_STATUS_CHOICES, required=False)
+    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, label='VRF')
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+    status = forms.ChoiceField(choices=add_blank_choice(PREFIX_STATUS_CHOICES), required=False)
     role = forms.ModelChoiceField(queryset=Role.objects.all(), required=False)
-    description = forms.CharField(max_length=50, required=False)
+    description = forms.CharField(max_length=100, required=False)
 
-
-class PrefixBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=Prefix.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def prefix_vrf_choices():
-    vrf_choices = [('', 'All'), (0, 'Global')]
-    vrf_choices += [(v.pk, v.name) for v in VRF.objects.all()]
-    return vrf_choices
-
-
-def prefix_site_choices():
-    site_choices = Site.objects.annotate(prefix_count=Count('prefixes'))
-    return [(s.slug, '{} ({})'.format(s.name, s.prefix_count)) for s in site_choices]
+    class Meta:
+        nullable_fields = ['site', 'vrf', 'tenant', 'role', 'description']
 
 
 def prefix_status_choices():
     status_counts = {}
     for status in Prefix.objects.values('status').annotate(count=Count('status')).order_by('status'):
         status_counts[status['status']] = status['count']
-    return [(s[0], '{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in PREFIX_STATUS_CHOICES]
+    return [(s[0], u'{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in PREFIX_STATUS_CHOICES]
 
 
-def prefix_role_choices():
-    role_choices = Role.objects.annotate(prefix_count=Count('prefixes'))
-    return [(r.slug, '{} ({})'.format(r.name, r.prefix_count)) for r in role_choices]
-
-
-class PrefixFilterForm(forms.Form, BootstrapMixin):
-    parent = forms.CharField(required=False, label='Search Within')
-    vrf = forms.ChoiceField(required=False, choices=prefix_vrf_choices, label='VRF')
-    status = forms.MultipleChoiceField(required=False, choices=prefix_status_choices)
-    site = forms.MultipleChoiceField(required=False, choices=prefix_site_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
-    role = forms.MultipleChoiceField(required=False, choices=prefix_role_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
+class PrefixFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = Prefix
+    parent = forms.CharField(required=False, label='Search Within', widget=forms.TextInput(attrs={
+        'placeholder': 'Network',
+    }))
+    family = forms.ChoiceField(required=False, choices=IP_FAMILY_CHOICES, label='Address Family')
+    vrf = FilterChoiceField(queryset=VRF.objects.annotate(filter_count=Count('prefixes')), to_field_name='rd',
+                            label='VRF', null_option=(0, 'Global'))
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('prefixes')), to_field_name='slug',
+                               null_option=(0, 'None'))
+    status = forms.MultipleChoiceField(choices=prefix_status_choices, required=False)
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('prefixes')), to_field_name='slug',
+                             null_option=(0, 'None'))
+    role = FilterChoiceField(queryset=Role.objects.annotate(filter_count=Count('prefixes')), to_field_name='slug',
+                             null_option=(0, 'None'))
     expand = forms.BooleanField(required=False, label='Expand prefix hierarchy')
 
 
@@ -266,25 +281,22 @@ class PrefixFilterForm(forms.Form, BootstrapMixin):
 # IP addresses
 #
 
-class IPAddressForm(forms.ModelForm, BootstrapMixin):
+class IPAddressForm(BootstrapMixin, CustomFieldForm):
     nat_site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, label='Site',
                                       widget=forms.Select(attrs={'filter-for': 'nat_device'}))
     nat_device = forms.ModelChoiceField(queryset=Device.objects.all(), required=False, label='Device',
                                         widget=APISelect(api_url='/api/dcim/devices/?site_id={{nat_site}}',
+                                                         display_field='display_name',
                                                          attrs={'filter-for': 'nat_inside'}))
     livesearch = forms.CharField(required=False, label='IP Address', widget=Livesearch(
         query_key='q', query_url='ipam-api:ipaddress_list', field_to_update='nat_inside', obj_label='address')
     )
-    nat_inside = forms.ModelChoiceField(queryset=IPAddress.objects.all(), required=False, label='NAT (Inside)',
-                                        widget=APISelect(api_url='/api/ipam/ip-addresses/?device_id={{nat_device}}',
-                                                         display_field='address'))
 
     class Meta:
         model = IPAddress
-        fields = ['address', 'vrf', 'nat_device', 'nat_inside', 'description']
-        help_texts = {
-            'address': "IPv4 or IPv6 address and mask",
-            'vrf': "VRF (if applicable)",
+        fields = ['address', 'vrf', 'tenant', 'status', 'nat_inside', 'description']
+        widgets = {
+            'nat_inside': APISelect(api_url='/api/ipam/ip-addresses/?device_id={{nat_device}}', display_field='address')
         }
 
     def __init__(self, *args, **kwargs):
@@ -327,9 +339,35 @@ class IPAddressForm(forms.ModelForm, BootstrapMixin):
                 self.fields['nat_inside'].choices = []
 
 
+class IPAddressAssignForm(BootstrapMixin, forms.Form):
+    site = forms.ModelChoiceField(queryset=Site.objects.all(), label='Site', required=False,
+                                  widget=forms.Select(attrs={'filter-for': 'rack'}))
+    rack = forms.ModelChoiceField(queryset=Rack.objects.all(), label='Rack', required=False,
+                                  widget=APISelect(api_url='/api/dcim/racks/?site_id={{site}}', display_field='display_name', attrs={'filter-for': 'device'}))
+    device = forms.ModelChoiceField(queryset=Device.objects.all(), label='Device', required=False,
+                                    widget=APISelect(api_url='/api/dcim/devices/?rack_id={{rack}}', display_field='display_name', attrs={'filter-for': 'interface'}))
+    livesearch = forms.CharField(required=False, label='Device', widget=Livesearch(
+        query_key='q', query_url='dcim-api:device_list', field_to_update='device')
+    )
+    interface = forms.ModelChoiceField(queryset=Interface.objects.all(), label='Interface',
+                                       widget=APISelect(api_url='/api/dcim/devices/{{device}}/interfaces/'))
+    set_as_primary = forms.BooleanField(label='Set as primary IP for device', required=False)
+
+    def __init__(self, *args, **kwargs):
+
+        super(IPAddressAssignForm, self).__init__(*args, **kwargs)
+
+        self.fields['rack'].choices = []
+        self.fields['device'].choices = []
+        self.fields['interface'].choices = []
+
+
 class IPAddressFromCSVForm(forms.ModelForm):
     vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, to_field_name='rd',
-                                 error_messages={'invalid_choice': 'Site not found.'})
+                                 error_messages={'invalid_choice': 'VRF not found.'})
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
+    status_name = forms.ChoiceField(choices=[(s[1], s[0]) for s in IPADDRESS_STATUS_CHOICES])
     device = forms.ModelChoiceField(queryset=Device.objects.all(), required=False, to_field_name='name',
                                     error_messages={'invalid_choice': 'Device not found.'})
     interface_name = forms.CharField(required=False)
@@ -337,7 +375,7 @@ class IPAddressFromCSVForm(forms.ModelForm):
 
     class Meta:
         model = IPAddress
-        fields = ['address', 'vrf', 'device', 'interface_name', 'is_primary', 'description']
+        fields = ['address', 'vrf', 'tenant', 'status_name', 'device', 'interface_name', 'is_primary', 'description']
 
     def clean(self):
 
@@ -360,7 +398,10 @@ class IPAddressFromCSVForm(forms.ModelForm):
         if is_primary and not device:
             self.add_error('is_primary', "No device specified; cannot set as primary IP")
 
-    def save(self, commit=True):
+    def save(self, *args, **kwargs):
+
+        # Assign status by name
+        self.instance.status = dict(self.fields['status_name'].choices)[self.cleaned_data['status_name']]
 
         # Set interface
         if self.cleaned_data['device'] and self.cleaned_data['interface_name']:
@@ -368,70 +409,116 @@ class IPAddressFromCSVForm(forms.ModelForm):
                                                             name=self.cleaned_data['interface_name'])
         # Set as primary for device
         if self.cleaned_data['is_primary']:
-            self.instance.primary_for = self.cleaned_data['device']
+            if self.instance.address.version == 4:
+                self.instance.primary_ip4_for = self.cleaned_data['device']
+            elif self.instance.address.version == 6:
+                self.instance.primary_ip6_for = self.cleaned_data['device']
 
-        return super(IPAddressFromCSVForm, self).save(commit=commit)
+        return super(IPAddressFromCSVForm, self).save(*args, **kwargs)
 
 
 class IPAddressImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=IPAddressFromCSVForm)
 
 
-class IPAddressBulkEditForm(forms.Form, BootstrapMixin):
+class IPAddressBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=IPAddress.objects.all(), widget=forms.MultipleHiddenInput)
-    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, label='VRF',
-                                 help_text="Select the VRF to assign, or check below to remove VRF assignment")
-    vrf_global = forms.BooleanField(required=False, label='Set VRF to global')
-    description = forms.CharField(max_length=50, required=False)
+    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, label='VRF')
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+    status = forms.ChoiceField(choices=add_blank_choice(IPADDRESS_STATUS_CHOICES), required=False)
+    description = forms.CharField(max_length=100, required=False)
+
+    class Meta:
+        nullable_fields = ['vrf', 'tenant', 'description']
 
 
-class IPAddressBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=IPAddress.objects.all(), widget=forms.MultipleHiddenInput)
+def ipaddress_status_choices():
+    status_counts = {}
+    for status in IPAddress.objects.values('status').annotate(count=Count('status')).order_by('status'):
+        status_counts[status['status']] = status['count']
+    return [(s[0], u'{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in IPADDRESS_STATUS_CHOICES]
 
 
-def ipaddress_family_choices():
-    return [('', 'All'), (4, 'IPv4'), (6, 'IPv6')]
+class IPAddressFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = IPAddress
+    parent = forms.CharField(required=False, label='Search Within', widget=forms.TextInput(attrs={
+        'placeholder': 'Prefix',
+    }))
+    family = forms.ChoiceField(required=False, choices=IP_FAMILY_CHOICES, label='Address Family')
+    vrf = FilterChoiceField(queryset=VRF.objects.annotate(filter_count=Count('ip_addresses')), to_field_name='rd',
+                            label='VRF', null_option=(0, 'Global'))
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('ip_addresses')),
+                               to_field_name='slug', null_option=(0, 'None'))
+    status = forms.MultipleChoiceField(choices=ipaddress_status_choices, required=False)
 
 
-def ipaddress_vrf_choices():
-    vrf_choices = [('', 'All'), (0, 'Global')]
-    vrf_choices += [(v.pk, v.name) for v in VRF.objects.all()]
-    return vrf_choices
+#
+# VLAN groups
+#
+
+class VLANGroupForm(forms.ModelForm, BootstrapMixin):
+    slug = SlugField()
+
+    class Meta:
+        model = VLANGroup
+        fields = ['site', 'name', 'slug']
 
 
-class IPAddressFilterForm(forms.Form, BootstrapMixin):
-    family = forms.ChoiceField(required=False, choices=ipaddress_family_choices, label='Address Family')
-    vrf = forms.ChoiceField(required=False, choices=ipaddress_vrf_choices, label='VRF')
+class VLANGroupFilterForm(forms.Form, BootstrapMixin):
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('vlan_groups')), to_field_name='slug')
 
 
 #
 # VLANs
 #
 
-class VLANForm(forms.ModelForm, BootstrapMixin):
+class VLANForm(BootstrapMixin, CustomFieldForm):
+    group = forms.ModelChoiceField(queryset=VLANGroup.objects.all(), required=False, label='Group', widget=APISelect(
+        api_url='/api/ipam/vlan-groups/?site_id={{site}}',
+    ))
 
     class Meta:
         model = VLAN
-        fields = ['site', 'vid', 'name', 'status', 'role']
+        fields = ['site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description']
         help_texts = {
             'site': "The site at which this VLAN exists",
+            'group': "VLAN group (optional)",
             'vid': "Configured VLAN ID",
             'name': "Configured VLAN name",
             'status': "Operational status of this VLAN",
             'role': "The primary function of this VLAN",
         }
+        widgets = {
+            'site': forms.Select(attrs={'filter-for': 'group'}),
+        }
+
+    def __init__(self, *args, **kwargs):
+
+        super(VLANForm, self).__init__(*args, **kwargs)
+
+        # Limit VLAN group choices
+        if self.is_bound and self.data.get('site'):
+            self.fields['group'].queryset = VLANGroup.objects.filter(site__pk=self.data['site'])
+        elif self.initial.get('site'):
+            self.fields['group'].queryset = VLANGroup.objects.filter(site=self.initial['site'])
+        else:
+            self.fields['group'].choices = []
 
 
 class VLANFromCSVForm(forms.ModelForm):
     site = forms.ModelChoiceField(queryset=Site.objects.all(), to_field_name='name',
-                                  error_messages={'invalid_choice': 'Device not found.'})
+                                  error_messages={'invalid_choice': 'Site not found.'})
+    group = forms.ModelChoiceField(queryset=VLANGroup.objects.all(), required=False, to_field_name='name',
+                                   error_messages={'invalid_choice': 'VLAN group not found.'})
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
     status_name = forms.ChoiceField(choices=[(s[1], s[0]) for s in VLAN_STATUS_CHOICES])
     role = forms.ModelChoiceField(queryset=Role.objects.all(), required=False, to_field_name='name',
                                   error_messages={'invalid_choice': 'Invalid role.'})
 
     class Meta:
         model = VLAN
-        fields = ['site', 'vid', 'name', 'status_name', 'role']
+        fields = ['site', 'group', 'vid', 'name', 'tenant', 'status_name', 'role', 'description']
 
     def save(self, *args, **kwargs):
         m = super(VLANFromCSVForm, self).save(commit=False)
@@ -446,37 +533,33 @@ class VLANImportForm(BulkImportForm, BootstrapMixin):
     csv = CSVDataField(csv_form=VLANFromCSVForm)
 
 
-class VLANBulkEditForm(forms.Form, BootstrapMixin):
+class VLANBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=VLAN.objects.all(), widget=forms.MultipleHiddenInput)
     site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False)
-    status = forms.ChoiceField(choices=FORM_VLAN_STATUS_CHOICES, required=False)
+    group = forms.ModelChoiceField(queryset=VLANGroup.objects.all(), required=False)
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+    status = forms.ChoiceField(choices=add_blank_choice(VLAN_STATUS_CHOICES), required=False)
     role = forms.ModelChoiceField(queryset=Role.objects.all(), required=False)
+    description = forms.CharField(max_length=100, required=False)
 
-
-class VLANBulkDeleteForm(ConfirmationForm):
-    pk = forms.ModelMultipleChoiceField(queryset=VLAN.objects.all(), widget=forms.MultipleHiddenInput)
-
-
-def vlan_site_choices():
-    site_choices = Site.objects.annotate(vlan_count=Count('vlans'))
-    return [(s.slug, '{} ({})'.format(s.name, s.vlan_count)) for s in site_choices]
+    class Meta:
+        nullable_fields = ['group', 'tenant', 'role', 'description']
 
 
 def vlan_status_choices():
     status_counts = {}
     for status in VLAN.objects.values('status').annotate(count=Count('status')).order_by('status'):
         status_counts[status['status']] = status['count']
-    return [(s[0], '{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in VLAN_STATUS_CHOICES]
+    return [(s[0], u'{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in VLAN_STATUS_CHOICES]
 
 
-def vlan_role_choices():
-    role_choices = Role.objects.annotate(vlan_count=Count('vlans'))
-    return [(r.slug, '{} ({})'.format(r.name, r.vlan_count)) for r in role_choices]
-
-
-class VLANFilterForm(forms.Form, BootstrapMixin):
-    site = forms.MultipleChoiceField(required=False, choices=vlan_site_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
-    status = forms.MultipleChoiceField(required=False, choices=vlan_status_choices)
-    role = forms.MultipleChoiceField(required=False, choices=vlan_role_choices,
-                                     widget=forms.SelectMultiple(attrs={'size': 8}))
+class VLANFilterForm(BootstrapMixin, CustomFieldFilterForm):
+    model = VLAN
+    site = FilterChoiceField(queryset=Site.objects.annotate(filter_count=Count('vlans')), to_field_name='slug')
+    group_id = FilterChoiceField(queryset=VLANGroup.objects.annotate(filter_count=Count('vlans')), label='VLAN group',
+                                 null_option=(0, 'None'))
+    tenant = FilterChoiceField(queryset=Tenant.objects.annotate(filter_count=Count('vlans')), to_field_name='slug',
+                               null_option=(0, 'None'))
+    status = forms.MultipleChoiceField(choices=vlan_status_choices, required=False)
+    role = FilterChoiceField(queryset=Role.objects.annotate(filter_count=Count('vlans')), to_field_name='slug',
+                             null_option=(0, 'None'))