Merge branch 'release/1.11.0'

* #304 Add editable service update configuration

* fix unable to use 0 for update-delay

* apply margin top to center help text

.gitignore

@@ -2,3 +2,4 @@ node_modules
 bower_components
 dist
 portainer-checksum.txt
+api/cmd/portainer/portainer*

CONTRIBUTING.md

@@ -6,8 +6,27 @@ Some basic conventions for contributing to this project.
 
 Please make sure that there aren't existing pull requests attempting to address the issue mentioned. Likewise, please check for issues related to update, as someone else may be working on the issue in a branch or fork.
 
-* Non-trivial changes should be discussed in an issue first
-* Develop in a topic branch, not master
+* Please open a discussion in a new issue / existing issue to talk about the changes you'd like to bring
+* Develop in a topic branch, not master/develop
+
+When creating a new branch, prefix it with the *type* of the change (see section **Commit Message Format** below), the associated opened issue number, a dash and some text describing the issue (using dash as a separator).
+
+For example, if you work on a bugfix for the issue #361, you could name the branch `fix361-template-selection`.
+
+### Issues open to contribution
+
+Want to contribute but don't know where to start?
+
+Some of the open issues are labeled with prefix `exp/`, this is used to mark them as available for contributors to work on. All of these have an attributed difficulty level:
+
+* **beginner**: a task that should be accessible with users not familiar with the codebase
+* **intermediate**: a task that require some understanding of the project codebase or some experience in
+either AngularJS or Golang
+
+You can have a use Github filters to list these issues:
+
+* beginner labeled issues: https://github.com/portainer/portainer/labels/exp%2Fbeginner
+* intermediate labeled issues: https://github.com/portainer/portainer/labels/exp%2Fintermediate
 
 ### Linting
 
@@ -47,6 +66,7 @@ Must be one of the following:
 
 The scope could be anything specifying place of the commit change. For example `networks`,
 `containers`, `images` etc...
+You can use the **area** label tag associated on the issue here (for `area/containers` use `containers` as a scope...)
 
 #### Subject
 

LICENSE

@@ -1,22 +1,22 @@
 Portainer: Copyright (c) 2016 Portainer.io
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+This software is provided 'as-is', without any express or implied
+warranty.  In no event will the authors be held liable for any damages
+arising from the use of this software.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+3. This notice may not be removed or altered from any source distribution.
+
+Portainer contains code which was originally under this license:
 
 UI For Docker: Copyright (c) 2013-2016 Michael Crosby (crosbymichael.com), Kevan Ahlquist (kevanahlquist.com), Anthony Lapenna (portainer.io)
 

README.md

@@ -1,79 +1,48 @@
-# Portainer
 
-The easiest way to manage Docker.
+<p align="center">
+  <img title="portainer" src='http://portainer.io/images/logo_alt.png' />
+</p>
 
 [![Microbadger version](https://images.microbadger.com/badges/version/portainer/portainer.svg)](https://microbadger.com/images/portainer/portainer "Latest version on Docker Hub")
 [![Microbadger](https://images.microbadger.com/badges/image/portainer/portainer.svg)](http://microbadger.com/images/portainer/portainer "Image size")
-[![Documentation Status](https://readthedocs.org/projects/portainer/badge/?version=stable)](http://portainer.readthedocs.io/en/stable/?badge=stable)
+[![Documentation Status](https://readthedocs.org/projects/portainer/badge/?version=stable)](http://portainer.readthedocs.io/en/latest/?badge=stable)
 [![Gitter](https://badges.gitter.im/portainer/Lobby.svg)](https://gitter.im/portainer/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=YHXZJQNJQ36H6)
 
-Portainer is a lightweight management UI which allows you to **easily** manage your Docker host or Swarm cluster.
+**_Portainer_** is a lightweight management UI which allows you to **easily** manage your Docker host or Swarm cluster.
 
-# Usage
+**_Portainer_** is meant to be as **simple** to deploy as it is to use. It consists of a single container that can run on any Docker engine (Docker for Linux and Docker for Windows are supported).
 
-It's really simple to deploy it using Docker:
+**_Portainer_** allows you to manage your Docker containers, images, volumes, networks and more ! It is compatible with the *standalone Docker* engine and with *Docker Swarm*.
 
-```shell
-$ docker run -d -p 9000:9000 portainer/portainer -H tcp://<DOCKER_HOST>:<DOCKER_PORT>
-```
+## Demo
 
-Just point it at your targeted Docker host and then access Portainer by hitting [http://localhost:9000](http://localhost:9000) with a web browser.
+<img src="http://portainer.io/images/screenshots/portainer.gif" width="77%"/>
 
-If your target is a Docker Swarm cluster or a Docker cluster using *swarm mode*, just add the flag `--swarm`:
+You can try out the public demo instance: http://demo.portainer.io/ (login with the username **demo** and the password **tryportainer**).
 
-```shell
-$ docker run -d -p 9000:9000 portainer/portainer -H tcp://<SWARM_HOST>:<SWARM_PORT> --swarm
-```
+Please note that the public demo cluster is **reset every 15min**.
 
-If you don't specify any target, its default behaviour is to use a bind mount on the Docker socket so you can easily deploy it to manage your local Docker host:
+## Getting started
 
-```shell
-$ docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer
-```
+* [Deploy Portainer](https://portainer.readthedocs.io/en/latest/deployment.html)
+* [Documentation](https://portainer.readthedocs.io)
 
-Have a look at our [documentation](http://portainer.readthedocs.io/en/stable/deployment.html) for more deployment options.
+## Getting help
 
-# Configuration
+* Issues: https://github.com/portainer/portainer/issues
+* FAQ: https://portainer.readthedocs.io/en/latest/faq.html
+* Gitter (chat): https://gitter.im/portainer/Lobby
+* Slack: http://portainer.io/slack/
 
-Portainer is easy to tune using CLI flags.
+## Reporting bugs and contributing
 
-## Hiding specific containers
+* Want to report a bug or request a feature? Please open [an issue](https://github.com/portainer/portainer/issues/new).
+* Want to help us build **_portainer_**? Follow our [contribution guidelines](https://portainer.readthedocs.io/en/latest/contribute.html) to build it  locally and make a pull request. We need all the help we can get!
 
-Portainer allows you to hide container with a specific label by using the `-l` flag.
+## Limitations
 
-For example, take a container started with the label `owner=acme`:
-```shell
-$ docker run -d --label owner=acme nginx
-```
-
-Simply add the `-l owner=acme` option on the CLI when starting Portainer:
-```shell
-$ docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer -l owner=acme
-```
-
-## Use your own templates
-
-Portainer allows you to rapidly deploy containers using `App Templates`.
-
-By default [Portainer templates](https://raw.githubusercontent.com/portainer/templates/master/templates.json) will be used but you can also define your own templates.
-
-Add the `--templates` flag and specify the external location of your templates when starting Portainer:
-
-```shell
-$ docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer --templates http://my-host.my-domain/templates.json
-```
-
-For more information about hosting your own template definitions and the format, see the [templates documentation](http://portainer.readthedocs.io/en/stable/templates.html).
-
-Check our [documentation](http://portainer.readthedocs.io/en/stable/configuration.html) for more configuration options.
-
-# FAQ
-
-Be sure to check our [FAQ](http://portainer.readthedocs.io/en/stable/faq.html) if you are missing some information.
-
-# Limitations
-
-Portainer has full support for the following Docker versions:
+**_Portainer_** has full support for the following Docker versions:
 
 * Docker 1.10 to Docker 1.12 (including `swarm-mode`)
 * Docker Swarm >= 1.2.3

api/api.go

@@ -1,60 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"log"
-	"net/http"
-	"net/url"
-)
-
-type (
-	api struct {
-		endpoint     *url.URL
-		bindAddress  string
-		assetPath    string
-		dataPath     string
-		tlsConfig    *tls.Config
-		templatesURL string
-	}
-
-	apiConfig struct {
-		Endpoint      string
-		BindAddress   string
-		AssetPath     string
-		DataPath      string
-		SwarmSupport  bool
-		TLSEnabled    bool
-		TLSCACertPath string
-		TLSCertPath   string
-		TLSKeyPath    string
-		TemplatesURL  string
-	}
-)
-
-func (a *api) run(settings *Settings) {
-	handler := a.newHandler(settings)
-	if err := http.ListenAndServe(a.bindAddress, handler); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func newAPI(apiConfig apiConfig) *api {
-	endpointURL, err := url.Parse(apiConfig.Endpoint)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var tlsConfig *tls.Config
-	if apiConfig.TLSEnabled {
-		tlsConfig = newTLSConfig(apiConfig.TLSCACertPath, apiConfig.TLSCertPath, apiConfig.TLSKeyPath)
-	}
-
-	return &api{
-		endpoint:     endpointURL,
-		bindAddress:  apiConfig.BindAddress,
-		assetPath:    apiConfig.AssetPath,
-		dataPath:     apiConfig.DataPath,
-		tlsConfig:    tlsConfig,
-		templatesURL: apiConfig.TemplatesURL,
-	}
-}

api/bolt/datastore.go

@@ -0,0 +1,72 @@
+package bolt
+
+import (
+	"time"
+
+	"github.com/boltdb/bolt"
+)
+
+// Store defines the implementation of portainer.DataStore using
+// BoltDB as the storage system.
+type Store struct {
+	// Path where is stored the BoltDB database.
+	Path string
+
+	// Services
+	UserService     *UserService
+	EndpointService *EndpointService
+
+	db *bolt.DB
+}
+
+const (
+	databaseFileName         = "portainer.db"
+	userBucketName           = "users"
+	endpointBucketName       = "endpoints"
+	activeEndpointBucketName = "activeEndpoint"
+)
+
+// NewStore initializes a new Store and the associated services
+func NewStore(storePath string) *Store {
+	store := &Store{
+		Path:            storePath,
+		UserService:     &UserService{},
+		EndpointService: &EndpointService{},
+	}
+	store.UserService.store = store
+	store.EndpointService.store = store
+	return store
+}
+
+// Open opens and initializes the BoltDB database.
+func (store *Store) Open() error {
+	path := store.Path + "/" + databaseFileName
+	db, err := bolt.Open(path, 0600, &bolt.Options{Timeout: 1 * time.Second})
+	if err != nil {
+		return err
+	}
+	store.db = db
+	return db.Update(func(tx *bolt.Tx) error {
+		_, err := tx.CreateBucketIfNotExists([]byte(userBucketName))
+		if err != nil {
+			return err
+		}
+		_, err = tx.CreateBucketIfNotExists([]byte(endpointBucketName))
+		if err != nil {
+			return err
+		}
+		_, err = tx.CreateBucketIfNotExists([]byte(activeEndpointBucketName))
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// Close closes the BoltDB database.
+func (store *Store) Close() error {
+	if store.db != nil {
+		return store.db.Close()
+	}
+	return nil
+}

api/bolt/endpoint_service.go

@@ -0,0 +1,162 @@
+package bolt
+
+import (
+	"github.com/portainer/portainer"
+	"github.com/portainer/portainer/bolt/internal"
+
+	"github.com/boltdb/bolt"
+)
+
+// EndpointService represents a service for managing users.
+type EndpointService struct {
+	store *Store
+}
+
+const (
+	activeEndpointID = 0
+)
+
+// Endpoint returns an endpoint by ID.
+func (service *EndpointService) Endpoint(ID portainer.EndpointID) (*portainer.Endpoint, error) {
+	var data []byte
+	err := service.store.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(endpointBucketName))
+		value := bucket.Get(internal.Itob(int(ID)))
+		if value == nil {
+			return portainer.ErrEndpointNotFound
+		}
+
+		data = make([]byte, len(value))
+		copy(data, value)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var endpoint portainer.Endpoint
+	err = internal.UnmarshalEndpoint(data, &endpoint)
+	if err != nil {
+		return nil, err
+	}
+	return &endpoint, nil
+}
+
+// Endpoints return an array containing all the endpoints.
+func (service *EndpointService) Endpoints() ([]portainer.Endpoint, error) {
+	var endpoints []portainer.Endpoint
+	err := service.store.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(endpointBucketName))
+
+		cursor := bucket.Cursor()
+		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
+			var endpoint portainer.Endpoint
+			err := internal.UnmarshalEndpoint(v, &endpoint)
+			if err != nil {
+				return err
+			}
+			endpoints = append(endpoints, endpoint)
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return endpoints, nil
+}
+
+// CreateEndpoint assign an ID to a new endpoint and saves it.
+func (service *EndpointService) CreateEndpoint(endpoint *portainer.Endpoint) error {
+	return service.store.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(endpointBucketName))
+
+		id, _ := bucket.NextSequence()
+		endpoint.ID = portainer.EndpointID(id)
+
+		data, err := internal.MarshalEndpoint(endpoint)
+		if err != nil {
+			return err
+		}
+
+		err = bucket.Put(internal.Itob(int(endpoint.ID)), data)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// UpdateEndpoint updates an endpoint.
+func (service *EndpointService) UpdateEndpoint(ID portainer.EndpointID, endpoint *portainer.Endpoint) error {
+	data, err := internal.MarshalEndpoint(endpoint)
+	if err != nil {
+		return err
+	}
+
+	return service.store.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(endpointBucketName))
+		err = bucket.Put(internal.Itob(int(ID)), data)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// DeleteEndpoint deletes an endpoint.
+func (service *EndpointService) DeleteEndpoint(ID portainer.EndpointID) error {
+	return service.store.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(endpointBucketName))
+		err := bucket.Delete(internal.Itob(int(ID)))
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+// GetActive returns the active endpoint.
+func (service *EndpointService) GetActive() (*portainer.Endpoint, error) {
+	var data []byte
+	err := service.store.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(activeEndpointBucketName))
+		value := bucket.Get(internal.Itob(activeEndpointID))
+		if value == nil {
+			return portainer.ErrEndpointNotFound
+		}
+
+		data = make([]byte, len(value))
+		copy(data, value)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var endpoint portainer.Endpoint
+	err = internal.UnmarshalEndpoint(data, &endpoint)
+	if err != nil {
+		return nil, err
+	}
+	return &endpoint, nil
+}
+
+// SetActive saves an endpoint as active.
+func (service *EndpointService) SetActive(endpoint *portainer.Endpoint) error {
+	return service.store.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(activeEndpointBucketName))
+
+		data, err := internal.MarshalEndpoint(endpoint)
+		if err != nil {
+			return err
+		}
+
+		err = bucket.Put(internal.Itob(activeEndpointID), data)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+}

api/bolt/internal/internal.go

@@ -0,0 +1,37 @@
+package internal
+
+import (
+	"github.com/portainer/portainer"
+
+	"encoding/binary"
+	"encoding/json"
+)
+
+// MarshalUser encodes a user to binary format.
+func MarshalUser(user *portainer.User) ([]byte, error) {
+	return json.Marshal(user)
+}
+
+// UnmarshalUser decodes a user from a binary data.
+func UnmarshalUser(data []byte, user *portainer.User) error {
+	return json.Unmarshal(data, user)
+}
+
+// MarshalEndpoint encodes an endpoint to binary format.
+func MarshalEndpoint(endpoint *portainer.Endpoint) ([]byte, error) {
+	return json.Marshal(endpoint)
+}
+
+// UnmarshalEndpoint decodes an endpoint from a binary data.
+func UnmarshalEndpoint(data []byte, endpoint *portainer.Endpoint) error {
+	return json.Unmarshal(data, endpoint)
+}
+
+// Itob returns an 8-byte big endian representation of v.
+// This function is typically used for encoding integer IDs to byte slices
+// so that they can be used as BoltDB keys.
+func Itob(v int) []byte {
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint64(b, uint64(v))
+	return b
+}

api/bolt/user_service.go

@@ -0,0 +1,56 @@
+package bolt
+
+import (
+	"github.com/portainer/portainer"
+	"github.com/portainer/portainer/bolt/internal"
+
+	"github.com/boltdb/bolt"
+)
+
+// UserService represents a service for managing users.
+type UserService struct {
+	store *Store
+}
+
+// User returns a user by username.
+func (service *UserService) User(username string) (*portainer.User, error) {
+	var data []byte
+	err := service.store.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(userBucketName))
+		value := bucket.Get([]byte(username))
+		if value == nil {
+			return portainer.ErrUserNotFound
+		}
+
+		data = make([]byte, len(value))
+		copy(data, value)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var user portainer.User
+	err = internal.UnmarshalUser(data, &user)
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+// UpdateUser saves a user.
+func (service *UserService) UpdateUser(user *portainer.User) error {
+	data, err := internal.MarshalUser(user)
+	if err != nil {
+		return err
+	}
+
+	return service.store.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(userBucketName))
+		err = bucket.Put([]byte(user.Username), data)
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+}

api/cli/cli.go

@@ -0,0 +1,61 @@
+package cli
+
+import (
+	"github.com/portainer/portainer"
+
+	"os"
+	"strings"
+
+	"gopkg.in/alecthomas/kingpin.v2"
+)
+
+// Service implements the CLIService interface
+type Service struct{}
+
+const (
+	errInvalidEnpointProtocol = portainer.Error("Invalid endpoint protocol: Portainer only supports unix:// or tcp://")
+	errSocketNotFound         = portainer.Error("Unable to locate Unix socket")
+)
+
+// ParseFlags parse the CLI flags and return a portainer.Flags struct
+func (*Service) ParseFlags(version string) (*portainer.CLIFlags, error) {
+	kingpin.Version(version)
+
+	flags := &portainer.CLIFlags{
+		Endpoint:  kingpin.Flag("host", "Dockerd endpoint").Short('H').String(),
+		Logo:      kingpin.Flag("logo", "URL for the logo displayed in the UI").String(),
+		Labels:    pairs(kingpin.Flag("hide-label", "Hide containers with a specific label in the UI").Short('l')),
+		Addr:      kingpin.Flag("bind", "Address and port to serve Portainer").Default(":9000").Short('p').String(),
+		Assets:    kingpin.Flag("assets", "Path to the assets").Default(".").Short('a').String(),
+		Data:      kingpin.Flag("data", "Path to the folder where the data is stored").Default("/data").Short('d').String(),
+		Templates: kingpin.Flag("templates", "URL to the templates (apps) definitions").Default("https://raw.githubusercontent.com/portainer/templates/master/templates.json").Short('t').String(),
+		TLSVerify: kingpin.Flag("tlsverify", "TLS support").Default("false").Bool(),
+		TLSCacert: kingpin.Flag("tlscacert", "Path to the CA").Default("/certs/ca.pem").String(),
+		TLSCert:   kingpin.Flag("tlscert", "Path to the TLS certificate file").Default("/certs/cert.pem").String(),
+		TLSKey:    kingpin.Flag("tlskey", "Path to the TLS key").Default("/certs/key.pem").String(),
+	}
+
+	kingpin.Parse()
+	return flags, nil
+}
+
+// ValidateFlags validates the values of the flags.
+func (*Service) ValidateFlags(flags *portainer.CLIFlags) error {
+	if *flags.Endpoint != "" {
+		if !strings.HasPrefix(*flags.Endpoint, "unix://") && !strings.HasPrefix(*flags.Endpoint, "tcp://") {
+			return errInvalidEnpointProtocol
+		}
+
+		if strings.HasPrefix(*flags.Endpoint, "unix://") {
+			socketPath := strings.TrimPrefix(*flags.Endpoint, "unix://")
+			if _, err := os.Stat(socketPath); err != nil {
+				if os.IsNotExist(err) {
+					return errSocketNotFound
+				}
+				return err
+			}
+		}
+	}
+
+	return nil
+}

api/cli/pairlist.go

@@ -1,46 +1,40 @@
-package main
+package cli
 
 import (
+	"github.com/portainer/portainer"
+
 	"fmt"
 	"gopkg.in/alecthomas/kingpin.v2"
 	"strings"
 )
 
-// pair defines a key/value pair
-type pair struct {
-	Name  string `json:"name"`
-	Value string `json:"value"`
-}
+type pairList []portainer.Pair
 
-// pairList defines an array of Label
-type pairList []pair
-
-// Set implementation for Labels
+// Set implementation for a list of portainer.Pair
 func (l *pairList) Set(value string) error {
 	parts := strings.SplitN(value, "=", 2)
 	if len(parts) != 2 {
 		return fmt.Errorf("expected NAME=VALUE got '%s'", value)
 	}
-	p := new(pair)
+	p := new(portainer.Pair)
 	p.Name = parts[0]
 	p.Value = parts[1]
 	*l = append(*l, *p)
 	return nil
 }
 
-// String implementation for Labels
+// String implementation for a list of pair
 func (l *pairList) String() string {
 	return ""
 }
 
-// IsCumulative implementation for Labels
+// IsCumulative implementation for a list of pair
 func (l *pairList) IsCumulative() bool {
 	return true
 }
 
-// LabelParser defines a custom parser for Labels flags
-func pairs(s kingpin.Settings) (target *[]pair) {
-	target = new([]pair)
+func pairs(s kingpin.Settings) (target *[]portainer.Pair) {
+	target = new([]portainer.Pair)
 	s.SetValue((*pairList)(target))
 	return
 }

api/cmd/portainer/main.go

@@ -0,0 +1,92 @@
+package main // import "github.com/portainer/portainer"
+
+import (
+	"github.com/portainer/portainer"
+	"github.com/portainer/portainer/bolt"
+	"github.com/portainer/portainer/cli"
+	"github.com/portainer/portainer/crypto"
+	"github.com/portainer/portainer/file"
+	"github.com/portainer/portainer/http"
+	"github.com/portainer/portainer/jwt"
+
+	"log"
+)
+
+func main() {
+	var cli portainer.CLIService = &cli.Service{}
+	flags, err := cli.ParseFlags(portainer.APIVersion)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	err = cli.ValidateFlags(flags)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	settings := &portainer.Settings{
+		HiddenLabels: *flags.Labels,
+		Logo:         *flags.Logo,
+	}
+
+	var store = bolt.NewStore(*flags.Data)
+	err = store.Open()
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer store.Close()
+
+	jwtService, err := jwt.NewService()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fileService, err := file.NewService(*flags.Data)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var cryptoService portainer.CryptoService = &crypto.Service{}
+
+	// Initialize the active endpoint from the CLI only if there is no
+	// active endpoint defined yet.
+	var activeEndpoint *portainer.Endpoint
+	if *flags.Endpoint != "" {
+		activeEndpoint, err = store.EndpointService.GetActive()
+		if err == portainer.ErrEndpointNotFound {
+			activeEndpoint = &portainer.Endpoint{
+				Name:          "primary",
+				URL:           *flags.Endpoint,
+				TLS:           *flags.TLSVerify,
+				TLSCACertPath: *flags.TLSCacert,
+				TLSCertPath:   *flags.TLSCert,
+				TLSKeyPath:    *flags.TLSKey,
+			}
+			err = store.EndpointService.CreateEndpoint(activeEndpoint)
+			if err != nil {
+				log.Fatal(err)
+			}
+		} else if err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	var server portainer.Server = &http.Server{
+		BindAddress:     *flags.Addr,
+		AssetsPath:      *flags.Assets,
+		Settings:        settings,
+		TemplatesURL:    *flags.Templates,
+		UserService:     store.UserService,
+		EndpointService: store.EndpointService,
+		CryptoService:   cryptoService,
+		JWTService:      jwtService,
+		FileService:     fileService,
+		ActiveEndpoint:  activeEndpoint,
+	}
+
+	log.Printf("Starting Portainer on %s", *flags.Addr)
+	err = server.Start()
+	if err != nil {
+		log.Fatal(err)
+	}
+}

api/crypto/crypto.go

@@ -0,0 +1,22 @@
+package crypto
+
+import (
+	"golang.org/x/crypto/bcrypt"
+)
+
+// Service represents a service for encrypting/hashing data.
+type Service struct{}
+
+// Hash hashes a string using the bcrypt algorithm
+func (*Service) Hash(data string) (string, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(data), bcrypt.DefaultCost)
+	if err != nil {
+		return "", nil
+	}
+	return string(hash), nil
+}
+
+// CompareHashAndData compares a hash to clear data and returns an error if the comparison fails.
+func (*Service) CompareHashAndData(hash string, data string) error {
+	return bcrypt.CompareHashAndPassword([]byte(hash), []byte(data))
+}

api/csrf.go

@@ -1,48 +0,0 @@
-package main
-
-import (
-	"github.com/gorilla/csrf"
-	"github.com/gorilla/securecookie"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-const keyFile = "authKey.dat"
-
-// newAuthKey reuses an existing CSRF authkey if present or generates a new one
-func newAuthKey(path string) []byte {
-	var authKey []byte
-	authKeyPath := path + "/" + keyFile
-	data, err := ioutil.ReadFile(authKeyPath)
-	if err != nil {
-		log.Print("Unable to find an existing CSRF auth key. Generating a new key.")
-		authKey = securecookie.GenerateRandomKey(32)
-		err := ioutil.WriteFile(authKeyPath, authKey, 0644)
-		if err != nil {
-			log.Fatal("Unable to persist CSRF auth key.")
-			log.Fatal(err)
-		}
-	} else {
-		authKey = data
-	}
-	return authKey
-}
-
-// newCSRF initializes a new CSRF handler
-func newCSRFHandler(keyPath string) func(h http.Handler) http.Handler {
-	authKey := newAuthKey(keyPath)
-	return csrf.Protect(
-		authKey,
-		csrf.HttpOnly(false),
-		csrf.Secure(false),
-	)
-}
-
-// newCSRFWrapper wraps a http.Handler to add the CSRF token
-func newCSRFWrapper(h http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("X-CSRF-Token", csrf.Token(r))
-		h.ServeHTTP(w, r)
-	})
-}

api/errors.go

@@ -0,0 +1,39 @@
+package portainer
+
+// General errors.
+const (
+	ErrUnauthorized = Error("Unauthorized")
+)
+
+// User errors.
+const (
+	ErrUserNotFound = Error("User not found")
+)
+
+// Endpoint errors.
+const (
+	ErrEndpointNotFound = Error("Endpoint not found")
+	ErrNoActiveEndpoint = Error("Undefined Docker endpoint")
+)
+
+// Crypto errors.
+const (
+	ErrCryptoHashFailure = Error("Unable to hash data")
+)
+
+// JWT errors.
+const (
+	ErrSecretGeneration = Error("Unable to generate secret key")
+	ErrInvalidJWTToken  = Error("Invalid JWT token")
+)
+
+// File errors.
+const (
+	ErrUndefinedTLSFileType = Error("Undefined TLS file type")
+)
+
+// Error represents an application error.
+type Error string
+
+// Error returns the error message.
+func (e Error) Error() string { return string(e) }

api/exec.go

@@ -1,24 +0,0 @@
-package main
-
-import (
-	"golang.org/x/net/websocket"
-	"log"
-)
-
-// execContainer is used to create a websocket communication with an exec instance
-func (a *api) execContainer(ws *websocket.Conn) {
-	qry := ws.Request().URL.Query()
-	execID := qry.Get("id")
-
-	var host string
-	if a.endpoint.Scheme == "tcp" {
-		host = a.endpoint.Host
-	} else if a.endpoint.Scheme == "unix" {
-		host = a.endpoint.Path
-	}
-
-	if err := hijack(host, a.endpoint.Scheme, "POST", "/exec/"+execID+"/start", a.tlsConfig, true, ws, ws, ws, nil, nil); err != nil {
-		log.Fatalf("error during hijack: %s", err)
-		return
-	}
-}

api/file/file.go

@@ -0,0 +1,125 @@
+package file
+
+import (
+	"strconv"
+
+	"github.com/portainer/portainer"
+
+	"io"
+	"os"
+	"path"
+)
+
+const (
+	// TLSStorePath represents the subfolder where TLS files are stored in the file store folder.
+	TLSStorePath = "tls"
+	// TLSCACertFile represents the name on disk for a TLS CA file.
+	TLSCACertFile = "ca.pem"
+	// TLSCertFile represents the name on disk for a TLS certificate file.
+	TLSCertFile = "cert.pem"
+	// TLSKeyFile represents the name on disk for a TLS key file.
+	TLSKeyFile = "key.pem"
+)
+
+// Service represents a service for managing files.
+type Service struct {
+	fileStorePath string
+}
+
+// NewService initializes a new service.
+func NewService(fileStorePath string) (*Service, error) {
+	service := &Service{
+		fileStorePath: fileStorePath,
+	}
+
+	err := service.createFolderInStoreIfNotExist(TLSStorePath)
+	if err != nil {
+		return nil, err
+	}
+
+	return service, nil
+}
+
+// StoreTLSFile creates a subfolder in the TLSStorePath and stores a new file with the content from r.
+func (service *Service) StoreTLSFile(endpointID portainer.EndpointID, fileType portainer.TLSFileType, r io.Reader) error {
+	ID := strconv.Itoa(int(endpointID))
+	endpointStorePath := path.Join(TLSStorePath, ID)
+	err := service.createFolderInStoreIfNotExist(endpointStorePath)
+	if err != nil {
+		return err
+	}
+
+	var fileName string
+	switch fileType {
+	case portainer.TLSFileCA:
+		fileName = TLSCACertFile
+	case portainer.TLSFileCert:
+		fileName = TLSCertFile
+	case portainer.TLSFileKey:
+		fileName = TLSKeyFile
+	default:
+		return portainer.ErrUndefinedTLSFileType
+	}
+
+	tlsFilePath := path.Join(endpointStorePath, fileName)
+	err = service.createFileInStore(tlsFilePath, r)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// GetPathForTLSFile returns the absolute path to a specific TLS file for an endpoint.
+func (service *Service) GetPathForTLSFile(endpointID portainer.EndpointID, fileType portainer.TLSFileType) (string, error) {
+	var fileName string
+	switch fileType {
+	case portainer.TLSFileCA:
+		fileName = TLSCACertFile
+	case portainer.TLSFileCert:
+		fileName = TLSCertFile
+	case portainer.TLSFileKey:
+		fileName = TLSKeyFile
+	default:
+		return "", portainer.ErrUndefinedTLSFileType
+	}
+	ID := strconv.Itoa(int(endpointID))
+	return path.Join(service.fileStorePath, TLSStorePath, ID, fileName), nil
+}
+
+// DeleteTLSFiles deletes a folder containing the TLS files for an endpoint.
+func (service *Service) DeleteTLSFiles(endpointID portainer.EndpointID) error {
+	ID := strconv.Itoa(int(endpointID))
+	endpointPath := path.Join(service.fileStorePath, TLSStorePath, ID)
+	err := os.RemoveAll(endpointPath)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// createFolderInStoreIfNotExist creates a new folder in the file store if it doesn't exists on the file system.
+func (service *Service) createFolderInStoreIfNotExist(name string) error {
+	path := path.Join(service.fileStorePath, name)
+	_, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		os.Mkdir(path, 0600)
+	} else if err != nil {
+		return err
+	}
+	return nil
+}
+
+// createFile creates a new file in the file store with the content from r.
+func (service *Service) createFileInStore(filePath string, r io.Reader) error {
+	path := path.Join(service.fileStorePath, filePath)
+	out, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return err
+	}
+	defer out.Close()
+	_, err = io.Copy(out, r)
+	if err != nil {
+		return err
+	}
+	return nil
+}

api/handler.go

@@ -1,78 +0,0 @@
-package main
-
-import (
-	"golang.org/x/net/websocket"
-	"log"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-)
-
-// newHandler creates a new http.Handler with CSRF protection
-func (a *api) newHandler(settings *Settings) http.Handler {
-	var (
-		mux         = http.NewServeMux()
-		fileHandler = http.FileServer(http.Dir(a.assetPath))
-	)
-
-	handler := a.newAPIHandler()
-	CSRFHandler := newCSRFHandler(a.dataPath)
-
-	mux.Handle("/", fileHandler)
-	mux.Handle("/dockerapi/", http.StripPrefix("/dockerapi", handler))
-	mux.Handle("/ws/exec", websocket.Handler(a.execContainer))
-	mux.HandleFunc("/settings", func(w http.ResponseWriter, r *http.Request) {
-		settingsHandler(w, r, settings)
-	})
-	mux.HandleFunc("/templates", func(w http.ResponseWriter, r *http.Request) {
-		templatesHandler(w, r, a.templatesURL)
-	})
-	return CSRFHandler(newCSRFWrapper(mux))
-}
-
-// newAPIHandler initializes a new http.Handler based on the URL scheme
-func (a *api) newAPIHandler() http.Handler {
-	var handler http.Handler
-	var endpoint = *a.endpoint
-	if endpoint.Scheme == "tcp" {
-		if a.tlsConfig != nil {
-			handler = a.newTCPHandlerWithTLS(&endpoint)
-		} else {
-			handler = a.newTCPHandler(&endpoint)
-		}
-	} else if endpoint.Scheme == "unix" {
-		socketPath := endpoint.Path
-		if _, err := os.Stat(socketPath); err != nil {
-			if os.IsNotExist(err) {
-				log.Fatalf("Unix socket %s does not exist", socketPath)
-			}
-			log.Fatal(err)
-		}
-		handler = a.newUnixHandler(socketPath)
-	} else {
-		log.Fatalf("Bad Docker enpoint: %v. Only unix:// and tcp:// are supported.", &endpoint)
-	}
-	return handler
-}
-
-// newUnixHandler initializes a new UnixHandler
-func (a *api) newUnixHandler(e string) http.Handler {
-	return &unixHandler{e}
-}
-
-// newTCPHandler initializes a HTTP reverse proxy
-func (a *api) newTCPHandler(u *url.URL) http.Handler {
-	u.Scheme = "http"
-	return httputil.NewSingleHostReverseProxy(u)
-}
-
-// newTCPHandlerWithL initializes a HTTPS reverse proxy with a TLS configuration
-func (a *api) newTCPHandlerWithTLS(u *url.URL) http.Handler {
-	u.Scheme = "https"
-	proxy := httputil.NewSingleHostReverseProxy(u)
-	proxy.Transport = &http.Transport{
-		TLSClientConfig: a.tlsConfig,
-	}
-	return proxy
-}

api/http/auth_handler.go

@@ -0,0 +1,96 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/asaskevich/govalidator"
+	"github.com/gorilla/mux"
+)
+
+// AuthHandler represents an HTTP API handler for managing authentication.
+type AuthHandler struct {
+	*mux.Router
+	Logger        *log.Logger
+	UserService   portainer.UserService
+	CryptoService portainer.CryptoService
+	JWTService    portainer.JWTService
+}
+
+const (
+	// ErrInvalidCredentialsFormat is an error raised when credentials format is not valid
+	ErrInvalidCredentialsFormat = portainer.Error("Invalid credentials format")
+	// ErrInvalidCredentials is an error raised when credentials for a user are invalid
+	ErrInvalidCredentials = portainer.Error("Invalid credentials")
+)
+
+// NewAuthHandler returns a new instance of AuthHandler.
+func NewAuthHandler() *AuthHandler {
+	h := &AuthHandler{
+		Router: mux.NewRouter(),
+		Logger: log.New(os.Stderr, "", log.LstdFlags),
+	}
+	h.HandleFunc("/auth", h.handlePostAuth)
+	return h
+}
+
+func (handler *AuthHandler) handlePostAuth(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		handleNotAllowed(w, []string{http.MethodPost})
+		return
+	}
+
+	var req postAuthRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err := govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidCredentialsFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	var username = req.Username
+	var password = req.Password
+
+	u, err := handler.UserService.User(username)
+	if err == portainer.ErrUserNotFound {
+		Error(w, err, http.StatusNotFound, handler.Logger)
+		return
+	} else if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	err = handler.CryptoService.CompareHashAndData(u.Password, password)
+	if err != nil {
+		Error(w, ErrInvalidCredentials, http.StatusUnprocessableEntity, handler.Logger)
+		return
+	}
+
+	tokenData := &portainer.TokenData{
+		username,
+	}
+	token, err := handler.JWTService.GenerateToken(tokenData)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	encodeJSON(w, &postAuthResponse{JWT: token}, handler.Logger)
+}
+
+type postAuthRequest struct {
+	Username string `valid:"alphanum,required"`
+	Password string `valid:"required"`
+}
+
+type postAuthResponse struct {
+	JWT string `json:"jwt"`
+}

api/http/docker_handler.go

@@ -0,0 +1,159 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+// DockerHandler represents an HTTP API handler for proxying requests to the Docker API.
+type DockerHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	middleWareService *middleWareService
+	proxy             http.Handler
+}
+
+// NewDockerHandler returns a new instance of DockerHandler.
+func NewDockerHandler(middleWareService *middleWareService) *DockerHandler {
+	h := &DockerHandler{
+		Router:            mux.NewRouter(),
+		Logger:            log.New(os.Stderr, "", log.LstdFlags),
+		middleWareService: middleWareService,
+	}
+	h.PathPrefix("/").Handler(middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.proxyRequestsToDockerAPI(w, r)
+	})))
+	return h
+}
+
+func (handler *DockerHandler) proxyRequestsToDockerAPI(w http.ResponseWriter, r *http.Request) {
+	if handler.proxy != nil {
+		handler.proxy.ServeHTTP(w, r)
+	} else {
+		Error(w, portainer.ErrNoActiveEndpoint, http.StatusNotFound, handler.Logger)
+	}
+}
+
+func (handler *DockerHandler) setupProxy(endpoint *portainer.Endpoint) error {
+	var proxy http.Handler
+	endpointURL, err := url.Parse(endpoint.URL)
+	if err != nil {
+		return err
+	}
+	if endpointURL.Scheme == "tcp" {
+		if endpoint.TLS {
+			proxy, err = newHTTPSProxy(endpointURL, endpoint)
+			if err != nil {
+				return err
+			}
+		} else {
+			proxy = newHTTPProxy(endpointURL)
+		}
+	} else {
+		// Assume unix:// scheme
+		proxy = newSocketProxy(endpointURL.Path)
+	}
+	handler.proxy = proxy
+	return nil
+}
+
+// singleJoiningSlash from golang.org/src/net/http/httputil/reverseproxy.go
+// included here for use in NewSingleHostReverseProxyWithHostHeader
+// because its used in NewSingleHostReverseProxy from golang.org/src/net/http/httputil/reverseproxy.go
+func singleJoiningSlash(a, b string) string {
+	aslash := strings.HasSuffix(a, "/")
+	bslash := strings.HasPrefix(b, "/")
+	switch {
+	case aslash && bslash:
+		return a + b[1:]
+	case !aslash && !bslash:
+		return a + "/" + b
+	}
+	return a + b
+}
+
+// NewSingleHostReverseProxyWithHostHeader is based on NewSingleHostReverseProxy
+// from golang.org/src/net/http/httputil/reverseproxy.go and merely sets the Host
+// HTTP header, which NewSingleHostReverseProxy deliberately preserves
+func NewSingleHostReverseProxyWithHostHeader(target *url.URL) *httputil.ReverseProxy {
+	targetQuery := target.RawQuery
+	director := func(req *http.Request) {
+		req.URL.Scheme = target.Scheme
+		req.URL.Host = target.Host
+		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
+		req.Host = req.URL.Host
+		if targetQuery == "" || req.URL.RawQuery == "" {
+			req.URL.RawQuery = targetQuery + req.URL.RawQuery
+		} else {
+			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
+		}
+		if _, ok := req.Header["User-Agent"]; !ok {
+			// explicitly disable User-Agent so it's not set to default value
+			req.Header.Set("User-Agent", "")
+		}
+	}
+	return &httputil.ReverseProxy{Director: director}
+}
+
+func newHTTPProxy(u *url.URL) http.Handler {
+	u.Scheme = "http"
+	return NewSingleHostReverseProxyWithHostHeader(u)
+}
+
+func newHTTPSProxy(u *url.URL, endpoint *portainer.Endpoint) (http.Handler, error) {
+	u.Scheme = "https"
+	proxy := NewSingleHostReverseProxyWithHostHeader(u)
+	config, err := createTLSConfiguration(endpoint.TLSCACertPath, endpoint.TLSCertPath, endpoint.TLSKeyPath)
+	if err != nil {
+		return nil, err
+	}
+	proxy.Transport = &http.Transport{
+		TLSClientConfig: config,
+	}
+	return proxy, nil
+}
+
+func newSocketProxy(path string) http.Handler {
+	return &unixSocketHandler{path}
+}
+
+// unixSocketHandler represents a handler to proxy HTTP requests via a unix:// socket
+type unixSocketHandler struct {
+	path string
+}
+
+func (h *unixSocketHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	conn, err := net.Dial("unix", h.path)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	c := httputil.NewClientConn(conn, nil)
+	defer c.Close()
+
+	res, err := c.Do(r)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer res.Body.Close()
+
+	for k, vv := range res.Header {
+		for _, v := range vv {
+			w.Header().Add(k, v)
+		}
+	}
+	if _, err := io.Copy(w, res.Body); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}

api/http/endpoint_handler.go

@@ -0,0 +1,294 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+
+	"github.com/asaskevich/govalidator"
+	"github.com/gorilla/mux"
+)
+
+// EndpointHandler represents an HTTP API handler for managing Docker endpoints.
+type EndpointHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	EndpointService   portainer.EndpointService
+	FileService       portainer.FileService
+	server            *Server
+	middleWareService *middleWareService
+}
+
+// NewEndpointHandler returns a new instance of EndpointHandler.
+func NewEndpointHandler(middleWareService *middleWareService) *EndpointHandler {
+	h := &EndpointHandler{
+		Router:            mux.NewRouter(),
+		Logger:            log.New(os.Stderr, "", log.LstdFlags),
+		middleWareService: middleWareService,
+	}
+	h.Handle("/endpoints", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePostEndpoints(w, r)
+	}))).Methods(http.MethodPost)
+	h.Handle("/endpoints", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handleGetEndpoints(w, r)
+	}))).Methods(http.MethodGet)
+	h.Handle("/endpoints/{id}", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handleGetEndpoint(w, r)
+	}))).Methods(http.MethodGet)
+	h.Handle("/endpoints/{id}", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePutEndpoint(w, r)
+	}))).Methods(http.MethodPut)
+	h.Handle("/endpoints/{id}", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handleDeleteEndpoint(w, r)
+	}))).Methods(http.MethodDelete)
+	h.Handle("/endpoints/{id}/active", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePostEndpoint(w, r)
+	}))).Methods(http.MethodPost)
+	return h
+}
+
+// handleGetEndpoints handles GET requests on /endpoints
+func (handler *EndpointHandler) handleGetEndpoints(w http.ResponseWriter, r *http.Request) {
+	endpoints, err := handler.EndpointService.Endpoints()
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+	encodeJSON(w, endpoints, handler.Logger)
+}
+
+// handlePostEndpoints handles POST requests on /endpoints
+// if the active URL parameter is specified, will also define the new endpoint as the active endpoint.
+// /endpoints(?active=true|false)
+func (handler *EndpointHandler) handlePostEndpoints(w http.ResponseWriter, r *http.Request) {
+	var req postEndpointsRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err := govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	endpoint := &portainer.Endpoint{
+		Name: req.Name,
+		URL:  req.URL,
+		TLS:  req.TLS,
+	}
+
+	err = handler.EndpointService.CreateEndpoint(endpoint)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	if req.TLS {
+		caCertPath, _ := handler.FileService.GetPathForTLSFile(endpoint.ID, portainer.TLSFileCA)
+		endpoint.TLSCACertPath = caCertPath
+		certPath, _ := handler.FileService.GetPathForTLSFile(endpoint.ID, portainer.TLSFileCert)
+		endpoint.TLSCertPath = certPath
+		keyPath, _ := handler.FileService.GetPathForTLSFile(endpoint.ID, portainer.TLSFileKey)
+		endpoint.TLSKeyPath = keyPath
+		err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
+		if err != nil {
+			Error(w, err, http.StatusInternalServerError, handler.Logger)
+			return
+		}
+	}
+
+	activeEndpointParameter := r.FormValue("active")
+	if activeEndpointParameter != "" {
+		active, err := strconv.ParseBool(activeEndpointParameter)
+		if err != nil {
+			Error(w, err, http.StatusBadRequest, handler.Logger)
+			return
+		}
+		if active == true {
+			err = handler.server.updateActiveEndpoint(endpoint)
+			if err != nil {
+				Error(w, err, http.StatusInternalServerError, handler.Logger)
+				return
+			}
+		}
+	}
+
+	encodeJSON(w, &postEndpointsResponse{ID: int(endpoint.ID)}, handler.Logger)
+}
+
+type postEndpointsRequest struct {
+	Name string `valid:"required"`
+	URL  string `valid:"required"`
+	TLS  bool
+}
+
+type postEndpointsResponse struct {
+	ID int `json:"Id"`
+}
+
+// handleGetEndpoint handles GET requests on /endpoints/:id
+// GET /endpoints/0 returns active endpoint
+func (handler *EndpointHandler) handleGetEndpoint(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	endpointID, err := strconv.Atoi(id)
+	if err != nil {
+		Error(w, err, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	var endpoint *portainer.Endpoint
+	if id == "0" {
+		endpoint, err = handler.EndpointService.GetActive()
+		if err == portainer.ErrEndpointNotFound {
+			Error(w, err, http.StatusNotFound, handler.Logger)
+			return
+		} else if err != nil {
+			Error(w, err, http.StatusInternalServerError, handler.Logger)
+			return
+		}
+		if handler.server.ActiveEndpoint == nil {
+			err = handler.server.updateActiveEndpoint(endpoint)
+			if err != nil {
+				Error(w, err, http.StatusInternalServerError, handler.Logger)
+				return
+			}
+		}
+	} else {
+		endpoint, err = handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
+		if err == portainer.ErrEndpointNotFound {
+			Error(w, err, http.StatusNotFound, handler.Logger)
+			return
+		} else if err != nil {
+			Error(w, err, http.StatusInternalServerError, handler.Logger)
+			return
+		}
+	}
+
+	encodeJSON(w, endpoint, handler.Logger)
+}
+
+// handlePostEndpoint handles POST requests on /endpoints/:id/active
+func (handler *EndpointHandler) handlePostEndpoint(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	endpointID, err := strconv.Atoi(id)
+	if err != nil {
+		Error(w, err, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
+	if err == portainer.ErrEndpointNotFound {
+		Error(w, err, http.StatusNotFound, handler.Logger)
+		return
+	} else if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	err = handler.server.updateActiveEndpoint(endpoint)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+	}
+}
+
+// handlePutEndpoint handles PUT requests on /endpoints/:id
+func (handler *EndpointHandler) handlePutEndpoint(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	endpointID, err := strconv.Atoi(id)
+	if err != nil {
+		Error(w, err, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	var req putEndpointsRequest
+	if err = json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err = govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	endpoint := &portainer.Endpoint{
+		ID:   portainer.EndpointID(endpointID),
+		Name: req.Name,
+		URL:  req.URL,
+		TLS:  req.TLS,
+	}
+
+	if req.TLS {
+		caCertPath, _ := handler.FileService.GetPathForTLSFile(endpoint.ID, portainer.TLSFileCA)
+		endpoint.TLSCACertPath = caCertPath
+		certPath, _ := handler.FileService.GetPathForTLSFile(endpoint.ID, portainer.TLSFileCert)
+		endpoint.TLSCertPath = certPath
+		keyPath, _ := handler.FileService.GetPathForTLSFile(endpoint.ID, portainer.TLSFileKey)
+		endpoint.TLSKeyPath = keyPath
+	} else {
+		err = handler.FileService.DeleteTLSFiles(endpoint.ID)
+		if err != nil {
+			Error(w, err, http.StatusInternalServerError, handler.Logger)
+			return
+		}
+	}
+
+	err = handler.EndpointService.UpdateEndpoint(endpoint.ID, endpoint)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+}
+
+type putEndpointsRequest struct {
+	Name string `valid:"required"`
+	URL  string `valid:"required"`
+	TLS  bool
+}
+
+// handleDeleteEndpoint handles DELETE requests on /endpoints/:id
+func (handler *EndpointHandler) handleDeleteEndpoint(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := vars["id"]
+
+	endpointID, err := strconv.Atoi(id)
+	if err != nil {
+		Error(w, err, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	endpoint, err := handler.EndpointService.Endpoint(portainer.EndpointID(endpointID))
+	if err == portainer.ErrEndpointNotFound {
+		Error(w, err, http.StatusNotFound, handler.Logger)
+		return
+	} else if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	err = handler.EndpointService.DeleteEndpoint(portainer.EndpointID(endpointID))
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	if endpoint.TLS {
+		err = handler.FileService.DeleteTLSFiles(portainer.EndpointID(endpointID))
+		if err != nil {
+			Error(w, err, http.StatusInternalServerError, handler.Logger)
+		}
+	}
+}

api/http/handler.go

@@ -0,0 +1,82 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"encoding/json"
+	"log"
+	"net/http"
+	"strings"
+)
+
+// Handler is a collection of all the service handlers.
+type Handler struct {
+	AuthHandler      *AuthHandler
+	UserHandler      *UserHandler
+	EndpointHandler  *EndpointHandler
+	SettingsHandler  *SettingsHandler
+	TemplatesHandler *TemplatesHandler
+	DockerHandler    *DockerHandler
+	WebSocketHandler *WebSocketHandler
+	UploadHandler    *UploadHandler
+	FileHandler      http.Handler
+}
+
+const (
+	// ErrInvalidJSON defines an error raised the app is unable to parse request data
+	ErrInvalidJSON = portainer.Error("Invalid JSON")
+	// ErrInvalidRequestFormat defines an error raised when the format of the data sent in a request is not valid
+	ErrInvalidRequestFormat = portainer.Error("Invalid request data format")
+)
+
+// ServeHTTP delegates a request to the appropriate subhandler.
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if strings.HasPrefix(r.URL.Path, "/api/auth") {
+		http.StripPrefix("/api", h.AuthHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/users") {
+		http.StripPrefix("/api", h.UserHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/endpoints") {
+		http.StripPrefix("/api", h.EndpointHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/settings") {
+		http.StripPrefix("/api", h.SettingsHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/templates") {
+		http.StripPrefix("/api", h.TemplatesHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/upload") {
+		http.StripPrefix("/api", h.UploadHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/websocket") {
+		http.StripPrefix("/api", h.WebSocketHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/api/docker") {
+		http.StripPrefix("/api/docker", h.DockerHandler).ServeHTTP(w, r)
+	} else if strings.HasPrefix(r.URL.Path, "/") {
+		h.FileHandler.ServeHTTP(w, r)
+	}
+}
+
+// Error writes an API error message to the response and logger.
+func Error(w http.ResponseWriter, err error, code int, logger *log.Logger) {
+	// Log error.
+	logger.Printf("http error: %s (code=%d)", err, code)
+
+	// Write generic error response.
+	w.WriteHeader(code)
+	json.NewEncoder(w).Encode(&errorResponse{Err: err.Error()})
+}
+
+// errorResponse is a generic response for sending a error.
+type errorResponse struct {
+	Err string `json:"err,omitempty"`
+}
+
+// handleNotAllowed writes an API error message to the response and sets the Allow header.
+func handleNotAllowed(w http.ResponseWriter, allowedMethods []string) {
+	w.Header().Set("Allow", strings.Join(allowedMethods, ", "))
+	w.WriteHeader(http.StatusMethodNotAllowed)
+	json.NewEncoder(w).Encode(&errorResponse{Err: http.StatusText(http.StatusMethodNotAllowed)})
+}
+
+// encodeJSON encodes v to w in JSON format. Error() is called if encoding fails.
+func encodeJSON(w http.ResponseWriter, v interface{}, logger *log.Logger) {
+	if err := json.NewEncoder(w).Encode(v); err != nil {
+		Error(w, err, http.StatusInternalServerError, logger)
+	}
+}

api/http/middleware.go

@@ -0,0 +1,63 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"net/http"
+	"strings"
+)
+
+// Service represents a service to manage HTTP middlewares
+type middleWareService struct {
+	jwtService portainer.JWTService
+}
+
+func addMiddleware(h http.Handler, middleware ...func(http.Handler) http.Handler) http.Handler {
+	for _, mw := range middleware {
+		h = mw(h)
+	}
+	return h
+}
+
+func (service *middleWareService) addMiddleWares(h http.Handler) http.Handler {
+	h = service.middleWareSecureHeaders(h)
+	h = service.middleWareAuthenticate(h)
+	return h
+}
+
+// middleWareAuthenticate provides secure headers middleware for handlers
+func (*middleWareService) middleWareSecureHeaders(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Add("X-Content-Type-Options", "nosniff")
+		w.Header().Add("X-Frame-Options", "DENY")
+		next.ServeHTTP(w, r)
+	})
+}
+
+// middleWareAuthenticate provides Authentication middleware for handlers
+func (service *middleWareService) middleWareAuthenticate(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var token string
+
+		// Get token from the Authorization header
+		tokens, ok := r.Header["Authorization"]
+		if ok && len(tokens) >= 1 {
+			token = tokens[0]
+			token = strings.TrimPrefix(token, "Bearer ")
+		}
+
+		if token == "" {
+			http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
+			return
+		}
+
+		err := service.jwtService.VerifyToken(token)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusUnauthorized)
+			return
+		}
+
+		next.ServeHTTP(w, r)
+		return
+	})
+}

api/http/server.go

@@ -0,0 +1,85 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"net/http"
+)
+
+// Server implements the portainer.Server interface
+type Server struct {
+	BindAddress     string
+	AssetsPath      string
+	UserService     portainer.UserService
+	EndpointService portainer.EndpointService
+	CryptoService   portainer.CryptoService
+	JWTService      portainer.JWTService
+	FileService     portainer.FileService
+	Settings        *portainer.Settings
+	TemplatesURL    string
+	ActiveEndpoint  *portainer.Endpoint
+	Handler         *Handler
+}
+
+func (server *Server) updateActiveEndpoint(endpoint *portainer.Endpoint) error {
+	if endpoint != nil {
+		server.ActiveEndpoint = endpoint
+		server.Handler.WebSocketHandler.endpoint = endpoint
+		err := server.Handler.DockerHandler.setupProxy(endpoint)
+		if err != nil {
+			return err
+		}
+		err = server.EndpointService.SetActive(endpoint)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Start starts the HTTP server
+func (server *Server) Start() error {
+	middleWareService := &middleWareService{
+		jwtService: server.JWTService,
+	}
+
+	var authHandler = NewAuthHandler()
+	authHandler.UserService = server.UserService
+	authHandler.CryptoService = server.CryptoService
+	authHandler.JWTService = server.JWTService
+	var userHandler = NewUserHandler(middleWareService)
+	userHandler.UserService = server.UserService
+	userHandler.CryptoService = server.CryptoService
+	var settingsHandler = NewSettingsHandler(middleWareService)
+	settingsHandler.settings = server.Settings
+	var templatesHandler = NewTemplatesHandler(middleWareService)
+	templatesHandler.templatesURL = server.TemplatesURL
+	var dockerHandler = NewDockerHandler(middleWareService)
+	var websocketHandler = NewWebSocketHandler()
+	// EndpointHandler requires a reference to the server to be able to update the active endpoint.
+	var endpointHandler = NewEndpointHandler(middleWareService)
+	endpointHandler.EndpointService = server.EndpointService
+	endpointHandler.FileService = server.FileService
+	endpointHandler.server = server
+	var uploadHandler = NewUploadHandler(middleWareService)
+	uploadHandler.FileService = server.FileService
+	var fileHandler = http.FileServer(http.Dir(server.AssetsPath))
+
+	server.Handler = &Handler{
+		AuthHandler:      authHandler,
+		UserHandler:      userHandler,
+		EndpointHandler:  endpointHandler,
+		SettingsHandler:  settingsHandler,
+		TemplatesHandler: templatesHandler,
+		DockerHandler:    dockerHandler,
+		WebSocketHandler: websocketHandler,
+		FileHandler:      fileHandler,
+		UploadHandler:    uploadHandler,
+	}
+	err := server.updateActiveEndpoint(server.ActiveEndpoint)
+	if err != nil {
+		return err
+	}
+
+	return http.ListenAndServe(server.BindAddress, server.Handler)
+}

api/http/settings_handler.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/gorilla/mux"
+)
+
+// SettingsHandler represents an HTTP API handler for managing settings.
+type SettingsHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	middleWareService *middleWareService
+	settings          *portainer.Settings
+}
+
+// NewSettingsHandler returns a new instance of SettingsHandler.
+func NewSettingsHandler(middleWareService *middleWareService) *SettingsHandler {
+	h := &SettingsHandler{
+		Router:            mux.NewRouter(),
+		Logger:            log.New(os.Stderr, "", log.LstdFlags),
+		middleWareService: middleWareService,
+	}
+	h.HandleFunc("/settings", h.handleGetSettings)
+	return h
+}
+
+// handleGetSettings handles GET requests on /settings
+func (handler *SettingsHandler) handleGetSettings(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		handleNotAllowed(w, []string{http.MethodGet})
+		return
+	}
+
+	encodeJSON(w, handler.settings, handler.Logger)
+}

api/http/templates_handler.go

@@ -0,0 +1,56 @@
+package http
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/gorilla/mux"
+)
+
+// TemplatesHandler represents an HTTP API handler for managing templates.
+type TemplatesHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	middleWareService *middleWareService
+	templatesURL      string
+}
+
+// NewTemplatesHandler returns a new instance of TemplatesHandler.
+func NewTemplatesHandler(middleWareService *middleWareService) *TemplatesHandler {
+	h := &TemplatesHandler{
+		Router:            mux.NewRouter(),
+		Logger:            log.New(os.Stderr, "", log.LstdFlags),
+		middleWareService: middleWareService,
+	}
+	h.Handle("/templates", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handleGetTemplates(w, r)
+	})))
+	return h
+}
+
+// handleGetTemplates handles GET requests on /templates
+func (handler *TemplatesHandler) handleGetTemplates(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		handleNotAllowed(w, []string{http.MethodGet})
+		return
+	}
+
+	resp, err := http.Get(handler.templatesURL)
+	if err != nil {
+		log.Print(err)
+		http.Error(w, fmt.Sprintf("Error making request to %s: %s", handler.templatesURL, err.Error()), http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		log.Print(err)
+		http.Error(w, "Error reading body from templates URL", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(body)
+}

api/http/tls.go

@@ -1,27 +1,26 @@
-package main
+package http
 
 import (
 	"crypto/tls"
 	"crypto/x509"
 	"io/ioutil"
-	"log"
 )
 
-// newTLSConfig initializes a tls.Config using a CA certificate, a certificate and a key
-func newTLSConfig(caCertPath, certPath, keyPath string) *tls.Config {
+// createTLSConfiguration initializes a tls.Config using a CA certificate, a certificate and a key
+func createTLSConfiguration(caCertPath, certPath, keyPath string) (*tls.Config, error) {
 	cert, err := tls.LoadX509KeyPair(certPath, keyPath)
 	if err != nil {
-		log.Fatal(err)
+		return nil, err
 	}
 	caCert, err := ioutil.ReadFile(caCertPath)
 	if err != nil {
-		log.Fatal(err)
+		return nil, err
 	}
 	caCertPool := x509.NewCertPool()
 	caCertPool.AppendCertsFromPEM(caCert)
-	tlsConfig := &tls.Config{
+	config := &tls.Config{
 		Certificates: []tls.Certificate{cert},
 		RootCAs:      caCertPool,
 	}
-	return tlsConfig
+	return config, nil
 }

api/http/upload_handler.go

@@ -0,0 +1,74 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+
+	"github.com/gorilla/mux"
+)
+
+// UploadHandler represents an HTTP API handler for managing file uploads.
+type UploadHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	FileService       portainer.FileService
+	middleWareService *middleWareService
+}
+
+// NewUploadHandler returns a new instance of UploadHandler.
+func NewUploadHandler(middleWareService *middleWareService) *UploadHandler {
+	h := &UploadHandler{
+		Router:            mux.NewRouter(),
+		Logger:            log.New(os.Stderr, "", log.LstdFlags),
+		middleWareService: middleWareService,
+	}
+	h.Handle("/upload/tls/{endpointID}/{certificate:(ca|cert|key)}", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePostUploadTLS(w, r)
+	})))
+	return h
+}
+
+func (handler *UploadHandler) handlePostUploadTLS(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		handleNotAllowed(w, []string{http.MethodPost})
+		return
+	}
+
+	vars := mux.Vars(r)
+	endpointID := vars["endpointID"]
+	certificate := vars["certificate"]
+	ID, err := strconv.Atoi(endpointID)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	file, _, err := r.FormFile("file")
+	defer file.Close()
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	var fileType portainer.TLSFileType
+	switch certificate {
+	case "ca":
+		fileType = portainer.TLSFileCA
+	case "cert":
+		fileType = portainer.TLSFileCert
+	case "key":
+		fileType = portainer.TLSFileKey
+	default:
+		Error(w, portainer.ErrUndefinedTLSFileType, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	err = handler.FileService.StoreTLSFile(portainer.EndpointID(ID), fileType, file)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+	}
+}

api/http/user_handler.go

@@ -0,0 +1,248 @@
+package http
+
+import (
+	"github.com/portainer/portainer"
+
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/asaskevich/govalidator"
+	"github.com/gorilla/mux"
+)
+
+// UserHandler represents an HTTP API handler for managing users.
+type UserHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	UserService       portainer.UserService
+	CryptoService     portainer.CryptoService
+	middleWareService *middleWareService
+}
+
+// NewUserHandler returns a new instance of UserHandler.
+func NewUserHandler(middleWareService *middleWareService) *UserHandler {
+	h := &UserHandler{
+		Router:            mux.NewRouter(),
+		Logger:            log.New(os.Stderr, "", log.LstdFlags),
+		middleWareService: middleWareService,
+	}
+	h.Handle("/users", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePostUsers(w, r)
+	})))
+	h.Handle("/users/{username}", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handleGetUser(w, r)
+	}))).Methods(http.MethodGet)
+	h.Handle("/users/{username}", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePutUser(w, r)
+	}))).Methods(http.MethodPut)
+	h.Handle("/users/{username}/passwd", middleWareService.addMiddleWares(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		h.handlePostUserPasswd(w, r)
+	})))
+	h.HandleFunc("/users/admin/check", h.handleGetAdminCheck)
+	h.HandleFunc("/users/admin/init", h.handlePostAdminInit)
+	return h
+}
+
+// handlePostUsers handles POST requests on /users
+func (handler *UserHandler) handlePostUsers(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		handleNotAllowed(w, []string{http.MethodPost})
+		return
+	}
+
+	var req postUsersRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err := govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	user := &portainer.User{
+		Username: req.Username,
+	}
+	user.Password, err = handler.CryptoService.Hash(req.Password)
+	if err != nil {
+		Error(w, portainer.ErrCryptoHashFailure, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	err = handler.UserService.UpdateUser(user)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+}
+
+type postUsersRequest struct {
+	Username string `valid:"alphanum,required"`
+	Password string `valid:"required"`
+}
+
+// handlePostUserPasswd handles POST requests on /users/:username/passwd
+func (handler *UserHandler) handlePostUserPasswd(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		handleNotAllowed(w, []string{http.MethodPost})
+		return
+	}
+
+	vars := mux.Vars(r)
+	username := vars["username"]
+
+	var req postUserPasswdRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err := govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	var password = req.Password
+
+	u, err := handler.UserService.User(username)
+	if err == portainer.ErrUserNotFound {
+		Error(w, err, http.StatusNotFound, handler.Logger)
+		return
+	} else if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	valid := true
+	err = handler.CryptoService.CompareHashAndData(u.Password, password)
+	if err != nil {
+		valid = false
+	}
+
+	encodeJSON(w, &postUserPasswdResponse{Valid: valid}, handler.Logger)
+}
+
+type postUserPasswdRequest struct {
+	Password string `valid:"required"`
+}
+
+type postUserPasswdResponse struct {
+	Valid bool `json:"valid"`
+}
+
+// handleGetUser handles GET requests on /users/:username
+func (handler *UserHandler) handleGetUser(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	username := vars["username"]
+
+	user, err := handler.UserService.User(username)
+	if err == portainer.ErrUserNotFound {
+		Error(w, err, http.StatusNotFound, handler.Logger)
+		return
+	} else if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	user.Password = ""
+	encodeJSON(w, &user, handler.Logger)
+}
+
+// handlePutUser handles PUT requests on /users/:username
+func (handler *UserHandler) handlePutUser(w http.ResponseWriter, r *http.Request) {
+	var req putUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err := govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	user := &portainer.User{
+		Username: req.Username,
+	}
+	user.Password, err = handler.CryptoService.Hash(req.Password)
+	if err != nil {
+		Error(w, portainer.ErrCryptoHashFailure, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	err = handler.UserService.UpdateUser(user)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+}
+
+type putUserRequest struct {
+	Username string `valid:"alphanum,required"`
+	Password string `valid:"required"`
+}
+
+// handlePostAdminInit handles GET requests on /users/admin/check
+func (handler *UserHandler) handleGetAdminCheck(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		handleNotAllowed(w, []string{http.MethodGet})
+		return
+	}
+
+	user, err := handler.UserService.User("admin")
+	if err == portainer.ErrUserNotFound {
+		Error(w, err, http.StatusNotFound, handler.Logger)
+		return
+	} else if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+
+	user.Password = ""
+	encodeJSON(w, &user, handler.Logger)
+}
+
+// handlePostAdminInit handles POST requests on /users/admin/init
+func (handler *UserHandler) handlePostAdminInit(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		handleNotAllowed(w, []string{http.MethodPost})
+		return
+	}
+
+	var req postAdminInitRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		Error(w, ErrInvalidJSON, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	_, err := govalidator.ValidateStruct(req)
+	if err != nil {
+		Error(w, ErrInvalidRequestFormat, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	user := &portainer.User{
+		Username: "admin",
+	}
+	user.Password, err = handler.CryptoService.Hash(req.Password)
+	if err != nil {
+		Error(w, portainer.ErrCryptoHashFailure, http.StatusBadRequest, handler.Logger)
+		return
+	}
+
+	err = handler.UserService.UpdateUser(user)
+	if err != nil {
+		Error(w, err, http.StatusInternalServerError, handler.Logger)
+		return
+	}
+}
+
+type postAdminInitRequest struct {
+	Password string `valid:"required"`
+}

api/http/websocket_handler.go

@@ -1,17 +1,79 @@
-package main
+package http
 
 import (
+	"github.com/portainer/portainer"
+
 	"bytes"
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net"
 	"net/http"
 	"net/http/httputil"
+	"net/url"
+	"os"
 	"time"
+
+	"github.com/gorilla/mux"
+	"golang.org/x/net/websocket"
 )
 
+// WebSocketHandler represents an HTTP API handler for proxying requests to a web socket.
+type WebSocketHandler struct {
+	*mux.Router
+	Logger            *log.Logger
+	middleWareService *middleWareService
+	endpoint          *portainer.Endpoint
+}
+
+// NewWebSocketHandler returns a new instance of WebSocketHandler.
+func NewWebSocketHandler() *WebSocketHandler {
+	h := &WebSocketHandler{
+		Router: mux.NewRouter(),
+		Logger: log.New(os.Stderr, "", log.LstdFlags),
+	}
+	h.Handle("/websocket/exec", websocket.Handler(h.webSocketDockerExec))
+	return h
+}
+
+func (handler *WebSocketHandler) webSocketDockerExec(ws *websocket.Conn) {
+	qry := ws.Request().URL.Query()
+	execID := qry.Get("id")
+
+	// Should not be managed here
+	endpoint, err := url.Parse(handler.endpoint.URL)
+	if err != nil {
+		log.Fatalf("Unable to parse endpoint URL: %s", err)
+		return
+	}
+
+	var host string
+	if endpoint.Scheme == "tcp" {
+		host = endpoint.Host
+	} else if endpoint.Scheme == "unix" {
+		host = endpoint.Path
+	}
+
+	// Should not be managed here
+	var tlsConfig *tls.Config
+	if handler.endpoint.TLS {
+		tlsConfig, err = createTLSConfiguration(handler.endpoint.TLSCACertPath,
+			handler.endpoint.TLSCertPath,
+			handler.endpoint.TLSKeyPath)
+		if err != nil {
+			log.Fatalf("Unable to create TLS configuration: %s", err)
+			return
+		}
+	}
+
+	if err := hijack(host, endpoint.Scheme, "POST", "/exec/"+execID+"/start", tlsConfig, true, ws, ws, ws, nil, nil); err != nil {
+		log.Fatalf("error during hijack: %s", err)
+		return
+	}
+}
+
 type execConfig struct {
 	Tty    bool
 	Detach bool

api/jwt/jwt.go

@@ -0,0 +1,66 @@
+package jwt
+
+import (
+	"github.com/portainer/portainer"
+
+	"fmt"
+	"github.com/dgrijalva/jwt-go"
+	"github.com/gorilla/securecookie"
+	"time"
+)
+
+// Service represents a service for managing JWT tokens.
+type Service struct {
+	secret []byte
+}
+
+type claims struct {
+	Username string `json:"username"`
+	jwt.StandardClaims
+}
+
+// NewService initializes a new service. It will generate a random key that will be used to sign JWT tokens.
+func NewService() (*Service, error) {
+	secret := securecookie.GenerateRandomKey(32)
+	if secret == nil {
+		return nil, portainer.ErrSecretGeneration
+	}
+	service := &Service{
+		secret,
+	}
+	return service, nil
+}
+
+// GenerateToken generates a new JWT token.
+func (service *Service) GenerateToken(data *portainer.TokenData) (string, error) {
+	expireToken := time.Now().Add(time.Hour * 8).Unix()
+	cl := claims{
+		data.Username,
+		jwt.StandardClaims{
+			ExpiresAt: expireToken,
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, cl)
+
+	signedToken, err := token.SignedString(service.secret)
+	if err != nil {
+		return "", err
+	}
+
+	return signedToken, nil
+}
+
+// VerifyToken parses a JWT token and verify its validity. It returns an error if token is invalid.
+func (service *Service) VerifyToken(token string) error {
+	parsedToken, err := jwt.Parse(token, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			msg := fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
+			return nil, msg
+		}
+		return service.secret, nil
+	})
+	if err != nil || parsedToken == nil || !parsedToken.Valid {
+		return portainer.ErrInvalidJWTToken
+	}
+	return nil
+}

api/main.go

@@ -1,47 +0,0 @@
-package main // import "github.com/portainer/portainer"
-
-import (
-	"gopkg.in/alecthomas/kingpin.v2"
-)
-
-// main is the entry point of the program
-func main() {
-	kingpin.Version("1.9.2")
-	var (
-		endpoint  = kingpin.Flag("host", "Dockerd endpoint").Default("unix:///var/run/docker.sock").Short('H').String()
-		addr      = kingpin.Flag("bind", "Address and port to serve Portainer").Default(":9000").Short('p').String()
-		assets    = kingpin.Flag("assets", "Path to the assets").Default(".").Short('a').String()
-		data      = kingpin.Flag("data", "Path to the data").Default(".").Short('d').String()
-		tlsverify = kingpin.Flag("tlsverify", "TLS support").Default("false").Bool()
-		tlscacert = kingpin.Flag("tlscacert", "Path to the CA").Default("/certs/ca.pem").String()
-		tlscert   = kingpin.Flag("tlscert", "Path to the TLS certificate file").Default("/certs/cert.pem").String()
-		tlskey    = kingpin.Flag("tlskey", "Path to the TLS key").Default("/certs/key.pem").String()
-		swarm     = kingpin.Flag("swarm", "Swarm cluster support").Default("false").Short('s').Bool()
-		labels    = pairs(kingpin.Flag("hide-label", "Hide containers with a specific label in the UI").Short('l'))
-		logo      = kingpin.Flag("logo", "URL for the logo displayed in the UI").String()
-		templates = kingpin.Flag("templates", "URL to the templates (apps) definitions").Default("https://raw.githubusercontent.com/portainer/templates/master/templates.json").Short('t').String()
-	)
-	kingpin.Parse()
-
-	apiConfig := apiConfig{
-		Endpoint:      *endpoint,
-		BindAddress:   *addr,
-		AssetPath:     *assets,
-		DataPath:      *data,
-		SwarmSupport:  *swarm,
-		TLSEnabled:    *tlsverify,
-		TLSCACertPath: *tlscacert,
-		TLSCertPath:   *tlscert,
-		TLSKeyPath:    *tlskey,
-		TemplatesURL:  *templates,
-	}
-
-	settings := &Settings{
-		Swarm:        *swarm,
-		HiddenLabels: *labels,
-		Logo:         *logo,
-	}
-
-	api := newAPI(apiConfig)
-	api.run(settings)
-}

api/portainer.go

@@ -0,0 +1,131 @@
+package portainer
+
+import (
+	"io"
+)
+
+type (
+	// Pair defines a key/value string pair
+	Pair struct {
+		Name  string `json:"name"`
+		Value string `json:"value"`
+	}
+
+	// CLIFlags represents the available flags on the CLI.
+	CLIFlags struct {
+		Addr      *string
+		Assets    *string
+		Data      *string
+		Endpoint  *string
+		Labels    *[]Pair
+		Logo      *string
+		Templates *string
+		TLSVerify *bool
+		TLSCacert *string
+		TLSCert   *string
+		TLSKey    *string
+	}
+
+	// Settings represents Portainer settings.
+	Settings struct {
+		HiddenLabels []Pair `json:"hiddenLabels"`
+		Logo         string `json:"logo"`
+	}
+
+	// User represent a user account.
+	User struct {
+		Username string `json:"Username"`
+		Password string `json:"Password,omitempty"`
+	}
+
+	// TokenData represents the data embedded in a JWT token.
+	TokenData struct {
+		Username string
+	}
+
+	// EndpointID represents an endpoint identifier.
+	EndpointID int
+
+	// Endpoint represents a Docker endpoint with all the info required
+	// to connect to it.
+	Endpoint struct {
+		ID            EndpointID `json:"Id"`
+		Name          string     `json:"Name"`
+		URL           string     `json:"URL"`
+		TLS           bool       `json:"TLS"`
+		TLSCACertPath string     `json:"TLSCACert,omitempty"`
+		TLSCertPath   string     `json:"TLSCert,omitempty"`
+		TLSKeyPath    string     `json:"TLSKey,omitempty"`
+	}
+
+	// TLSFileType represents a type of TLS file required to connect to a Docker endpoint.
+	// It can be either a TLS CA file, a TLS certificate file or a TLS key file.
+	TLSFileType int
+
+	// CLIService represents a service for managing CLI.
+	CLIService interface {
+		ParseFlags(version string) (*CLIFlags, error)
+		ValidateFlags(flags *CLIFlags) error
+	}
+
+	// DataStore defines the interface to manage the data.
+	DataStore interface {
+		Open() error
+		Close() error
+	}
+
+	// Server defines the interface to serve the data.
+	Server interface {
+		Start() error
+	}
+
+	// UserService represents a service for managing users.
+	UserService interface {
+		User(username string) (*User, error)
+		UpdateUser(user *User) error
+	}
+
+	// EndpointService represents a service for managing endpoints.
+	EndpointService interface {
+		Endpoint(ID EndpointID) (*Endpoint, error)
+		Endpoints() ([]Endpoint, error)
+		CreateEndpoint(endpoint *Endpoint) error
+		UpdateEndpoint(ID EndpointID, endpoint *Endpoint) error
+		DeleteEndpoint(ID EndpointID) error
+		GetActive() (*Endpoint, error)
+		SetActive(endpoint *Endpoint) error
+	}
+
+	// CryptoService represents a service for encrypting/hashing data.
+	CryptoService interface {
+		Hash(data string) (string, error)
+		CompareHashAndData(hash string, data string) error
+	}
+
+	// JWTService represents a service for managing JWT tokens.
+	JWTService interface {
+		GenerateToken(data *TokenData) (string, error)
+		VerifyToken(token string) error
+	}
+
+	// FileService represents a service for managing files.
+	FileService interface {
+		StoreTLSFile(endpointID EndpointID, fileType TLSFileType, r io.Reader) error
+		GetPathForTLSFile(endpointID EndpointID, fileType TLSFileType) (string, error)
+		DeleteTLSFiles(endpointID EndpointID) error
+	}
+)
+
+const (
+	// APIVersion is the version number of portainer API.
+	APIVersion = "1.11.0"
+)
+
+const (
+	// TLSFileCA represents a TLS CA certificate file.
+	TLSFileCA TLSFileType = iota
+	// TLSFileCert represents a TLS certificate file.
+	TLSFileCert
+	// TLSFileKey represents a TLS key file.
+	TLSFileKey
+)

api/settings.go

@@ -1,18 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// Settings defines the settings available under the /settings endpoint
-type Settings struct {
-	Swarm        bool     `json:"swarm"`
-	HiddenLabels pairList `json:"hiddenLabels"`
-	Logo         string   `json:"logo"`
-}
-
-// settingsHandler defines a handler function used to encode the configuration in JSON
-func settingsHandler(w http.ResponseWriter, r *http.Request, s *Settings) {
-	json.NewEncoder(w).Encode(*s)
-}

api/templates.go

@@ -1,27 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net/http"
-)
-
-// templatesHandler defines a handler function used to retrieve the templates from a URL and put them in the response
-func templatesHandler(w http.ResponseWriter, r *http.Request, templatesURL string) {
-	resp, err := http.Get(templatesURL)
-	if err != nil {
-		http.Error(w, fmt.Sprintf("Error making request to %s: %s", templatesURL, err.Error()), http.StatusInternalServerError)
-		log.Print(err)
-		return
-	}
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		http.Error(w, "Error reading body from templates URL", http.StatusInternalServerError)
-		log.Print(err)
-		return
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.Write(body)
-}

api/unix_handler.go

@@ -1,47 +0,0 @@
-package main
-
-import (
-	"io"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-)
-
-// unixHandler defines a handler holding the path to a socket under UNIX
-type unixHandler struct {
-	path string
-}
-
-// ServeHTTP implementation for unixHandler
-func (h *unixHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	conn, err := net.Dial("unix", h.path)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		log.Println(err)
-		return
-	}
-	c := httputil.NewClientConn(conn, nil)
-	defer c.Close()
-
-	res, err := c.Do(r)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		log.Println(err)
-		return
-	}
-	defer res.Body.Close()
-
-	copyHeader(w.Header(), res.Header)
-	if _, err := io.Copy(w, res.Body); err != nil {
-		log.Println(err)
-	}
-}
-
-func copyHeader(dst, src http.Header) {
-	for k, vv := range src {
-		for _, v := range vv {
-			dst.Add(k, v)
-		}
-	}
-}

app/app.js

@@ -5,9 +5,14 @@ angular.module('portainer', [
   'ui.select',
   'ngCookies',
   'ngSanitize',
+  'ngFileUpload',
+  'angularUtils.directives.dirPagination',
+  'LocalStorageModule',
+  'angular-jwt',
   'portainer.services',
   'portainer.helpers',
   'portainer.filters',
+  'auth',
   'dashboard',
   'container',
   'containerConsole',
@@ -15,11 +20,17 @@ angular.module('portainer', [
   'containers',
   'createContainer',
   'docker',
+  'endpoint',
+  'endpointInit',
+  'endpoints',
   'events',
   'images',
   'image',
+  'main',
   'service',
   'services',
+  'settings',
+  'sidebar',
   'createService',
   'stats',
   'swarm',
@@ -30,134 +41,474 @@ angular.module('portainer', [
   'templates',
   'volumes',
   'createVolume'])
-  .config(['$stateProvider', '$urlRouterProvider', '$httpProvider', function ($stateProvider, $urlRouterProvider, $httpProvider) {
+  .config(['$stateProvider', '$urlRouterProvider', '$httpProvider', 'localStorageServiceProvider', 'jwtOptionsProvider', function ($stateProvider, $urlRouterProvider, $httpProvider, localStorageServiceProvider, jwtOptionsProvider) {
     'use strict';
 
-    $httpProvider.defaults.xsrfCookieName = 'csrfToken';
-    $httpProvider.defaults.xsrfHeaderName = 'X-CSRF-Token';
+    localStorageServiceProvider
+    .setStorageType('sessionStorage')
+    .setPrefix('portainer');
 
-    $urlRouterProvider.otherwise('/');
+    jwtOptionsProvider.config({
+      tokenGetter: ['localStorageService', function(localStorageService) {
+        return localStorageService.get('JWT');
+      }],
+      unauthenticatedRedirector: ['$state', function($state) {
+        $state.go('auth', {error: 'Your session has expired'});
+      }]
+    });
+    $httpProvider.interceptors.push('jwtInterceptor');
+
+    $urlRouterProvider.otherwise('/auth');
 
     $stateProvider
-    .state('index', {
-      url: '/',
-      templateUrl: 'app/components/dashboard/dashboard.html',
-      controller: 'DashboardController'
+    .state('auth', {
+      url: '/auth',
+      params: {
+        logout: false,
+        error: ''
+      },
+      views: {
+        "content": {
+          templateUrl: 'app/components/auth/auth.html',
+          controller: 'AuthenticationController'
+        }
+      }
     })
     .state('containers', {
       url: '/containers/',
-      templateUrl: 'app/components/containers/containers.html',
-      controller: 'ContainersController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/containers/containers.html',
+          controller: 'ContainersController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('container', {
       url: "^/containers/:id",
-      templateUrl: 'app/components/container/container.html',
-      controller: 'ContainerController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/container/container.html',
+          controller: 'ContainerController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('stats', {
       url: "^/containers/:id/stats",
-      templateUrl: 'app/components/stats/stats.html',
-      controller: 'StatsController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/stats/stats.html',
+          controller: 'StatsController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('logs', {
       url: "^/containers/:id/logs",
-      templateUrl: 'app/components/containerLogs/containerlogs.html',
-      controller: 'ContainerLogsController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/containerLogs/containerlogs.html',
+          controller: 'ContainerLogsController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('console', {
       url: "^/containers/:id/console",
-      templateUrl: 'app/components/containerConsole/containerConsole.html',
-      controller: 'ContainerConsoleController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/containerConsole/containerConsole.html',
+          controller: 'ContainerConsoleController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
+    })
+    .state('dashboard', {
+      url: '/dashboard',
+      views: {
+        "content": {
+          templateUrl: 'app/components/dashboard/dashboard.html',
+          controller: 'DashboardController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('actions', {
       abstract: true,
       url: "/actions",
-      template: '<ui-view/>'
+      views: {
+        "content": {
+          template: '<div ui-view="content"></div>'
+        },
+        "sidebar": {
+          template: '<div ui-view="sidebar"></div>'
+        }
+      }
     })
     .state('actions.create', {
       abstract: true,
       url: "/create",
-      template: '<ui-view/>'
+      views: {
+        "content": {
+          template: '<div ui-view="content"></div>'
+        },
+        "sidebar": {
+          template: '<div ui-view="sidebar"></div>'
+        }
+      }
     })
     .state('actions.create.container', {
       url: "/container",
-      templateUrl: 'app/components/createContainer/createcontainer.html',
-      controller: 'CreateContainerController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/createContainer/createcontainer.html',
+          controller: 'CreateContainerController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('actions.create.network', {
       url: "/network",
-      templateUrl: 'app/components/createNetwork/createnetwork.html',
-      controller: 'CreateNetworkController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/createNetwork/createnetwork.html',
+          controller: 'CreateNetworkController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('actions.create.service', {
       url: "/service",
-      templateUrl: 'app/components/createService/createservice.html',
-      controller: 'CreateServiceController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/createService/createservice.html',
+          controller: 'CreateServiceController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('actions.create.volume', {
       url: "/volume",
-      templateUrl: 'app/components/createVolume/createvolume.html',
-      controller: 'CreateVolumeController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/createVolume/createvolume.html',
+          controller: 'CreateVolumeController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('docker', {
       url: '/docker/',
-      templateUrl: 'app/components/docker/docker.html',
-      controller: 'DockerController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/docker/docker.html',
+          controller: 'DockerController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
+    })
+    .state('endpoints', {
+      url: '/endpoints/',
+      views: {
+        "content": {
+          templateUrl: 'app/components/endpoints/endpoints.html',
+          controller: 'EndpointsController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
+    })
+    .state('endpoint', {
+      url: '^/endpoints/:id',
+      views: {
+        "content": {
+          templateUrl: 'app/components/endpoint/endpoint.html',
+          controller: 'EndpointController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
+    })
+    .state('endpointInit', {
+      url: '/init/endpoint',
+      views: {
+        "content": {
+          templateUrl: 'app/components/endpointInit/endpointInit.html',
+          controller: 'EndpointInitController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('events', {
       url: '/events/',
-      templateUrl: 'app/components/events/events.html',
-      controller: 'EventsController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/events/events.html',
+          controller: 'EventsController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('images', {
       url: '/images/',
-      templateUrl: 'app/components/images/images.html',
-      controller: 'ImagesController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/images/images.html',
+          controller: 'ImagesController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('image', {
       url: '^/images/:id/',
-      templateUrl: 'app/components/image/image.html',
-      controller: 'ImageController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/image/image.html',
+          controller: 'ImageController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('networks', {
       url: '/networks/',
-      templateUrl: 'app/components/networks/networks.html',
-      controller: 'NetworksController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/networks/networks.html',
+          controller: 'NetworksController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('network', {
       url: '^/networks/:id/',
-      templateUrl: 'app/components/network/network.html',
-      controller: 'NetworkController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/network/network.html',
+          controller: 'NetworkController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('services', {
       url: '/services/',
-      templateUrl: 'app/components/services/services.html',
-      controller: 'ServicesController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/services/services.html',
+          controller: 'ServicesController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('service', {
       url: '^/service/:id/',
-      templateUrl: 'app/components/service/service.html',
-      controller: 'ServiceController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/service/service.html',
+          controller: 'ServiceController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
+    })
+    .state('settings', {
+      url: '/settings/',
+      views: {
+        "content": {
+          templateUrl: 'app/components/settings/settings.html',
+          controller: 'SettingsController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('task', {
       url: '^/task/:id',
-      templateUrl: 'app/components/task/task.html',
-      controller: 'TaskController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/task/task.html',
+          controller: 'TaskController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('templates', {
       url: '/templates/',
-      templateUrl: 'app/components/templates/templates.html',
-      controller: 'TemplatesController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/templates/templates.html',
+          controller: 'TemplatesController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('volumes', {
       url: '/volumes/',
-      templateUrl: 'app/components/volumes/volumes.html',
-      controller: 'VolumesController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/volumes/volumes.html',
+          controller: 'VolumesController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     })
     .state('swarm', {
       url: '/swarm/',
-      templateUrl: 'app/components/swarm/swarm.html',
-      controller: 'SwarmController'
+      views: {
+        "content": {
+          templateUrl: 'app/components/swarm/swarm.html',
+          controller: 'SwarmController'
+        },
+        "sidebar": {
+          templateUrl: 'app/components/sidebar/sidebar.html',
+          controller: 'SidebarController'
+        }
+      },
+      data: {
+        requiresLogin: true
+      }
     });
 
     // The Docker API likes to return plaintext errors, this catches them and disp
@@ -165,27 +516,42 @@ angular.module('portainer', [
       return {
         'response': function(response) {
           if (typeof(response.data) === 'string' &&
-                  (response.data.startsWith('Conflict.') || response.data.startsWith('conflict:'))) {
+          (response.data.startsWith('Conflict.') || response.data.startsWith('conflict:'))) {
             $.gritter.add({
               title: 'Error',
               text: $('<div>').text(response.data).html(),
               time: 10000
             });
           }
-          var csrfToken = response.headers('X-Csrf-Token');
-          if (csrfToken) {
-            document.cookie = 'csrfToken=' + csrfToken;
-          }
           return response;
         }
       };
     });
   }])
+  .run(['$rootScope', '$state', 'Authentication', 'authManager', 'EndpointMode', function ($rootScope, $state, Authentication, authManager, EndpointMode) {
+    authManager.checkAuthOnRefresh();
+    authManager.redirectWhenUnauthenticated();
+    Authentication.init();
+    $rootScope.$state = $state;
 
+    $rootScope.$on('tokenHasExpired', function($state) {
+      $state.go('auth', {error: 'Your session has expired'});
+    });
+
+    $rootScope.$on("$stateChangeStart", function(event, toState, toParams, fromState, fromParams) {
+      if (toState.name !== 'endpointInit' && (fromState.name === 'auth' || fromState.name === '' || fromState.name === 'endpointInit') && Authentication.isAuthenticated()) {
+        EndpointMode.determineEndpointMode();
+      }
+    });
+  }])
   // This is your docker url that the api will use to make requests
   // You need to set this to the api endpoint without the port i.e. http://192.168.1.9
-  .constant('DOCKER_ENDPOINT', 'dockerapi')
-  .constant('DOCKER_PORT', '') // Docker port, leave as an empty string if no port is requred.  If you have a port, prefix it with a ':' i.e. :4243
-  .constant('CONFIG_ENDPOINT', 'settings')
-  .constant('TEMPLATES_ENDPOINT', 'templates')
-  .constant('UI_VERSION', 'v1.9.2');
+  .constant('DOCKER_PORT', '') // Docker port, leave as an empty string if no port is required.  If you have a port, prefix it with a ':' i.e. :4243
+  .constant('DOCKER_ENDPOINT', '/api/docker')
+  .constant('CONFIG_ENDPOINT', '/api/settings')
+  .constant('AUTH_ENDPOINT', '/api/auth')
+  .constant('USERS_ENDPOINT', '/api/users')
+  .constant('ENDPOINTS_ENDPOINT', '/api/endpoints')
+  .constant('TEMPLATES_ENDPOINT', '/api/templates')
+  .constant('PAGINATION_MAX_ITEMS', 10)
+  .constant('UI_VERSION', 'v1.11.0');

app/components/auth/auth.html

@@ -0,0 +1,101 @@
+<div class="page-wrapper">
+  <!-- login box -->
+  <div class="container simple-box">
+    <div class="col-md-6 col-md-offset-3 col-sm-6 col-sm-offset-3">
+      <!-- login box logo -->
+      <div class="row">
+        <img ng-if="logo" ng-src="{{ logo }}" class="simple-box-logo">
+        <img ng-if="!logo" src="images/logo_alt.png" class="simple-box-logo" alt="Portainer">
+      </div>
+      <!-- !login box logo -->
+      <!-- init password panel -->
+      <div class="panel panel-default" ng-if="initPassword">
+        <div class="panel-body">
+          <!-- init password form -->
+          <form class="login-form form-horizontal" enctype="multipart/form-data" method="POST">
+            <!-- comment -->
+            <div class="input-group">
+              <p style="margin: 5px;">
+                Please specify a password for the <b>admin</b> user account.
+              </p>
+            </div>
+            <!-- !comment input -->
+            <!-- comment -->
+            <div class="input-group">
+              <p style="margin: 5px;">
+                <i ng-class="{true: 'fa fa-check green-icon', false: 'fa fa-times red-icon'}[initPasswordData.password.length >= 8]" aria-hidden="true"></i>
+                Your password must be at least 8 characters long
+              </p>
+            </div>
+            <!-- !comment input -->
+            <!-- password input -->
+            <div class="input-group">
+              <span class="input-group-addon"><i class="fa fa-lock" aria-hidden="true"></i></span>
+              <input id="admin_password" type="password" class="form-control" name="password" ng-model="initPasswordData.password" autofocus>
+            </div>
+            <!-- !password input -->
+            <!-- comment -->
+            <div class="input-group">
+              <p style="margin: 5px;">
+                <i ng-class="{true: 'fa fa-check green-icon', false: 'fa fa-times red-icon'}[initPasswordData.password !== '' && initPasswordData.password === initPasswordData.password_confirmation]" aria-hidden="true"></i>
+                Confirm your password
+              </p>
+            </div>
+            <!-- !comment input -->
+            <!-- password confirmation input -->
+            <div class="input-group">
+              <span class="input-group-addon"><i class="fa fa-lock" aria-hidden="true"></i></span>
+              <input id="password_confirmation" type="password" class="form-control" name="password" ng-model="initPasswordData.password_confirmation">
+            </div>
+            <!-- !password confirmation input -->
+            <!-- validate button -->
+            <div class="form-group">
+              <div class="col-sm-12 controls">
+                <p class="pull-left text-danger" ng-if="initPasswordData.error" style="margin: 5px;">
+                  <i class="fa fa-exclamation-circle" aria-hidden="true"></i> Unable to create default user
+                </p>
+                <button type="submit" class="btn btn-primary pull-right" ng-disabled="initPasswordData.password.length < 8 || initPasswordData.password !== initPasswordData.password_confirmation" ng-click="createAdminUser()"><i class="fa fa-key" aria-hidden="true"></i> Validate</button>
+              </div>
+            </div>
+            <!-- !validate button -->
+          </form>
+          <!-- !init password form -->
+        </div>
+      </div>
+      <!-- !init password panel -->
+      <!-- login panel -->
+      <div class="panel panel-default" ng-if="!initPassword">
+        <div class="panel-body">
+          <!-- login form -->
+          <form class="login-form form-horizontal" enctype="multipart/form-data" method="POST">
+            <!-- username input -->
+            <div class="input-group">
+              <span class="input-group-addon"><i class="fa fa-user" aria-hidden="true"></i></span>
+              <input id="username" type="text" class="form-control" name="username" ng-model="authData.username" placeholder="Username">
+            </div>
+            <!-- !username input -->
+            <!-- password input -->
+            <div class="input-group">
+              <span class="input-group-addon"><i class="fa fa-lock" aria-hidden="true"></i></span>
+              <input id="password" type="password" class="form-control" name="password" ng-model="authData.password" autofocus>
+            </div>
+            <!-- !password input -->
+            <!-- login button -->
+            <div class="form-group">
+              <div class="col-sm-12 controls">
+                <p class="pull-left text-danger" ng-if="authData.error" style="margin: 5px;">
+                  <i class="fa fa-exclamation-circle" aria-hidden="true"></i> {{ authData.error }}
+                </p>
+                <button type="submit" class="btn btn-primary pull-right" ng-click="authenticateUser()"><i class="fa fa-sign-in" aria-hidden="true"></i> Login</button>
+              </div>
+            </div>
+            <!-- !login button -->
+          </form>
+          <!-- !login form -->
+        </div>
+      </div>
+      <!-- !login panel -->
+    </div>
+  </div>
+  <!-- !login box -->
+</div>

app/components/auth/authController.js

@@ -0,0 +1,75 @@
+angular.module('auth', [])
+.controller('AuthenticationController', ['$scope', '$state', '$stateParams', '$window', '$timeout', '$sanitize', 'Config', 'Authentication', 'Users', 'EndpointService', 'Messages',
+function ($scope, $state, $stateParams, $window, $timeout, $sanitize, Config, Authentication, Users, EndpointService, Messages) {
+
+  $scope.authData = {
+    username: 'admin',
+    password: '',
+    error: ''
+  };
+  $scope.initPasswordData = {
+    password: '',
+    password_confirmation: '',
+    error: false
+  };
+
+  if ($stateParams.logout) {
+    Authentication.logout();
+  }
+
+  if ($stateParams.error) {
+    $scope.authData.error = $stateParams.error;
+    Authentication.logout();
+  }
+
+  if (Authentication.isAuthenticated()) {
+    $state.go('dashboard');
+  }
+
+  Config.$promise.then(function (c) {
+    $scope.logo = c.logo;
+  });
+
+  Users.checkAdminUser({}, function (d) {},
+  function (e) {
+    if (e.status === 404) {
+      $scope.initPassword = true;
+    } else {
+      Messages.error("Failure", e, 'Unable to verify administrator account existence');
+    }
+  });
+
+  $scope.createAdminUser = function() {
+    var password = $sanitize($scope.initPasswordData.password);
+    Users.initAdminUser({password: password}, function (d) {
+      $scope.initPassword = false;
+      $timeout(function() {
+        var element = $window.document.getElementById('password');
+        if(element) {
+          element.focus();
+        }
+      });
+    }, function (e) {
+      $scope.initPassword.error = true;
+    });
+  };
+
+  $scope.authenticateUser = function() {
+    $scope.authenticationError = false;
+    var username = $sanitize($scope.authData.username);
+    var password = $sanitize($scope.authData.password);
+    Authentication.login(username, password).then(function success() {
+      EndpointService.getActive().then(function success(data) {
+        $state.go('dashboard');
+      }, function error(err) {
+        if (err.status === 404) {
+          $state.go('endpointInit');
+        } else {
+          Messages.error("Failure", err, 'Unable to verify Docker endpoint existence');
+        }
+      });
+    }, function error() {
+      $scope.authData.error = 'Invalid credentials';
+    });
+  };
+}]);

app/components/container/container.html

@@ -3,7 +3,7 @@
     <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>
-    Containers > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a>
+    <a ui-sref="containers">Containers</a> > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a>
   </rd-header-content>
 </rd-header>
 
@@ -13,13 +13,13 @@
       <rd-widget-header icon="fa-cogs" title="Actions"></rd-widget-header>
       <rd-widget-body classes="padding">
         <div class="btn-group" role="group" aria-label="...">
-          <button class="btn btn-primary" ng-click="start()" ng-if="!container.State.Running"><i class="fa fa-play btn-ico" aria-hidden="true"></i>Start</button>
-          <button class="btn btn-danger" ng-click="stop()" ng-if="container.State.Running"><i class="fa fa-stop btn-ico" aria-hidden="true"></i>Stop</button>
-          <button class="btn btn-danger" ng-click="kill()" ng-if="container.State.Running"><i class="fa fa-bomb btn-ico" aria-hidden="true"></i>Kill</button>
-          <button class="btn btn-primary" ng-click="restart()" ng-if="container.State.Running"><i class="fa fa-refresh btn-ico" aria-hidden="true"></i>Restart</button>
-          <button class="btn btn-primary" ng-click="pause()" ng-if="container.State.Running && !container.State.Paused"><i class="fa fa-pause btn-ico" aria-hidden="true"></i>Pause</button>
-          <button class="btn btn-primary" ng-click="unpause()" ng-if="container.State.Paused"><i class="fa fa-play btn-ico" aria-hidden="true"></i>Resume</button>
-          <button class="btn btn-danger" ng-click="remove()" ng-disabled="container.State.Running"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Remove</button>
+          <button class="btn btn-primary" ng-click="start()" ng-if="!container.State.Running"><i class="fa fa-play space-right" aria-hidden="true"></i>Start</button>
+          <button class="btn btn-danger" ng-click="stop()" ng-if="container.State.Running"><i class="fa fa-stop space-right" aria-hidden="true"></i>Stop</button>
+          <button class="btn btn-danger" ng-click="kill()" ng-if="container.State.Running"><i class="fa fa-bomb space-right" aria-hidden="true"></i>Kill</button>
+          <button class="btn btn-primary" ng-click="restart()" ng-if="container.State.Running"><i class="fa fa-refresh space-right" aria-hidden="true"></i>Restart</button>
+          <button class="btn btn-primary" ng-click="pause()" ng-if="container.State.Running && !container.State.Paused"><i class="fa fa-pause space-right" aria-hidden="true"></i>Pause</button>
+          <button class="btn btn-primary" ng-click="unpause()" ng-if="container.State.Paused"><i class="fa fa-play space-right" aria-hidden="true"></i>Resume</button>
+          <button class="btn btn-danger" ng-click="remove()" ng-disabled="container.State.Running"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
         </div>
       </rd-widget-body>
     </rd-widget>
@@ -40,9 +40,11 @@
                 <a href="" data-toggle="tooltip" title="Edit container name" ng-click="container.edit = true;"><i class="fa fa-edit"></i></a>
               </td>
               <td ng-if="container.edit">
-                <input type="text" class="containerNameInput" ng-model="container.newContainerName">
-                <a href="" ng-click="container.edit = false;"><i class="fa fa-times"></i></a>
-                <a href="" ng-click="renameContainer()"><i class="fa fa-check-square-o"></i></a>
+                <form ng-submit="renameContainer()">
+                  <input type="text" class="containerNameInput" ng-model="container.newContainerName">
+                  <a href="" ng-click="container.edit = false;"><i class="fa fa-times"></i></a>
+                  <a href="" ng-click="renameContainer()"><i class="fa fa-check-square-o"></i></a>
+                </form>
               </td>
             </tr>
             <tr ng-if="container.NetworkSettings.IPAddress">
@@ -52,7 +54,7 @@
             <tr>
               <td>Status</td>
               <td>
-                <i ng-class="{true: 'fa fa-heartbeat text-icon green-icon', false: 'fa fa-heartbeat text-icon red-icon'}[container.State.Running]"></i>
+                <i ng-class="{true: 'fa fa-heartbeat space-right green-icon', false: 'fa fa-heartbeat space-right red-icon'}[container.State.Running]"></i>
                 {{ container.State|getstatetext }} since {{ activityTime }}<span ng-if="!container.State.Running"> with exit code {{ container.State.ExitCode }}</span>
               </td>
             </tr>
@@ -67,9 +69,9 @@
             <tr>
               <td colspan="2">
                 <div class="btn-group" role="group" aria-label="...">
-                  <a class="btn btn-outline-secondary" type="button" ui-sref="stats({id: container.Id})"><i class="fa fa-area-chart btn-ico" aria-hidden="true"></i>Stats</a>
-                  <a class="btn btn-outline-secondary" type="button" ui-sref="logs({id: container.Id})"><i class="fa fa-exclamation-circle btn-ico" aria-hidden="true"></i>Logs</a>
-                  <a class="btn btn-outline-secondary" type="button" ui-sref="console({id: container.Id})"><i class="fa fa-terminal btn-ico" aria-hidden="true"></i>Console</a>
+                  <a class="btn btn-outline-secondary" type="button" ui-sref="stats({id: container.Id})"><i class="fa fa-area-chart space-right" aria-hidden="true"></i>Stats</a>
+                  <a class="btn btn-outline-secondary" type="button" ui-sref="logs({id: container.Id})"><i class="fa fa-exclamation-circle space-right" aria-hidden="true"></i>Logs</a>
+                  <a class="btn btn-outline-secondary" type="button" ui-sref="console({id: container.Id})"><i class="fa fa-terminal space-right" aria-hidden="true"></i>Console</a>
                 </div>
               </td>
             </tr>
@@ -202,3 +204,36 @@
     </rd-widget>
   </div>
 </div>
+
+<div class="row" ng-if="!(container.NetworkSettings.Networks | emptyobject)">
+  <div class="col-lg-12 col-md-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-sitemap" title="Connected networks"></rd-widget-header>
+      <rd-widget-body classes="no-padding">
+        <table class="table">
+          <thead>
+            <th>Network Name</th>
+            <th>IP Address</th>
+            <th>Gateway</th>
+            <th>MacAddress</th>
+            <th>Actions</th>
+          </thead>
+          <tbody>
+            <tr dir-paginate="(key, value) in container.NetworkSettings.Networks | itemsPerPage: pagination_count">
+              <td><a ui-sref="network({id: value.NetworkID})">{{ key }}</a></td>
+              <td>{{ value.IPAddress || '-' }}</td>
+              <td>{{ value.Gateway || '-' }}</td>
+              <td>{{ value.MacAddress || '-' }}</td>
+              <td>
+                <button type="button" class="btn btn-xs btn-danger" ng-click="containerLeaveNetwork(container, value.NetworkID)"><i class="fa fa-trash space-right" aria-hidden="true"></i>Leave Network</button>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+        <div class="pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>

app/components/container/containerController.js

@@ -1,12 +1,13 @@
 angular.module('container', [])
-.controller('ContainerController', ['$scope', '$state','$stateParams', '$filter', 'Container', 'ContainerCommit', 'ImageHelper', 'Messages',
-function ($scope, $state, $stateParams, $filter, Container, ContainerCommit, ImageHelper, Messages) {
+.controller('ContainerController', ['$scope', '$state','$stateParams', '$filter', 'Container', 'ContainerCommit', 'ImageHelper', 'Network', 'Messages', 'Settings',
+function ($scope, $state, $stateParams, $filter, Container, ContainerCommit, ImageHelper, Network, Messages, Settings) {
   $scope.activityTime = 0;
   $scope.portBindings = [];
   $scope.config = {
     Image: '',
     Registry: ''
   };
+  $scope.pagination_count = Settings.pagination_count;
 
   var update = function () {
     $('#loadingViewSpinner').show();
@@ -76,7 +77,7 @@ function ($scope, $state, $stateParams, $filter, Container, ContainerCommit, Ima
     $('#createImageSpinner').show();
     var image = _.toLower($scope.config.Image);
     var registry = _.toLower($scope.config.Registry);
-    var imageConfig = ImageHelper.createImageConfig(image, registry);
+    var imageConfig = ImageHelper.createImageConfigForCommit(image, registry);
     ContainerCommit.commit({id: $stateParams.id, tag: imageConfig.tag, repo: imageConfig.repo}, function (d) {
       $('#createImageSpinner').hide();
       update();
@@ -153,5 +154,22 @@ function ($scope, $state, $stateParams, $filter, Container, ContainerCommit, Ima
     $scope.container.edit = false;
   };
 
+  $scope.containerLeaveNetwork = function containerLeaveNetwork(container, networkId) {
+    $('#loadingViewSpinner').show();
+    Network.disconnect({id: networkId}, { Container: $stateParams.id, Force: false }, function (d) {
+      if (d.message) {
+        $('#loadingViewSpinner').hide();
+        Messages.send("Error", {}, d.message);
+      } else {
+        $('#loadingViewSpinner').hide();
+        Messages.send("Container left network", $stateParams.id);
+        $state.go('container', {id: $stateParams.id}, {reload: true});
+      }
+    }, function (e) {
+      $('#loadingViewSpinner').hide();
+      Messages.error("Failure", e, "Unable to disconnect container from network");
+    });
+  };
+
   update();
 }]);

app/components/containerConsole/containerConsole.html

@@ -2,12 +2,12 @@
   <rd-header-title title="Container console">
     <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
-  <rd-header-content>
-    Containers > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a> > Console
+  <rd-header-content ng-if="state.loaded">
+    <a ui-sref="containers">Containers</a> > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a> > Console
   </rd-header-content>
 </rd-header>
 
-<div class="row">
+<div class="row" ng-if="state.loaded">
   <div class="col-lg-12 col-md-12 col-xs-12">
     <rd-widget>
       <rd-widget-header icon="fa-terminal" title="Console">
@@ -16,18 +16,27 @@
         </div>
       </rd-widget-header>
       <rd-widget-body>
-        <form class="form-horizontal">
-          <!-- command-list -->
-          <div class="form-group">
-            <div class="col-sm-3">
-              <select class="selectpicker form-control" ng-model="state.command">
-                <option value="bash">/bin/bash</option>
-                <option value="sh">/bin/sh</option>
-              </select>
+        <form>
+          <div class="row">
+            <!-- command-list -->
+            <div class="col-sm-4">
+              <div class="input-group">
+                <span class="input-group-addon">
+                  <i class="fa fa-linux" aria-hidden="true" ng-if="imageOS == 'linux'"></i>
+                  <i class="fa fa-windows" aria-hidden="true" ng-if="imageOS == 'windows'"></i>
+                </span>
+                <select class="form-control" ng-model="state.command" id="command">
+                  <option value="bash" ng-if="imageOS == 'linux'">/bin/bash</option>
+                  <option value="sh" ng-if="imageOS == 'linux'">/bin/sh</option>
+                  <option value="powershell" ng-if="imageOS == 'windows'">powershell</option>
+                  <option value="cmd.exe" ng-if="imageOS == 'windows'">cmd.exe</option>
+                </select>
+              </div>
             </div>
-            <div class="col-sm-9 pull-left">
-              <button type="button" class="btn btn-primary" ng-click="connect()" ng-disabled="connected">Connect</button>
-              <button type="button" class="btn btn-default" ng-click="disconnect()" ng-disabled="!connected">Disconnect</button>
+            <!-- !command-list -->
+            <div class="col-sm-8">
+              <button type="button" class="btn btn-primary" ng-click="connect()" ng-disabled="state.connected">Connect</button>
+              <button type="button" class="btn btn-default" ng-click="disconnect()" ng-disabled="!state.connected">Disconnect</button>
             </div>
           </div>
         </form>

app/components/containerConsole/containerConsoleController.js

@@ -1,9 +1,9 @@
 angular.module('containerConsole', [])
-.controller('ContainerConsoleController', ['$scope', '$stateParams', 'Settings', 'Container', 'Exec', '$timeout', 'Messages',
-function ($scope, $stateParams, Settings, Container, Exec, $timeout, Messages) {
+.controller('ContainerConsoleController', ['$scope', '$stateParams', 'Settings', 'Container', 'Image', 'Exec', '$timeout', 'Messages',
+function ($scope, $stateParams, Settings, Container, Image, Exec, $timeout, Messages) {
   $scope.state = {};
-  $scope.state.command = "bash";
-  $scope.connected = false;
+  $scope.state.loaded = false;
+  $scope.state.connected = false;
 
   var socket, term;
 
@@ -16,6 +16,22 @@ function ($scope, $stateParams, Settings, Container, Exec, $timeout, Messages) {
 
   Container.get({id: $stateParams.id}, function(d) {
     $scope.container = d;
+    if (d.message) {
+      Messages.error("Error", d, 'Unable to retrieve container details');
+      $('#loadingViewSpinner').hide();
+    } else {
+      Image.get({id: d.Image}, function(imgData) {
+        $scope.imageOS = imgData.Os;
+        $scope.state.command = imgData.Os === 'windows' ? 'powershell' : 'bash';
+        $scope.state.loaded = true;
+        $('#loadingViewSpinner').hide();
+      }, function (e) {
+        Messages.error("Failure", e, 'Unable to retrieve image details');
+        $('#loadingViewSpinner').hide();
+      });
+    }
+  }, function (e) {
+    Messages.error("Failure", e, 'Unable to retrieve container details');
     $('#loadingViewSpinner').hide();
   });
 
@@ -39,7 +55,7 @@ function ($scope, $stateParams, Settings, Container, Exec, $timeout, Messages) {
       } else {
         var execId = d.Id;
         resizeTTY(execId, termHeight, termWidth);
-        var url = window.location.href.split('#')[0] + 'ws/exec?id=' + execId;
+        var url = window.location.href.split('#')[0] + 'api/websocket/exec?id=' + execId;
         if (url.indexOf('https') > -1) {
           url = url.replace('https://', 'wss://');
         } else {
@@ -54,7 +70,7 @@ function ($scope, $stateParams, Settings, Container, Exec, $timeout, Messages) {
   };
 
   $scope.disconnect = function() {
-    $scope.connected = false;
+    $scope.state.connected = false;
     if (socket !== null) {
       socket.close();
     }
@@ -79,7 +95,7 @@ function ($scope, $stateParams, Settings, Container, Exec, $timeout, Messages) {
   function initTerm(url, height, width) {
     socket = new WebSocket(url);
 
-    $scope.connected = true;
+    $scope.state.connected = true;
     socket.onopen = function(evt) {
       $('#loadConsoleSpinner').hide();
       term = new Terminal();
@@ -95,11 +111,10 @@ function ($scope, $stateParams, Settings, Container, Exec, $timeout, Messages) {
         term.write(e.data);
       };
       socket.onerror = function (error) {
-        $scope.connected = false;
-
+        $scope.state.connected = false;
       };
       socket.onclose = function(evt) {
-        $scope.connected = false;
+        $scope.state.connected = false;
       };
     };
   }

app/components/containerLogs/containerlogs.html

@@ -3,7 +3,7 @@
       <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>
-    Containers > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a> > Logs
+    <a ui-sref="containers">Containers</a> > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a> > Logs
   </rd-header-content>
 </rd-header>
 

app/components/containers/containers.html

@@ -17,13 +17,13 @@
     <rd-widget-taskbar classes="col-lg-12">
       <div class="pull-left">
         <div class="btn-group" role="group" aria-label="...">
-          <button type="button" class="btn btn-primary btn-responsive" ng-click="startAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-play btn-ico" aria-hidden="true"></i>Start</button>
-          <button type="button" class="btn btn-primary btn-responsive" ng-click="stopAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-stop btn-ico" aria-hidden="true"></i>Stop</button>
-          <button type="button" class="btn btn-primary btn-responsive" ng-click="killAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-bomb btn-ico" aria-hidden="true"></i>Kill</button>
-          <button type="button" class="btn btn-primary btn-responsive" ng-click="restartAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-refresh btn-ico" aria-hidden="true"></i>Restart</button>
-          <button type="button" class="btn btn-primary btn-responsive" ng-click="pauseAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-pause btn-ico" aria-hidden="true"></i>Pause</button>
-          <button type="button" class="btn btn-primary btn-responsive" ng-click="unpauseAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-play btn-ico" aria-hidden="true"></i>Resume</button>
-          <button type="button" class="btn btn-danger btn-responsive" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Remove</button>
+          <button type="button" class="btn btn-primary btn-responsive" ng-click="startAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-play space-right" aria-hidden="true"></i>Start</button>
+          <button type="button" class="btn btn-primary btn-responsive" ng-click="stopAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-stop space-right" aria-hidden="true"></i>Stop</button>
+          <button type="button" class="btn btn-primary btn-responsive" ng-click="killAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-bomb space-right" aria-hidden="true"></i>Kill</button>
+          <button type="button" class="btn btn-primary btn-responsive" ng-click="restartAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-refresh space-right" aria-hidden="true"></i>Restart</button>
+          <button type="button" class="btn btn-primary btn-responsive" ng-click="pauseAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-pause space-right" aria-hidden="true"></i>Pause</button>
+          <button type="button" class="btn btn-primary btn-responsive" ng-click="unpauseAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-play space-right" aria-hidden="true"></i>Resume</button>
+          <button type="button" class="btn btn-danger btn-responsive" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
         </div>
         <a class="btn btn-default btn-responsive" type="button" ui-sref="actions.create.container">Add container</a>
       </div>
@@ -66,7 +66,7 @@
                   <span ng-show="sortType == 'IP' && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
                 </a>
               </th>
-              <th ng-if="swarm && !swarm_mode">
+              <th ng-if="endpointMode.provider === 'DOCKER_SWARM'">
                 <a ui-sref="containers" ng-click="order('Host')">
                   Host IP
                   <span ng-show="sortType == 'Host' && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
@@ -83,14 +83,14 @@
             </tr>
           </thead>
           <tbody>
-            <tr ng-repeat="container in (state.filteredContainers = ( containers | filter:state.filter | orderBy:sortType:sortReverse))">
+            <tr dir-paginate="container in (state.filteredContainers = ( containers | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
               <td><input type="checkbox" ng-model="container.Checked" ng-change="selectItem(container)"/></td>
-              <td><span class="label label-{{ container.Status|containerstatusbadge }}">{{ container.Status|containerstatus }}</span></td>
-              <td ng-if="swarm && !swarm_mode"><a ui-sref="container({id: container.Id})">{{ container|swarmcontainername}}</a></td>
-              <td ng-if="!swarm || swarm_mode"><a ui-sref="container({id: container.Id})">{{ container|containername}}</a></td>
+              <td><span class="label label-{{ container.Status|containerstatusbadge }}">{{ container.Status }}</span></td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM'"><a ui-sref="container({id: container.Id})">{{ container|swarmcontainername}}</a></td>
+              <td ng-if="endpointMode.provider !== 'DOCKER_SWARM'"><a ui-sref="container({id: container.Id})">{{ container|containername}}</a></td>
               <td><a ui-sref="image({id: container.Image})">{{ container.Image }}</a></td>
               <td ng-if="state.displayIP">{{ container.IP ? container.IP : '-' }}</td>
-              <td ng-if="swarm && !swarm_mode">{{ container.hostIP }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM'">{{ container.hostIP }}</td>
               <td>
                 <a ng-if="container.Ports.length > 0" ng-repeat="p in container.Ports" class="image-tag" ng-href="http://{{p.host}}:{{p.public}}" target="_blank">
                   <i class="fa fa-external-link" aria-hidden="true"></i> {{p.public}}:{{ p.private }}
@@ -98,11 +98,17 @@
                 <span ng-if="container.Ports.length == 0" >-</span>
               </td>
             </tr>
+            <tr ng-if="!containers">
+              <td colspan="8" class="text-center text-muted">Loading...</td>
+            </tr>
             <tr ng-if="containers.length == 0">
               <td colspan="8" class="text-center text-muted">No containers available.</td>
             </tr>
           </tbody>
         </table>
+        <div ng-if="containers" class="pull-left pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </div>
     </rd-widget-body>
   <rd-widget>

app/components/containers/containersController.js

@@ -1,15 +1,13 @@
 angular.module('containers', [])
-.controller('ContainersController', ['$scope', 'Container', 'ContainerHelper', 'Info', 'Settings', 'Messages', 'Config',
-function ($scope, Container, ContainerHelper, Info, Settings, Messages, Config) {
+.controller('ContainersController', ['$scope', '$filter', 'Container', 'ContainerHelper', 'Info', 'Settings', 'Messages', 'Config',
+function ($scope, $filter, Container, ContainerHelper, Info, Settings, Messages, Config) {
   $scope.state = {};
   $scope.state.displayAll = Settings.displayAll;
   $scope.state.displayIP = false;
   $scope.sortType = 'State';
   $scope.sortReverse = false;
   $scope.state.selectedItemCount = 0;
-  $scope.swarm_mode = false;
-  $scope.containers = [];
-
+  $scope.pagination_count = Settings.pagination_count;
   $scope.order = function (sortType) {
     $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
     $scope.sortType = sortType;
@@ -25,15 +23,21 @@ function ($scope, Container, ContainerHelper, Info, Settings, Messages, Config)
       }
       $scope.containers = containers.map(function (container) {
         var model = new ContainerViewModel(container);
+        model.Status = $filter('containerstatus')(model.Status);
+
         if (model.IP) {
           $scope.state.displayIP = true;
         }
-        if ($scope.swarm && !$scope.swarm_mode) {
+        if ($scope.endpointMode.provider === 'DOCKER_SWARM') {
           model.hostIP = $scope.swarm_hosts[_.split(container.Names[0], '/')[1]];
         }
         return model;
       });
       $('#loadContainersSpinner').hide();
+    }, function (e) {
+      $('#loadContainersSpinner').hide();
+      Messages.error("Failure", e, "Unable to retrieve containers");
+      $scope.containers = [];
     });
   };
 
@@ -146,17 +150,11 @@ function ($scope, Container, ContainerHelper, Info, Settings, Messages, Config)
     return swarm_hosts;
   }
 
-  $scope.swarm = false;
   Config.$promise.then(function (c) {
     $scope.containersToHideLabels = c.hiddenLabels;
-    $scope.swarm = c.swarm;
-    if (c.swarm) {
+    if ($scope.endpointMode.provider === 'DOCKER_SWARM') {
       Info.get({}, function (d) {
-        if (!_.startsWith(d.ServerVersion, 'swarm')) {
-          $scope.swarm_mode = true;
-        } else {
-          $scope.swarm_hosts = retrieveSwarmHostsInfo(d);
-        }
+        $scope.swarm_hosts = retrieveSwarmHostsInfo(d);
         update({all: Settings.displayAll ? 1 : 0});
       });
     } else {

app/components/createContainer/createContainerController.js

@@ -1,21 +1,20 @@
 angular.module('createContainer', [])
-.controller('CreateContainerController', ['$scope', '$state', 'Config', 'Info', 'Container', 'Image', 'Volume', 'Network', 'Messages',
-function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messages) {
-
-  $scope.state = {
-    alwaysPull: true
-  };
+.controller('CreateContainerController', ['$scope', '$state', '$stateParams', '$filter', 'Config', 'Info', 'Container', 'ContainerHelper', 'Image', 'ImageHelper', 'Volume', 'Network', 'Messages',
+function ($scope, $state, $stateParams, $filter, Config, Info, Container, ContainerHelper, Image, ImageHelper, Volume, Network, Messages) {
 
   $scope.formValues = {
+    alwaysPull: true,
     Console: 'none',
     Volumes: [],
-    AvailableRegistries: [],
-    Registry: ''
+    Registry: '',
+    NetworkContainer: '',
+    Labels: []
   };
 
   $scope.imageConfig = {};
 
   $scope.config = {
+    Image: '',
     Env: [],
     ExposedPorts: {},
     HostConfig: {
@@ -26,7 +25,8 @@ function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messa
       Binds: [],
       NetworkMode: 'bridge',
       Privileged: false
-    }
+    },
+    Labels: {}
   };
 
   $scope.addVolume = function() {
@@ -53,15 +53,16 @@ function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messa
     $scope.config.HostConfig.PortBindings.splice(index, 1);
   };
 
-  Config.$promise.then(function (c) {
-    var swarm = c.swarm;
-    Info.get({}, function(info) {
-      if (swarm && !_.startsWith(info.ServerVersion, 'swarm')) {
-        $scope.swarm_mode = true;
-      }
-    });
+  $scope.addLabel = function() {
+    $scope.formValues.Labels.push({ name: '', value: ''});
+  };
 
-    $scope.formValues.AvailableRegistries = c.registries;
+  $scope.removeLabel = function(index) {
+    $scope.formValues.Labels.splice(index, 1);
+  };
+
+  Config.$promise.then(function (c) {
+    var containersToHideLabels = c.hiddenLabels;
 
     Volume.query({}, function (d) {
       $scope.availableVolumes = d.Volumes;
@@ -71,7 +72,7 @@ function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messa
 
     Network.query({}, function (d) {
       var networks = d;
-      if (swarm) {
+      if ($scope.endpointMode.provider === 'DOCKER_SWARM' || $scope.endpointMode.provider === 'DOCKER_SWARM_MODE') {
         networks = d.filter(function (network) {
           if (network.Scope === 'global') {
             return network;
@@ -82,10 +83,24 @@ function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messa
         networks.push({Name: "host"});
         networks.push({Name: "none"});
       }
+      networks.push({Name: "container"});
       $scope.availableNetworks = networks;
+      if (!_.find(networks, {'Name': 'bridge'})) {
+        $scope.config.HostConfig.NetworkMode = 'nat';
+      }
     }, function (e) {
       Messages.error("Failure", e, "Unable to retrieve networks");
     });
+
+    Container.query({}, function (d) {
+      var containers = d;
+      if (containersToHideLabels) {
+        containers = ContainerHelper.hideContainers(d, containersToHideLabels);
+      }
+      $scope.runningContainers = containers;
+    }, function(e) {
+      Messages.error("Failure", e, "Unable to retrieve running containers");
+    });
   });
 
   // TODO: centralize, already present in templatesController
@@ -118,37 +133,17 @@ function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messa
   // TODO: centralize, already present in templatesController
   function pullImageAndCreateContainer(config) {
     Image.create($scope.imageConfig, function (data) {
-      var err = data.length > 0 && data[data.length - 1].hasOwnProperty('error');
-      if (err) {
-        var detail = data[data.length - 1];
-        $('#createContainerSpinner').hide();
-        Messages.error('Error', {}, detail.error);
-      } else {
-        createContainer(config);
-      }
+      createContainer(config);
     }, function (e) {
       $('#createContainerSpinner').hide();
       Messages.error('Failure', e, 'Unable to pull image');
     });
   }
 
-  function createImageConfig(imageName, registry) {
-    var imageNameAndTag = imageName.split(':');
-    var image = imageNameAndTag[0];
-    if (registry) {
-      image = registry + '/' + imageNameAndTag[0];
-    }
-    var imageConfig = {
-      fromImage: image,
-      tag: imageNameAndTag[1] ? imageNameAndTag[1] : 'latest'
-    };
-    return imageConfig;
-  }
-
   function prepareImageConfig(config) {
     var image = _.toLower(config.Image);
     var registry = $scope.formValues.Registry;
-    var imageConfig = createImageConfig(image, registry);
+    var imageConfig = ImageHelper.createImageConfigForContainer(image, registry);
     config.Image = imageConfig.fromImage + ':' + imageConfig.tag;
     $scope.imageConfig = imageConfig;
   }
@@ -219,24 +214,52 @@ function ($scope, $state, Config, Info, Container, Image, Volume, Network, Messa
     config.Volumes = volumes;
   }
 
+  function prepareNetworkConfig(config) {
+    var mode = config.HostConfig.NetworkMode;
+    var container = $scope.formValues.NetworkContainer;
+    var containerName = container;
+    if (container && typeof container === 'object') {
+      containerName = $filter('trimcontainername')(container.Names[0]);
+      if ($scope.endpointMode.provider === 'DOCKER_SWARM') {
+        containerName = $filter('swarmcontainername')(container);
+      }
+    }
+    var networkMode = mode;
+    if (containerName) {
+      networkMode += ':' + containerName;
+    }
+    config.HostConfig.NetworkMode = networkMode;
+  }
+
+  function prepareLabels(config) {
+    var labels = {};
+    $scope.formValues.Labels.forEach(function (label) {
+      if (label.name && label.value) {
+        labels[label.name] = label.value;
+      }
+    });
+    config.Labels = labels;
+  }
+
   function prepareConfiguration() {
     var config = angular.copy($scope.config);
+    prepareNetworkConfig(config);
     prepareImageConfig(config);
     preparePortBindings(config);
     prepareConsole(config);
     prepareEnvironmentVariables(config);
     prepareVolumes(config);
+    prepareLabels(config);
     return config;
   }
 
   $scope.create = function () {
     var config = prepareConfiguration();
     $('#createContainerSpinner').show();
-    if ($scope.state.alwaysPull) {
+    if ($scope.formValues.alwaysPull) {
       pullImageAndCreateContainer(config);
     } else {
       createContainer(config);
     }
   };
-
 }]);

app/components/createContainer/createcontainer.html

@@ -1,7 +1,7 @@
 <rd-header>
   <rd-header-title title="Create container"></rd-header-title>
   <rd-header-content>
-    Containers > Add container
+    <a ui-sref="containers">Containers</a> > Add container
   </rd-header-content>
 </rd-header>
 
@@ -31,7 +31,7 @@
             <div class="col-sm-offset-1 col-sm-11">
               <div class="checkbox">
                 <label>
-                  <input type="checkbox" ng-model="state.alwaysPull"> Always pull image before creating
+                  <input type="checkbox" ng-model="formValues.alwaysPull"> Always pull image before creating
                 </label>
               </div>
             </div>
@@ -53,6 +53,10 @@
                 <input type="radio" name="container_restart_policy" ng-model="config.HostConfig.RestartPolicy.Name" value="on-failure">
                 <span class="radio-value">On failure</span>
               </label>
+              <label class="radio-inline">
+                <input type="radio" name="container_restart_policy" ng-model="config.HostConfig.RestartPolicy.Name" value="unless-stopped">
+                <span class="radio-value">Unless stopped</span>
+              </label>
             </div>
           </div>
           <!-- !restart-policy -->
@@ -60,7 +64,7 @@
           <div class="form-group">
             <label for="container_ports" class="col-sm-1 control-label text-left">Port mapping</label>
             <div class="col-sm-11">
-              <span class="label label-default clickable" ng-click="addPortBinding()">
+              <span class="label label-default interactive" ng-click="addPortBinding()">
                 <i class="fa fa-plus-circle" aria-hidden="true"></i> map port
               </span>
             </div>
@@ -76,7 +80,7 @@
                   <input type="text" class="form-control" ng-model="portBinding.containerPort" placeholder="e.g. 80">
                 </div>
                 <div class="input-group col-sm-1 input-group-sm">
-                  <select class="selectpicker form-control" ng-model="portBinding.protocol">
+                  <select class="form-control" ng-model="portBinding.protocol">
                     <option value="tcp">tcp</option>
                     <option value="udp">udp</option>
                   </select>
@@ -91,6 +95,16 @@
             <!-- !port-mapping-input-list -->
           </div>
           <!-- !port-mapping -->
+          <!-- labels -->
+          <div class="form-group">
+            <label for="container_labels" class="col-sm-1 control-label text-left">Labels</label>
+            <div class="col-sm-11">
+              <span class="label label-default interactive" ng-click="addLabel()">
+                <i class="fa fa-plus-circle" aria-hidden="true"></i> label
+              </span>
+            </div>
+          </div>
+          <!-- !labels-->
         </form>
       </rd-widget-body>
     </rd-widget>
@@ -102,10 +116,11 @@
     <rd-widget>
       <rd-widget-body>
         <ul class="nav nav-tabs">
-          <li class="active clickable"><a data-target="#command" data-toggle="tab">Command</a></li>
-          <li class="clickable"><a data-target="#volumes" data-toggle="tab">Volumes</a></li>
-          <li class="clickable"><a data-target="#network" data-toggle="tab">Network</a></li>
-          <li class="clickable"><a data-target="#security" data-toggle="tab">Security/Host</a></li>
+          <li class="active interactive"><a data-target="#command" data-toggle="tab">Command</a></li>
+          <li class="interactive"><a data-target="#volumes" data-toggle="tab">Volumes</a></li>
+          <li class="interactive"><a data-target="#network" data-toggle="tab">Network</a></li>
+          <li class="interactive"><a data-target="#labels" data-toggle="tab">Labels</a></li>
+          <li class="interactive"><a data-target="#security" data-toggle="tab">Security/Host</a></li>
         </ul>
         <!-- tab-content -->
         <div class="tab-content">
@@ -177,7 +192,7 @@
               <div class="form-group">
                 <label for="container_env" class="col-sm-1 control-label text-left">Environment variables</label>
                 <div class="col-sm-11">
-                  <span class="label label-default clickable" ng-click="addEnvironmentVariable()">
+                  <span class="label label-default interactive" ng-click="addEnvironmentVariable()">
                     <i class="fa fa-plus-circle" aria-hidden="true"></i> environment variable
                   </span>
                 </div>
@@ -212,7 +227,7 @@
               <div class="form-group">
                 <label for="container_volumes" class="col-sm-1 control-label text-left">Volumes</label>
                 <div class="col-sm-11">
-                  <span class="label label-default clickable" ng-click="addVolume()">
+                  <span class="label label-default interactive" ng-click="addVolume()">
                     <i class="fa fa-plus-circle" aria-hidden="true"></i> volume
                   </span>
                 </div>
@@ -228,7 +243,7 @@
                     </div>
                     <div class="input-group col-sm-5 input-group-sm">
                       <span class="input-group-addon"><input type="checkbox" ng-model="volume.isPath" ng-click="resetVolumePath($index)">Path</span>
-                      <select class="selectpicker form-control" ng-model="volume.name" ng-if="!volume.isPath">
+                      <select class="form-control" ng-model="volume.name" ng-if="!volume.isPath">
                         <option selected disabled hidden value="">Select a volume</option>
                         <option ng-repeat="vol in availableVolumes" ng-value="vol.Name">{{ vol.Name|truncate:30}}</option>
                       </select>
@@ -254,7 +269,7 @@
           <!-- tab-network -->
           <div class="tab-pane" id="network">
             <form class="form-horizontal" style="margin-top: 15px;">
-              <div class="form-group" ng-if="globalNetworkCount === 0 && !swarm_mode">
+              <div class="form-group" ng-if="globalNetworkCount === 0 && endpointMode.provider !== 'DOCKER_SWARM_MODE'">
                 <div class="col-sm-12">
                   <span class="small text-muted">You don't have any shared network. Head over the <a ui-sref="networks">networks view</a> to create one.</span>
                 </div>
@@ -263,13 +278,26 @@
               <div class="form-group">
                 <label for="container_network" class="col-sm-1 control-label text-left">Network</label>
                 <div class="col-sm-9">
-                  <select class="selectpicker form-control" ng-model="config.HostConfig.NetworkMode">
+                  <select class="form-control" ng-model="config.HostConfig.NetworkMode" id="container_network">
                     <option selected disabled hidden value="">Select a network</option>
                     <option ng-repeat="net in availableNetworks" ng-value="net.Name">{{ net.Name }}</option>
                   </select>
                 </div>
               </div>
               <!-- !network-input -->
+              <!-- container-name-input -->
+              <div class="form-group" ng-if="config.HostConfig.NetworkMode == 'container'">
+                <label for="container_network_container" class="col-sm-1 control-label text-left">Container</label>
+                <div class="col-sm-9">
+                  <select ng-if="endpointMode.provider !== 'DOCKER_SWARM'" ng-options="container|containername for container in runningContainers" class="form-control" ng-model="formValues.NetworkContainer">
+                    <option selected disabled hidden value="">Select a container</option>
+                  </select>
+                  <select ng-if="endpointMode.provider === 'DOCKER_SWARM'" ng-options="container|swarmcontainername for container in runningContainers" class="form-control" ng-model="formValues.NetworkContainer">
+                    <option selected disabled hidden value="">Select a container</option>
+                  </select>
+                </div>
+              </div>
+              <!-- !container-name-input -->
               <!-- hostname-input -->
               <div class="form-group">
                 <label for="container_hostname" class="col-sm-1 control-label text-left">Hostname</label>
@@ -289,6 +317,41 @@
             </form>
           </div>
           <!-- !tab-network -->
+          <!-- tab-labels -->
+          <div class="tab-pane" id="labels">
+            <form class="form-horizontal" style="margin-top: 15px;">
+              <!-- labels -->
+              <div class="form-group">
+                <label for="container_labels" class="col-sm-1 control-label text-left">Labels</label>
+                <div class="col-sm-11">
+                  <span class="label label-default interactive" ng-click="addLabel()">
+                    <i class="fa fa-plus-circle" aria-hidden="true"></i> label
+                  </span>
+                </div>
+                <!-- labels-input-list -->
+                <div class="col-sm-offset-1 col-sm-11 form-inline" style="margin-top: 10px;">
+                  <div ng-repeat="label in formValues.Labels" style="margin-top: 2px;">
+                    <div class="input-group col-sm-5 input-group-sm">
+                      <span class="input-group-addon">name</span>
+                      <input type="text" class="form-control" ng-model="label.name" placeholder="e.g. com.example.foo">
+                    </div>
+                    <div class="input-group col-sm-5 input-group-sm">
+                      <span class="input-group-addon">value</span>
+                      <input type="text" class="form-control" ng-model="label.value" placeholder="e.g. bar">
+                      <span class="input-group-btn">
+                        <button class="btn btn-default" type="button" ng-click="removeLabel($index)">
+                          <i class="fa fa-minus" aria-hidden="true"></i>
+                        </button>
+                      </span>
+                    </div>
+                  </div>
+                </div>
+                <!-- !labels-input-list -->
+              </div>
+              <!-- !labels-->
+            </form>
+          </div>
+          <!-- !tab-labels -->
           <!-- tab-security -->
           <div class="tab-pane" id="security">
             <form class="form-horizontal" style="margin-top: 15px;">

app/components/createNetwork/createNetworkController.js

@@ -4,7 +4,8 @@ function ($scope, $state, Messages, Network) {
   $scope.formValues = {
     DriverOptions: [],
     Subnet: '',
-    Gateway: ''
+    Gateway: '',
+    Labels: []
   };
 
   $scope.config = {
@@ -16,7 +17,8 @@ function ($scope, $state, Messages, Network) {
     IPAM: {
       Driver: 'default',
       Config: []
-    }
+    },
+    Labels: {}
   };
 
   $scope.addDriverOption = function() {
@@ -27,6 +29,14 @@ function ($scope, $state, Messages, Network) {
     $scope.formValues.DriverOptions.splice(index, 1);
   };
 
+  $scope.addLabel = function() {
+    $scope.formValues.Labels.push({ name: '', value: ''});
+  };
+
+  $scope.removeLabel = function(index) {
+    $scope.formValues.Labels.splice(index, 1);
+  };
+
   function createNetwork(config) {
     $('#createNetworkSpinner').show();
     Network.create(config, function (d) {
@@ -63,10 +73,21 @@ function ($scope, $state, Messages, Network) {
     config.Options = options;
   }
 
+  function prepareLabelsConfig(config) {
+    var labels = {};
+    $scope.formValues.Labels.forEach(function (label) {
+      if (label.name && label.value) {
+          labels[label.name] = label.value;
+      }
+    });
+    config.Labels = labels;
+  }
+
   function prepareConfiguration() {
     var config = angular.copy($scope.config);
     prepareIPAMConfiguration(config);
     prepareDriverOptions(config);
+    prepareLabelsConfig(config);
     return config;
   }
 

app/components/createNetwork/createnetwork.html

@@ -1,7 +1,7 @@
 <rd-header>
   <rd-header-title title="Create network"></rd-header-title>
   <rd-header-content>
-    Networks > Add network
+    <a ui-sref="networks">Networks</a> > Add network
   </rd-header-content>
 </rd-header>
 
@@ -42,7 +42,7 @@
           <div class="form-group">
             <label for="network_driveropts" class="col-sm-1 control-label text-left">Driver options</label>
             <div class="col-sm-11">
-              <span class="label label-default clickable" ng-click="addDriverOption()">
+              <span class="label label-default interactive" ng-click="addDriverOption()">
                 <i class="fa fa-plus-circle" aria-hidden="true"></i> driver option
               </span>
             </div>
@@ -78,6 +78,35 @@
             </div>
           </div>
           <!-- !internal -->
+          <!-- labels -->
+          <div class="form-group">
+            <label for="service_env" class="col-sm-1 control-label text-left">Labels</label>
+            <div class="col-sm-11">
+              <span class="label label-default interactive" ng-click="addLabel()">
+                <i class="fa fa-plus-circle" aria-hidden="true"></i> label
+              </span>
+            </div>
+            <!-- labels-input-list -->
+            <div class="col-sm-offset-1 col-sm-11 form-inline" style="margin-top: 10px;">
+              <div ng-repeat="label in formValues.Labels" style="margin-top: 2px;">
+                <div class="input-group col-sm-5 input-group-sm">
+                  <span class="input-group-addon">name</span>
+                  <input type="text" class="form-control" ng-model="label.name" placeholder="e.g. com.example.foo">
+                </div>
+                <div class="input-group col-sm-5 input-group-sm">
+                  <span class="input-group-addon">value</span>
+                  <input type="text" class="form-control" ng-model="label.value" placeholder="e.g. bar">
+                  <span class="input-group-btn">
+                    <button class="btn btn-default" type="button" ng-click="removeLabel($index)">
+                      <i class="fa fa-minus" aria-hidden="true"></i>
+                    </button>
+                  </span>
+                </div>
+              </div>
+            </div>
+            <!-- !labels-input-list -->
+          </div>
+          <!-- !labels-->
         </form>
       </rd-widget-body>
     </rd-widget>

app/components/createService/createServiceController.js

@@ -9,13 +9,19 @@ function ($scope, $state, Service, Volume, Network, ImageHelper, Messages) {
     Mode: 'replicated',
     Replicas: 1,
     Command: '',
+    EntryPoint: '',
     WorkingDir: '',
     User: '',
     Env: [],
+    Labels: [],
+    ContainerLabels: [],
     Volumes: [],
     Network: '',
     ExtraNetworks: [],
-    Ports: []
+    Ports: [],
+    Parallelism: 1,
+    UpdateDelay: 0,
+    FailureAction: 'pause'
   };
 
   $scope.addPortBinding = function() {
@@ -50,9 +56,25 @@ function ($scope, $state, Service, Volume, Network, ImageHelper, Messages) {
     $scope.formValues.Env.splice(index, 1);
   };
 
+  $scope.addLabel = function() {
+    $scope.formValues.Labels.push({ name: '', value: ''});
+  };
+
+  $scope.removeLabel = function(index) {
+    $scope.formValues.Labels.splice(index, 1);
+  };
+
+  $scope.addContainerLabel = function() {
+    $scope.formValues.ContainerLabels.push({ name: '', value: ''});
+  };
+
+  $scope.removeContainerLabel = function(index) {
+    $scope.formValues.ContainerLabels.splice(index, 1);
+  };
+
   function prepareImageConfig(config, input) {
-    var imageConfig = ImageHelper.createImageConfig(input.Image, input.Registry);
-    config.TaskTemplate.ContainerSpec.Image = imageConfig.repo + ':' + imageConfig.tag;
+    var imageConfig = ImageHelper.createImageConfigForContainer(input.Image, input.Registry);
+    config.TaskTemplate.ContainerSpec.Image = imageConfig.fromImage + ':' + imageConfig.tag;
   }
 
   function preparePortsConfig(config, input) {
@@ -75,9 +97,19 @@ function ($scope, $state, Service, Volume, Network, ImageHelper, Messages) {
     }
   }
 
+  function commandToArray(cmd) {
+    var tokens = [].concat.apply([], cmd.split('"').map(function(v,i) {
+       return i%2 ? v : v.split(' ');
+    })).filter(Boolean);
+    return tokens;
+  }
+
   function prepareCommandConfig(config, input) {
+    if (input.EntryPoint) {
+      config.TaskTemplate.ContainerSpec.Command = commandToArray(input.EntryPoint);
+    }
     if (input.Command) {
-      config.TaskTemplate.ContainerSpec.Command = _.split(input.Command, ' ');
+      config.TaskTemplate.ContainerSpec.Args = commandToArray(input.Command);
     }
     if (input.User) {
       config.TaskTemplate.ContainerSpec.User = input.User;
@@ -97,6 +129,24 @@ function ($scope, $state, Service, Volume, Network, ImageHelper, Messages) {
     config.TaskTemplate.ContainerSpec.Env = env;
   }
 
+  function prepareLabelsConfig(config, input) {
+    var labels = {};
+    input.Labels.forEach(function (label) {
+      if (label.name && label.value) {
+          labels[label.name] = label.value;
+      }
+    });
+    config.Labels = labels;
+
+    var containerLabels = {};
+    input.ContainerLabels.forEach(function (label) {
+      if (label.name && label.value) {
+          containerLabels[label.name] = label.value;
+      }
+    });
+    config.TaskTemplate.ContainerSpec.Labels = containerLabels;
+  }
+
   function prepareVolumes(config, input) {
     input.Volumes.forEach(function (volume) {
       if (volume.Source && volume.Target) {
@@ -121,6 +171,14 @@ function ($scope, $state, Service, Volume, Network, ImageHelper, Messages) {
     config.Networks = _.uniqWith(networks, _.isEqual);
   }
 
+  function prepareUpdateConfig(config, input) {
+    config.UpdateConfig = {
+      Parallelism: input.Parallelism || 0,
+      Delay: input.UpdateDelay || 0,
+      FailureAction: input.FailureAction
+    };
+  }
+
   function prepareConfiguration() {
     var input = $scope.formValues;
     var config = {
@@ -138,8 +196,10 @@ function ($scope, $state, Service, Volume, Network, ImageHelper, Messages) {
     preparePortsConfig(config, input);
     prepareCommandConfig(config, input);
     prepareEnvConfig(config, input);
+    prepareLabelsConfig(config, input);
     prepareVolumes(config, input);
     prepareNetworks(config, input);
+    prepareUpdateConfig(config, input);
     return config;
   }
 

app/components/createService/createservice.html

@@ -1,7 +1,7 @@
 <rd-header>
   <rd-header-title title="Create service"></rd-header-title>
   <rd-header-content>
-    Services > Add service
+    <a ui-sref="services">Services</a> > Add service
   </rd-header-content>
 </rd-header>
 
@@ -56,7 +56,7 @@
           <div class="form-group">
             <label for="container_ports" class="col-sm-1 control-label text-left">Port mapping</label>
             <div class="col-sm-11">
-              <span class="label label-default clickable" ng-click="addPortBinding()">
+              <span class="label label-default interactive" ng-click="addPortBinding()">
                 <i class="fa fa-plus-circle" aria-hidden="true"></i> map port
               </span>
             </div>
@@ -72,7 +72,7 @@
                   <input type="text" class="form-control" ng-model="portBinding.TargetPort" placeholder="e.g. 80">
                 </div>
                 <div class="input-group col-sm-1 input-group-sm">
-                  <select class="selectpicker form-control" ng-model="portBinding.Protocol">
+                  <select class="form-control" ng-model="portBinding.Protocol">
                     <option value="tcp">tcp</option>
                     <option value="udp">udp</option>
                   </select>
@@ -98,9 +98,11 @@
     <rd-widget>
       <rd-widget-body>
         <ul class="nav nav-tabs">
-          <li class="active clickable"><a data-target="#command" data-toggle="tab">Command</a></li>
-          <li class="clickable"><a data-target="#volumes" data-toggle="tab">Volumes</a></li>
-          <li class="clickable"><a data-target="#network" data-toggle="tab">Network</a></li>
+          <li class="active interactive"><a data-target="#command" data-toggle="tab">Command</a></li>
+          <li class="interactive"><a data-target="#volumes" data-toggle="tab">Volumes</a></li>
+          <li class="interactive"><a data-target="#network" data-toggle="tab">Network</a></li>
+          <li class="interactive"><a data-target="#labels" data-toggle="tab">Labels</a></li>
+          <li class="interactive"><a data-target="#update-config" data-toggle="tab">Update config</a></li>
         </ul>
         <!-- tab-content -->
         <div class="tab-content">
@@ -115,6 +117,14 @@
                 </div>
               </div>
               <!-- !command-input -->
+              <!-- entrypoint-input -->
+              <div class="form-group">
+                <label for="service_entrypoint" class="col-sm-1 control-label text-left">Entrypoint</label>
+                <div class="col-sm-9">
+                  <input type="text" class="form-control" ng-model="formValues.EntryPoint" id="service_entrypoint" placeholder="e.g. /bin/sh -c">
+                </div>
+              </div>
+              <!-- !entrypoint-input -->
               <!-- workdir-user-input -->
               <div class="form-group">
                 <label for="service_workingdir" class="col-sm-1 control-label text-left">Working Dir</label>
@@ -131,7 +141,7 @@
               <div class="form-group">
                 <label for="service_env" class="col-sm-1 control-label text-left">Environment variables</label>
                 <div class="col-sm-11">
-                  <span class="label label-default clickable" ng-click="addEnvironmentVariable()">
+                  <span class="label label-default interactive" ng-click="addEnvironmentVariable()">
                     <i class="fa fa-plus-circle" aria-hidden="true"></i> environment variable
                   </span>
                 </div>
@@ -166,7 +176,7 @@
               <div class="form-group">
                 <label for="service_volumes" class="col-sm-1 control-label text-left">Volumes</label>
                 <div class="col-sm-11">
-                  <span class="label label-default clickable" ng-click="addVolume()">
+                  <span class="label label-default interactive" ng-click="addVolume()">
                     <i class="fa fa-plus-circle" aria-hidden="true"></i> volume
                   </span>
                 </div>
@@ -182,7 +192,7 @@
                     </div>
                     <div class="input-group col-sm-5 input-group-sm">
                       <span class="input-group-addon"><input type="checkbox" ng-model="volume.Bind">bind</span>
-                      <select class="selectpicker form-control" ng-model="volume.Source" ng-if="!volume.Bind">
+                      <select class="form-control" ng-model="volume.Source" ng-if="!volume.Bind">
                         <option selected disabled hidden value="">Select a volume</option>
                         <option ng-repeat="vol in availableVolumes" ng-value="vol.Name">{{ vol.Name|truncate:30}}</option>
                       </select>
@@ -212,7 +222,7 @@
               <div class="form-group">
                 <label for="container_network" class="col-sm-1 control-label text-left">Network</label>
                 <div class="col-sm-9">
-                  <select class="selectpicker form-control" ng-model="formValues.Network">
+                  <select class="form-control" ng-model="formValues.Network">
                     <option selected disabled hidden value="">Select a network</option>
                     <option ng-repeat="net in availableNetworks" ng-value="net.Name">{{ net.Name }}</option>
                   </select>
@@ -224,7 +234,7 @@
               <div class="form-group">
                 <label for="service_extra_networks" class="col-sm-1 control-label text-left">Extra networks</label>
                 <div class="col-sm-11">
-                  <span class="label label-default clickable" ng-click="addExtraNetwork()">
+                  <span class="label label-default interactive" ng-click="addExtraNetwork()">
                     <i class="fa fa-plus-circle" aria-hidden="true"></i> network
                   </span>
                 </div>
@@ -237,7 +247,7 @@
                           <i class="fa fa-minus" aria-hidden="true"></i>
                         </button>
                       </span>
-                      <select class="selectpicker form-control" ng-model="network.Name">
+                      <select class="form-control" ng-model="network.Name">
                         <option selected disabled hidden value="">Select a network</option>
                         <option ng-repeat="net in availableNetworks" ng-value="net.Name">{{ net.Name }}</option>
                       </select>
@@ -251,6 +261,119 @@
             </form>
           </div>
           <!-- !tab-network -->
+          <!-- tab-labels -->
+          <div class="tab-pane" id="labels">
+            <form class="form-horizontal" style="margin-top: 15px;">
+              <!-- labels -->
+              <div class="form-group">
+                <label for="service_env" class="col-sm-1 control-label text-left">Labels</label>
+                <div class="col-sm-11">
+                  <span class="label label-default interactive" ng-click="addLabel()">
+                    <i class="fa fa-plus-circle" aria-hidden="true"></i> label
+                  </span>
+                </div>
+                <!-- labels-input-list -->
+                <div class="col-sm-offset-1 col-sm-11 form-inline" style="margin-top: 10px;">
+                  <div ng-repeat="label in formValues.Labels" style="margin-top: 2px;">
+                    <div class="input-group col-sm-5 input-group-sm">
+                      <span class="input-group-addon">name</span>
+                      <input type="text" class="form-control" ng-model="label.name" placeholder="e.g. com.example.foo">
+                    </div>
+                    <div class="input-group col-sm-5 input-group-sm">
+                      <span class="input-group-addon">value</span>
+                      <input type="text" class="form-control" ng-model="label.value" placeholder="e.g. bar">
+                      <span class="input-group-btn">
+                        <button class="btn btn-default" type="button" ng-click="removeLabel($index)">
+                          <i class="fa fa-minus" aria-hidden="true"></i>
+                        </button>
+                      </span>
+                    </div>
+                  </div>
+                </div>
+                <!-- !labels-input-list -->
+              </div>
+              <!-- !labels-->
+              <!-- container-labels -->
+              <div class="form-group">
+                <label for="service_env" class="col-sm-1 control-label text-left">Container labels</label>
+                <div class="col-sm-11">
+                  <span class="label label-default interactive" ng-click="addContainerLabel()">
+                    <i class="fa fa-plus-circle" aria-hidden="true"></i> container label
+                  </span>
+                </div>
+                <!-- container-labels-input-list -->
+                <div class="col-sm-offset-1 col-sm-11 form-inline" style="margin-top: 10px;">
+                  <div ng-repeat="label in formValues.ContainerLabels" style="margin-top: 2px;">
+                    <div class="input-group col-sm-5 input-group-sm">
+                      <span class="input-group-addon">name</span>
+                      <input type="text" class="form-control" ng-model="label.name" placeholder="e.g. com.example.foo">
+                    </div>
+                    <div class="input-group col-sm-5 input-group-sm">
+                      <span class="input-group-addon">value</span>
+                      <input type="text" class="form-control" ng-model="label.value" placeholder="e.g. bar">
+                      <span class="input-group-btn">
+                        <button class="btn btn-default" type="button" ng-click="removeContainerLabel($index)">
+                          <i class="fa fa-minus" aria-hidden="true"></i>
+                        </button>
+                      </span>
+                    </div>
+                  </div>
+                </div>
+                <!-- !container-labels-input-list -->
+              </div>
+              <!-- !container-labels-->
+            </form>
+          </div>
+          <!-- !tab-labels -->
+          <!-- tab-update-config -->
+          <div class="tab-pane" id="update-config">
+            <form class="form-horizontal" style="margin-top: 15px;">
+              <!-- parallelism-input -->
+              <div class="form-group">
+                <label for="parallelism" class="col-sm-1 control-label text-left">Parallelism</label>
+                <div class="col-sm-1">
+                  <input type="number" class="form-control" ng-model="formValues.Parallelism" id="parallelism" placeholder="e.g. 1">
+                </div>
+                <div class="col-sm-10">
+                  <p class="small text-muted" style="margin-top: 10px;">
+                    Maximum number of tasks to be updated simultaneously (0 to update all at once).
+                  </p>
+                </div>
+              </div>
+              <!-- !parallelism-input -->
+              <!-- delay-input -->
+              <div class="form-group">
+                <label for="update-delay" class="col-sm-1 control-label text-left">Delay</label>
+                <div class="col-sm-2">
+                  <input type="number" class="form-control" ng-model="formValues.UpdateDelay" id="update-delay" placeholder="e.g. 10">
+                </div>
+                <div class="col-sm-9">
+                  <p class="small text-muted" style="margin-top: 10px;">
+                    Amount of time between updates.
+                  </p>
+                </div>
+              </div>
+              <!-- !delay-input -->
+              <!-- failureAction-input -->
+              <div class="form-group">
+                <label for="failure_action" class="col-sm-1 control-label text-left">Failure Action</label>
+                <div class="col-sm-3">
+                  <label class="radio-inline">
+                    <input type="radio" name="failure_action" ng-model="formValues.FailureAction" value="continue">
+                    Continue
+                  </label>
+                  <label class="radio-inline">
+                    <input type="radio" name="failure_action" ng-model="formValues.FailureAction" value="pause">
+                    Pause
+                  </label>
+                </div>
+                <div class="col-sm-8"></div>
+              </div>
+              <!-- !failureAction-input -->
+
+            </form>
+          </div>
+          <!-- !tab-update-config -->
           <!-- tab-security -->
           <div class="tab-pane" id="security">
           </div>

app/components/createVolume/createvolume.html

@@ -1,7 +1,7 @@
 <rd-header>
   <rd-header-title title="Create volume"></rd-header-title>
   <rd-header-content>
-    Volumes > Add volume
+    <a ui-sref="volumes">Volumes</a> > Add volume
   </rd-header-content>
 </rd-header>
 
@@ -30,7 +30,7 @@
           <div class="form-group">
             <label for="volume_driveropts" class="col-sm-1 control-label text-left">Driver options</label>
             <div class="col-sm-11">
-              <span class="label label-default clickable" ng-click="addDriverOption()">
+              <span class="label label-default interactive" ng-click="addDriverOption()">
                 <i class="fa fa-plus-circle" aria-hidden="true"></i> driver option
               </span>
             </div>

app/components/dashboard/dashboard.html

@@ -6,7 +6,7 @@
 </rd-header>
 
 <div class="row">
-  <div class="col-lg-12 col-md-12 col-xs-12" ng-if="swarm_mode || !swarm">
+  <div class="col-lg-12 col-md-12 col-xs-12" ng-if="endpointMode.provider !== 'DOCKER_SWARM'">
     <rd-widget>
       <rd-widget-header icon="fa-tachometer" title="Node info"></rd-widget-header>
       <rd-widget-body classes="no-padding">
@@ -33,7 +33,7 @@
       </rd-widget-body>
     </rd-widget>
   </div>
-  <div class="col-lg-12 col-md-12 col-xs-12" ng-if="swarm && !swarm_mode">
+  <div class="col-lg-12 col-md-12 col-xs-12" ng-if="endpointMode.provider === 'DOCKER_SWARM'">
     <rd-widget>
       <rd-widget-header icon="fa-tachometer" title="Cluster info"></rd-widget-header>
       <rd-widget-body classes="no-padding">
@@ -60,7 +60,7 @@
       </rd-widget-body>
     </rd-widget>
   </div>
-  <div class="col-lg-12 col-md-12 col-xs-12" ng-if="swarm && swarm_mode">
+  <div class="col-lg-12 col-md-12 col-xs-12" ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">
     <rd-widget>
       <rd-widget-header icon="fa-tachometer" title="Swarm info"></rd-widget-header>
       <rd-widget-body classes="no-padding">
@@ -93,8 +93,8 @@
             <i class="fa fa-server"></i>
           </div>
           <div class="pull-right">
-            <div><i class="fa fa-heartbeat text-icon green-icon"></i>{{ containerData.running }} running</div>
-            <div><i class="fa fa-heartbeat text-icon red-icon"></i>{{ containerData.stopped }} stopped</div>
+            <div><i class="fa fa-heartbeat space-right green-icon"></i>{{ containerData.running }} running</div>
+            <div><i class="fa fa-heartbeat space-right red-icon"></i>{{ containerData.stopped }} stopped</div>
           </div>
           <div class="title">{{ containerData.total }}</div>
           <div class="comment">Containers</div>
@@ -110,7 +110,7 @@
             <i class="fa fa-clone"></i>
           </div>
           <div class="pull-right">
-            <div><i class="fa fa-pie-chart text-icon"></i>{{ imageData.size|humansize }}</div>
+            <div><i class="fa fa-pie-chart space-right"></i>{{ imageData.size|humansize }}</div>
           </div>
           <div class="title">{{ imageData.total }}</div>
           <div class="comment">Images</div>
@@ -126,7 +126,7 @@
             <i class="fa fa-cubes"></i>
           </div>
           <div class="pull-right" ng-if="infoData.Driver">
-            <div><i class="fa fa-hdd-o text-icon"></i>{{ infoData.Driver }} driver</div>
+            <div><i class="fa fa-hdd-o space-right"></i>{{ infoData.Driver }} driver</div>
           </div>
           <div class="title">{{ volumeData.total }}</div>
           <div class="comment">Volumes</div>

app/components/dashboard/dashboardController.js

@@ -1,6 +1,6 @@
 angular.module('dashboard', [])
-.controller('DashboardController', ['$scope', '$q', 'Config', 'Container', 'ContainerHelper', 'Image', 'Network', 'Volume', 'Info',
-function ($scope, $q, Config, Container, ContainerHelper, Image, Network, Volume, Info) {
+.controller('DashboardController', ['$scope', '$q', 'Config', 'Container', 'ContainerHelper', 'Image', 'Network', 'Volume', 'Info', 'Messages',
+function ($scope, $q, Config, Container, ContainerHelper, Image, Network, Volume, Info, Messages) {
 
   $scope.containerData = {
     total: 0
@@ -14,7 +14,6 @@ function ($scope, $q, Config, Container, ContainerHelper, Image, Network, Volume
   $scope.volumeData = {
     total: 0
   };
-  $scope.swarm_mode = false;
 
   function prepareContainerData(d, containersToHideLabels) {
     var running = 0;
@@ -64,9 +63,6 @@ function ($scope, $q, Config, Container, ContainerHelper, Image, Network, Volume
   function prepareInfoData(d) {
     var info = d;
     $scope.infoData = info;
-    if ($scope.swarm && !_.startsWith(info.ServerVersion, 'swarm')) {
-      $scope.swarm_mode = true;
-    }
   }
 
   function fetchDashboardData(containersToHideLabels) {
@@ -84,11 +80,13 @@ function ($scope, $q, Config, Container, ContainerHelper, Image, Network, Volume
       prepareNetworkData(d[3]);
       prepareInfoData(d[4]);
       $('#loadingViewSpinner').hide();
+    }, function(e) {
+      $('#loadingViewSpinner').hide();
+      Messages.error("Failure", e, "Unable to load dashboard data");
     });
   }
 
   Config.$promise.then(function (c) {
-    $scope.swarm = c.swarm;
     fetchDashboardData(c.hiddenLabels);
   });
 }]);

app/components/docker/docker.html

@@ -3,139 +3,113 @@
     <a data-toggle="tooltip" title="Refresh" ui-sref="docker" ui-sref-opts="{reload: true}">
       <i class="fa fa-refresh" aria-hidden="true"></i>
     </a>
+    <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>Docker</rd-header-content>
 </rd-header>
-<div class="row">
-  <div class="col-lg-3 col-md-6 col-xs-12">
-    <rd-widget>
-      <rd-widget-body>
-        <div class="widget-icon pull-left">
-          <i class="fa fa-code"></i>
-        </div>
-        <div class="title">{{ docker.Version }}</div>
-        <div class="comment">Docker version</div>
-      </rd-widget-body>
-    </rd-widget>
-  </div>
-  <div class="col-lg-3 col-md-6 col-xs-12">
-    <rd-widget>
-      <rd-widget-body>
-        <div class="widget-icon pull-left">
-          <i class="fa fa-code"></i>
-        </div>
-        <div class="title">{{ docker.ApiVersion }}</div>
-        <div class="comment">API version</div>
-      </rd-widget-body>
-    </rd-widget>
-  </div>
-  <div class="col-lg-3 col-md-6 col-xs-12">
-    <rd-widget>
-      <rd-widget-body>
-        <div class="widget-icon pull-left">
-          <i class="fa fa-code"></i>
-        </div>
-        <div class="title">{{ docker.GoVersion }}</div>
-        <div class="comment">Go version</div>
-      </rd-widget-body>
-    </rd-widget>
-  </div>
-</div>
 
-<div class="row">
-  <div class="col-lg-12">
+<div class="row" ng-if="state.loaded">
+  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12">
     <rd-widget>
-      <rd-widget-header icon="fa-object-group" title="Engine status"></rd-widget-header>
+      <rd-widget-header icon="fa-code" title="Engine version"></rd-widget-header>
       <rd-widget-body classes="no-padding">
         <table class="table">
           <tbody>
             <tr>
-              <td>Containers</td>
-              <td>{{ info.Containers }}</td>
+              <td>Version</td>
+              <td>{{ version.Version }}</td>
             </tr>
             <tr>
-              <td>Images</td>
-              <td>{{ info.Images }}</td>
+              <td>API version</td>
+              <td>{{ version.ApiVersion }}</td>
             </tr>
             <tr>
-              <td>Debug</td>
-              <td>{{ info.Debug }}</td>
+              <td>Go version</td>
+              <td>{{ version.GoVersion }}</td>
             </tr>
             <tr>
-              <td>CPUs</td>
-              <td>{{ info.NCPU }}</td>
+              <td>OS type</td>
+              <td>{{ version.Os }}</td>
             </tr>
             <tr>
-              <td>Total Memory</td>
-              <td>{{ info.MemTotal|humansize }}</td>
-            </tr>
-            <tr>
-              <td>Operating System</td>
+              <td>OS</td>
               <td>{{ info.OperatingSystem }}</td>
             </tr>
             <tr>
-              <td>Kernel Version</td>
-              <td>{{ info.KernelVersion }}</td>
+              <td>Architecture</td>
+              <td>{{ version.Arch }}</td>
             </tr>
             <tr>
-              <td>ID</td>
-              <td>{{ info.ID }}</td>
-            </tr>
-            <tr>
-              <td>Labels</td>
-              <td>{{ info.Labels }}</td>
-            </tr>
-            <tr>
-              <td>File Descriptors</td>
-              <td>{{ info.NFd }}</td>
-            </tr>
-            <tr>
-              <td>Goroutines</td>
-              <td>{{ info.NGoroutines }}</td>
-            </tr>
-            <tr>
-              <td>Storage Driver</td>
-              <td>{{ info.Driver }}</td>
-            </tr>
-            <tr>
-              <td>Storage Driver Status</td>
-              <td>
-                <p ng-repeat="val in info.DriverStatus">
-                  {{ val[0] }}: {{ val[1] }}
-                </p>
-              </td>
-            </tr>
-            <tr>
-              <td>Execution Driver</td>
-              <td>{{ info.ExecutionDriver }}</td>
-            </tr>
-            <tr>
-              <td>IPv4 Forwarding</td>
-              <td>{{ info.IPv4Forwarding }}</td>
-            </tr>
-            <tr>
-              <td>Index Server Address</td>
-              <td>{{ info.IndexServerAddress }}</td>
-            </tr>
-            <tr>
-              <td>Init Path</td>
-              <td>{{ info.InitPath }}</td>
-            </tr>
-            <tr>
-              <td>Docker Root Directory</td>
-              <td>{{ info.DockerRootDir }}</td>
-            </tr>
-            <tr>
-              <td>Init SHA1</td>
-              <td>{{ info.InitSha1 }}</td>
-            </tr>
-            <tr>
-              <td>Memory Limit</td>
-              <td>{{ info.MemoryLimit }}</td>
-            </tr>
-            <tr>
-              <td>Swap Limit</td>
-              <td>{{ info.SwapLimit }}</td>
+              <td>Kernel version</td>
+              <td>{{ version.KernelVersion }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>
+
+<div class="row" ng-if="state.loaded">
+  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-th" title="Engine status"></rd-widget-header>
+      <rd-widget-body classes="no-padding">
+        <table class="table">
+          <tbody>
+            <tr>
+              <td>Total CPU</td>
+              <td>{{ info.NCPU }}</td>
+            </tr>
+            <tr>
+              <td>Total memory</td>
+              <td>{{ info.MemTotal|humansize }}</td>
+            </tr>
+            <tr>
+              <td>Docker root directory</td>
+              <td>{{ info.DockerRootDir }}</td>
+            </tr>
+            <tr>
+              <td>Storage driver</td>
+              <td>{{ info.Driver }}</td>
+            </tr>
+            <tr>
+              <td>Logging driver</td>
+              <td>{{ info.LoggingDriver }}</td>
+            </tr>
+            <tr ng-if="info.CgroupDriver">
+              <td>Cgroup driver</td>
+              <td>{{ info.CgroupDriver }}</td>
+            </tr>
+            <tr ng-if="info.ExecutionDriver">
+              <td>Execution driver</td>
+              <td>{{ info.ExecutionDriver }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>
+
+<div class="row" ng-if="state.loaded && info.Plugins">
+  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-plug" title="Engine plugins"></rd-widget-header>
+      <rd-widget-body classes="no-padding">
+        <table class="table">
+          <tbody>
+            <tr ng-if="info.Plugins.Volume">
+              <td>Volume</td>
+              <td>{{ info.Plugins.Volume|arraytostr: ', '}}</td>
+            </tr>
+            <tr ng-if="info.Plugins.Network">
+              <td>Network</td>
+              <td>{{ info.Plugins.Network|arraytostr: ', '}}</td>
+            </tr>
+            <tr ng-if="info.Plugins.Authorization">
+              <td>Authorization</td>
+              <td>{{ info.Plugins.Authorization|arraytostr: ', '}}</td>
             </tr>
           </tbody>
         </table>

app/components/docker/dockerController.js

@@ -1,19 +1,24 @@
 angular.module('docker', [])
-.controller('DockerController', ['$scope', 'Info', 'Version', 'Settings',
-function ($scope, Info, Version, Settings) {
-
-  $scope.info = {};
-  $scope.docker = {};
-  
-  $scope.order = function(sortType) {
-    $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
-    $scope.sortType = sortType;
+.controller('DockerController', ['$scope', 'Info', 'Version', 'Messages',
+function ($scope, Info, Version, Messages) {
+  $scope.state = {
+    loaded: false
   };
+  $scope.info = {};
+  $scope.version = {};
 
-  Version.get({}, function (d) {
-    $scope.docker = d;
-  });
-  Info.get({}, function (d) {
-    $scope.info = d;
+  Info.get({}, function (infoData) {
+    $scope.info = infoData;
+    Version.get({}, function (versionData) {
+      $scope.version = versionData;
+      $scope.state.loaded = true;
+      $('#loadingViewSpinner').hide();
+    }, function (e) {
+      Messages.error("Failure", e, 'Unable to retrieve engine details');
+      $('#loadingViewSpinner').hide();
+    });
+  }, function (e) {
+    Messages.error("Failure", e, 'Unable to retrieve engine information');
+    $('#loadingViewSpinner').hide();
   });
 }]);

app/components/endpoint/endpoint.html

@@ -0,0 +1,99 @@
+<rd-header>
+  <rd-header-title title="Endpoint details">
+    <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
+  </rd-header-title>
+  <rd-header-content>
+    <a ui-sref="endpoints">Endpoints</a> > <a ui-sref="endpoint({id: endpoint.Id})">{{ endpoint.Name }}</a>
+  </rd-header-content>
+</rd-header>
+
+<div class="row">
+  <div class="col-lg-12 col-md-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-body>
+        <form class="form-horizontal">
+          <!-- name-input -->
+          <div class="form-group">
+            <label for="container_name" class="col-sm-2 control-label text-left">Name</label>
+            <div class="col-sm-10">
+              <input type="text" class="form-control" id="container_name" ng-model="endpoint.Name" placeholder="e.g. docker-prod01">
+            </div>
+          </div>
+          <!-- !name-input -->
+          <!-- endpoint-url-input -->
+          <div class="form-group">
+            <label for="endpoint_url" class="col-sm-2 control-label text-left">Endpoint URL</label>
+            <div class="col-sm-10">
+              <input ng-disabled="endpointType === 'local'" type="text" class="form-control" id="endpoint_url" ng-model="endpoint.URL" placeholder="e.g. 10.0.0.10:2375 or mydocker.mydomain.com:2375">
+            </div>
+          </div>
+          <!-- !endpoint-url-input -->
+          <!-- tls-checkbox -->
+          <div class="form-group" ng-if="endpointType === 'remote'">
+            <label for="tls" class="col-sm-2 control-label text-left">TLS</label>
+            <div class="col-sm-10">
+              <input type="checkbox" name="tls" ng-model="endpoint.TLS">
+            </div>
+          </div>
+          <!-- !tls-checkbox -->
+          <!-- tls-certs -->
+          <div ng-if="endpoint.TLS">
+            <!-- ca-input -->
+            <div class="form-group">
+              <label class="col-sm-2 control-label text-left">TLS CA certificate</label>
+              <div class="col-sm-10">
+                <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSCACert">Select file</button>
+                <span style="margin-left: 5px;">
+                  <span ng-if="formValues.TLSCACert !== endpoint.TLSCACert">{{ formValues.TLSCACert.name }}</span>
+                  <i class="fa fa-check green-icon" ng-if="formValues.TLSCACert && formValues.TLSCACert === endpoint.TLSCACert" aria-hidden="true"></i>
+                  <i class="fa fa-times red-icon" ng-if="!formValues.TLSCACert" aria-hidden="true"></i>
+                  <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                </span>
+              </div>
+            </div>
+            <!-- !ca-input -->
+            <!-- cert-input -->
+            <div class="form-group">
+              <label for="tls_cert" class="col-sm-2 control-label text-left">TLS certificate</label>
+              <div class="col-sm-10">
+                <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSCert">Select file</button>
+                <span style="margin-left: 5px;">
+                  <span ng-if="formValues.TLSCert !== endpoint.TLSCert">{{ formValues.TLSCert.name }}</span>
+                  <i class="fa fa-check green-icon" ng-if="formValues.TLSCert && formValues.TLSCert === endpoint.TLSCert" aria-hidden="true"></i>
+                  <i class="fa fa-times red-icon" ng-if="!formValues.TLSCert" aria-hidden="true"></i>
+                  <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                </span>
+              </div>
+            </div>
+            <!-- !cert-input -->
+            <!-- key-input -->
+            <div class="form-group">
+              <label class="col-sm-2 control-label text-left">TLS key</label>
+              <div class="col-sm-10">
+                <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSKey">Select file</button>
+                <span style="margin-left: 5px;">
+                  <span ng-if="formValues.TLSKey !== endpoint.TLSKey">{{ formValues.TLSKey.name }}</span>
+                  <i class="fa fa-check green-icon" ng-if="formValues.TLSKey && formValues.TLSKey === endpoint.TLSKey" aria-hidden="true"></i>
+                  <i class="fa fa-times red-icon" ng-if="!formValues.TLSKey" aria-hidden="true"></i>
+                  <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                </span>
+              </div>
+            </div>
+            <!-- !key-input -->
+          </div>
+          <!-- !tls-certs -->
+          <div class="form-group">
+            <div class="col-sm-12">
+              <button type="button" class="btn btn-primary btn-sm" ng-disabled="!endpoint.Name || !endpoint.URL || (endpoint.TLS && (!formValues.TLSCACert || !formValues.TLSCert || !formValues.TLSKey))" ng-click="updateEndpoint()">Update endpoint</button>
+              <a type="button" class="btn btn-default btn-sm" ui-sref="endpoints">Cancel</a>
+              <i id="updateEndpointSpinner" class="fa fa-cog fa-spin" style="margin-left: 5px; display: none;"></i>
+              <span class="text-danger" ng-if="state.error" style="margin: 5px;">
+                <i class="fa fa-exclamation-circle" aria-hidden="true"></i> {{ state.error }}
+              </span>
+            </div>
+          </div>
+        </form>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>

app/components/endpoint/endpointController.js

@@ -0,0 +1,55 @@
+angular.module('endpoint', [])
+.controller('EndpointController', ['$scope', '$state', '$stateParams', '$filter', 'EndpointService', 'Messages',
+function ($scope, $state, $stateParams, $filter, EndpointService, Messages) {
+  $scope.state = {
+    error: '',
+    uploadInProgress: false
+  };
+  $scope.formValues = {
+    TLSCACert: null,
+    TLSCert: null,
+    TLSKey: null
+  };
+
+  $scope.updateEndpoint = function() {
+    var ID = $scope.endpoint.Id;
+    var name = $scope.endpoint.Name;
+    var URL = $scope.endpoint.URL;
+    var TLS = $scope.endpoint.TLS;
+    var TLSCACert = $scope.formValues.TLSCACert !== $scope.endpoint.TLSCACert ? $scope.formValues.TLSCACert : null;
+    var TLSCert = $scope.formValues.TLSCert !== $scope.endpoint.TLSCert ? $scope.formValues.TLSCert : null;
+    var TLSKey = $scope.formValues.TLSKey !== $scope.endpoint.TLSKey ? $scope.formValues.TLSKey : null;
+    EndpointService.updateEndpoint(ID, name, URL, TLS, TLSCACert, TLSCert, TLSKey).then(function success(data) {
+      Messages.send("Endpoint updated", $scope.endpoint.Name);
+      $state.go('endpoints');
+    }, function error(err) {
+      $scope.state.error = err.msg;
+    }, function update(evt) {
+      if (evt.upload) {
+        $scope.state.uploadInProgress = evt.upload;
+      }
+    });
+  };
+
+  function getEndpoint(endpointID) {
+    $('#loadingViewSpinner').show();
+    EndpointService.endpoint($stateParams.id).then(function success(data) {
+      $('#loadingViewSpinner').hide();
+      $scope.endpoint = data;
+      if (data.URL.indexOf("unix://") === 0) {
+        $scope.endpointType = 'local';
+      } else {
+        $scope.endpointType = 'remote';
+      }
+      $scope.endpoint.URL = $filter('stripprotocol')(data.URL);
+      $scope.formValues.TLSCACert = data.TLSCACert;
+      $scope.formValues.TLSCert = data.TLSCert;
+      $scope.formValues.TLSKey = data.TLSKey;
+    }, function error(err) {
+      $('#loadingViewSpinner').hide();
+      Messages.error("Failure", err, "Unable to retrieve endpoint details");
+    });
+  }
+
+  getEndpoint($stateParams.id);
+}]);

app/components/endpointInit/endpointInit.html

@@ -0,0 +1,139 @@
+<div class="page-wrapper">
+  <!-- simple box -->
+  <div class="container simple-box">
+    <div class="col-md-8 col-md-offset-2 col-sm-8 col-sm-offset-2">
+      <!-- simple box logo -->
+      <div class="row">
+        <img ng-if="logo" ng-src="{{ logo }}" class="simple-box-logo">
+        <img ng-if="!logo" src="images/logo_alt.png" class="simple-box-logo" alt="Portainer">
+      </div>
+      <!-- !simple box logo -->
+      <!-- init-endpoint panel -->
+      <div class="panel panel-default">
+        <div class="panel-body">
+          <!-- init-endpoint form -->
+          <form class="form-horizontal" style="margin: 20px;" enctype="multipart/form-data" method="POST">
+            <!-- comment -->
+            <div class="form-group">
+              <p>Connect Portainer to a Docker engine or Swarm cluster endpoint.</p>
+            </div>
+            <!-- !comment input -->
+            <!-- endpoin-type radio -->
+            <div class="form-group">
+              <div class="radio">
+                <label><input type="radio" name="endpointType" value="local" ng-model="formValues.endpointType">Manage the Docker instance where Portainer is running</label>
+              </div>
+              <div class="radio">
+                <label><input type="radio" name="endpointType" value="remote" ng-model="formValues.endpointType">Manage a remote Docker instance</label>
+              </div>
+            </div>
+            <!-- endpoint-type radio -->
+            <!-- local-endpoint -->
+            <div ng-if="formValues.endpointType === 'local'" style="margin-top: 25px;">
+              <div class="form-group">
+                <div class="col-sm-12">
+                  <span class="small text-muted">Note: ensure that the Docker socket is bind mounted in the Portainer container at <code>/var/run/docker.sock</code></span>
+                </div>
+              </div>
+              <!-- connect button -->
+              <div class="form-group" style="margin-top: 10px;">
+                <div class="col-sm-12 controls">
+                  <p class="pull-left text-danger" ng-if="state.error" style="margin: 5px;">
+                    <i class="fa fa-exclamation-circle" aria-hidden="true"></i> {{ state.error }}
+                  </p>
+                  <button type="submit" class="btn btn-primary pull-right" ng-click="createLocalEndpoint()"><i class="fa fa-plug" aria-hidden="true"></i> Connect</button>
+                </div>
+              </div>
+              <!-- !connect button -->
+            </div>
+            <!-- !local-endpoint -->
+            <!-- remote-endpoint -->
+            <div ng-if="formValues.endpointType === 'remote'" style="margin-top: 25px;">
+              <!-- name-input -->
+              <div class="form-group">
+                <label for="container_name" class="col-sm-3 control-label text-left">Name</label>
+                <div class="col-sm-9">
+                  <input type="text" class="form-control" id="container_name" ng-model="formValues.Name" placeholder="e.g. docker-prod01">
+                </div>
+              </div>
+              <!-- !name-input -->
+              <!-- endpoint-url-input -->
+              <div class="form-group">
+                <label for="endpoint_url" class="col-sm-3 control-label text-left">Endpoint URL</label>
+                <div class="col-sm-9">
+                  <input type="text" class="form-control" id="endpoint_url" ng-model="formValues.URL" placeholder="e.g. 10.0.0.10:2375 or mydocker.mydomain.com:2375">
+                </div>
+              </div>
+              <!-- !endpoint-url-input -->
+              <!-- tls-checkbox -->
+              <div class="form-group">
+                <label for="tls" class="col-sm-3 control-label text-left">TLS</label>
+                <div class="col-sm-9">
+                  <input type="checkbox" name="tls" ng-model="formValues.TLS">
+                </div>
+              </div>
+              <!-- !tls-checkbox -->
+              <!-- tls-certs -->
+              <div ng-if="formValues.TLS">
+                <!-- ca-input -->
+                <div class="form-group">
+                  <label class="col-sm-3 control-label text-left">TLS CA certificate</label>
+                  <div class="col-sm-9">
+                    <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSCACert">Select file</button>
+                    <span style="margin-left: 5px;">
+                      {{ formValues.TLSCACert.name }}
+                      <i class="fa fa-times red-icon" ng-if="!formValues.TLSCACert" aria-hidden="true"></i>
+                      <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                    </span>
+                  </div>
+                </div>
+                <!-- !ca-input -->
+                <!-- cert-input -->
+                <div class="form-group">
+                  <label for="tls_cert" class="col-sm-3 control-label text-left">TLS certificate</label>
+                  <div class="col-sm-9">
+                    <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSCert">Select file</button>
+                    <span style="margin-left: 5px;">
+                      {{ formValues.TLSCert.name }}
+                      <i class="fa fa-times red-icon" ng-if="!formValues.TLSCert" aria-hidden="true"></i>
+                      <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                    </span>
+                  </div>
+                </div>
+                <!-- !cert-input -->
+                <!-- key-input -->
+                <div class="form-group">
+                  <label class="col-sm-3 control-label text-left">TLS key</label>
+                  <div class="col-sm-9">
+                    <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSKey">Select file</button>
+                    <span style="margin-left: 5px;">
+                      {{ formValues.TLSKey.name }}
+                      <i class="fa fa-times red-icon" ng-if="!formValues.TLSKey" aria-hidden="true"></i>
+                      <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                    </span>
+                  </div>
+                </div>
+                <!-- !key-input -->
+              </div>
+              <!-- !tls-certs -->
+              <!-- connect button -->
+              <div class="form-group" style="margin-top: 10px;">
+                <div class="col-sm-12 controls">
+                  <p class="pull-left text-danger" ng-if="state.error" style="margin: 5px;">
+                    <i class="fa fa-exclamation-circle" aria-hidden="true"></i> {{ state.error }}
+                  </p>
+                  <button type="submit" class="btn btn-primary pull-right" ng-disabled="!formValues.Name || !formValues.URL || (formValues.TLS && (!formValues.TLSCACert || !formValues.TLSCert || !formValues.TLSKey))" ng-click="createRemoteEndpoint()"><i class="fa fa-plug" aria-hidden="true"></i> Connect</button>
+                </div>
+              </div>
+              <!-- !connect button -->
+            </div>
+            <!-- !remote-endpoint -->
+          </form>
+          <!-- !init-endpoint form -->
+        </div>
+      </div>
+      <!-- !init-endpoint panel -->
+    </div>
+  </div>
+  <!-- !simple box -->
+</div>

app/components/endpointInit/endpointInitController.js

@@ -0,0 +1,57 @@
+angular.module('endpointInit', [])
+.controller('EndpointInitController', ['$scope', '$state', 'EndpointService', 'Messages',
+function ($scope, $state, EndpointService, Messages) {
+  $scope.state = {
+    error: '',
+    uploadInProgress: false
+  };
+  $scope.formValues = {
+    endpointType: "remote",
+    Name: '',
+    URL: '',
+    TLS: false,
+    TLSCACert: null,
+    TLSCert: null,
+    TLSKey: null
+  };
+
+  EndpointService.getActive().then(function success(data) {
+    $state.go('dashboard');
+  }, function error(err) {
+    if (err.status !== 404) {
+      Messages.error("Failure", err, 'Unable to verify Docker endpoint existence');
+    }
+  });
+
+  $scope.createLocalEndpoint = function() {
+    $scope.state.error = '';
+    var name = "local";
+    var URL = "unix:///var/run/docker.sock";
+    var TLS = false;
+    EndpointService.createLocalEndpoint(name, URL, TLS, true).then(function success(data) {
+      $state.go('dashboard');
+    }, function error(err) {
+      $scope.state.error = 'Unable to create endpoint';
+    });
+  };
+
+  $scope.createRemoteEndpoint = function() {
+    $scope.state.error = '';
+    var name = $scope.formValues.Name;
+    var URL = $scope.formValues.URL;
+    var TLS = $scope.formValues.TLS;
+    var TLSCAFile = $scope.formValues.TLSCACert;
+    var TLSCertFile = $scope.formValues.TLSCert;
+    var TLSKeyFile = $scope.formValues.TLSKey;
+    EndpointService.createRemoteEndpoint(name, URL, TLS, TLSCAFile, TLSCertFile, TLSKeyFile, TLS ? false : true).then(function success(data) {
+      $state.go('dashboard');
+    }, function error(err) {
+      $scope.state.uploadInProgress = false;
+      $scope.state.error = err.msg;
+    }, function update(evt) {
+      if (evt.upload) {
+        $scope.state.uploadInProgress = evt.upload;
+      }
+    });
+  };
+}]);

app/components/endpoints/endpoints.html

@@ -0,0 +1,175 @@
+<rd-header>
+  <rd-header-title title="Endpoints">
+    <a data-toggle="tooltip" title="Refresh" ui-sref="endpoints" ui-sref-opts="{reload: true}">
+      <i class="fa fa-refresh" aria-hidden="true"></i>
+    </a>
+  </rd-header-title>
+  <rd-header-content>Endpoint management</rd-header-content>
+</rd-header>
+
+<div class="row">
+  <div class="col-lg-12 col-md-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-plus" title="Add a new endpoint">
+      </rd-widget-header>
+      <rd-widget-body>
+        <form class="form-horizontal">
+          <!-- name-input -->
+          <div class="form-group">
+            <label for="container_name" class="col-sm-2 control-label text-left">Name</label>
+            <div class="col-sm-10">
+              <input type="text" class="form-control" id="container_name" ng-model="formValues.Name" placeholder="e.g. docker-prod01">
+            </div>
+          </div>
+          <!-- !name-input -->
+          <!-- endpoint-url-input -->
+          <div class="form-group">
+            <label for="endpoint_url" class="col-sm-2 control-label text-left">Endpoint URL</label>
+            <div class="col-sm-10">
+              <input type="text" class="form-control" id="endpoint_url" ng-model="formValues.URL" placeholder="e.g. 10.0.0.10:2375 or mydocker.mydomain.com:2375">
+            </div>
+          </div>
+          <!-- !endpoint-url-input -->
+          <!-- tls-checkbox -->
+          <div class="form-group">
+            <label for="tls" class="col-sm-2 control-label text-left">TLS</label>
+            <div class="col-sm-10">
+              <input type="checkbox" name="tls" ng-model="formValues.TLS">
+            </div>
+          </div>
+          <!-- !tls-checkbox -->
+          <!-- tls-certs -->
+          <div ng-if="formValues.TLS">
+            <!-- ca-input -->
+            <div class="form-group">
+              <label class="col-sm-2 control-label text-left">TLS CA certificate</label>
+              <div class="col-sm-10">
+                <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSCACert">Select file</button>
+                <span style="margin-left: 5px;">
+                  {{ formValues.TLSCACert.name }}
+                  <i class="fa fa-times red-icon" ng-if="!formValues.TLSCACert" aria-hidden="true"></i>
+                  <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                </span>
+              </div>
+            </div>
+            <!-- !ca-input -->
+            <!-- cert-input -->
+            <div class="form-group">
+              <label for="tls_cert" class="col-sm-2 control-label text-left">TLS certificate</label>
+              <div class="col-sm-10">
+                <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSCert">Select file</button>
+                <span style="margin-left: 5px;">
+                  {{ formValues.TLSCert.name }}
+                  <i class="fa fa-times red-icon" ng-if="!formValues.TLSCert" aria-hidden="true"></i>
+                  <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                </span>
+              </div>
+            </div>
+            <!-- !cert-input -->
+            <!-- key-input -->
+            <div class="form-group">
+              <label class="col-sm-2 control-label text-left">TLS key</label>
+              <div class="col-sm-10">
+                <button class="btn btn-sm btn-primary" ngf-select ng-model="formValues.TLSKey">Select file</button>
+                <span style="margin-left: 5px;">
+                  {{ formValues.TLSKey.name }}
+                  <i class="fa fa-times red-icon" ng-if="!formValues.TLSKey" aria-hidden="true"></i>
+                  <i class="fa fa-circle-o-notch fa-spin" ng-if="state.uploadInProgress"></i>
+                </span>
+              </div>
+            </div>
+            <!-- !key-input -->
+          </div>
+          <!-- !tls-certs -->
+          <div class="form-group">
+            <div class="col-sm-12">
+              <button type="button" class="btn btn-primary btn-sm" ng-disabled="!formValues.Name || !formValues.URL || (formValues.TLS && (!formValues.TLSCACert || !formValues.TLSCert || !formValues.TLSKey))" ng-click="addEndpoint()">Add endpoint</button>
+              <i id="createEndpointSpinner" class="fa fa-cog fa-spin" style="margin-left: 5px; display: none;"></i>
+              <span class="text-danger" ng-if="state.error" style="margin: 5px;">
+                <i class="fa fa-exclamation-circle" aria-hidden="true"></i> {{ state.error }}
+              </span>
+            </div>
+          </div>
+        </form>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>
+
+<div class="row">
+  <div class="col-lg-12 col-md-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-plug" title="Endpoints">
+        <div class="pull-right">
+          <i id="loadEndpointsSpinner" class="fa fa-cog fa-2x fa-spin" style="margin-top: 5px;"></i>
+        </div>
+      </rd-widget-header>
+      <rd-widget-taskbar classes="col-lg-12">
+        <div class="pull-left">
+          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
+        </div>
+        <div class="pull-right">
+          <input type="text" id="filter" ng-model="state.filter" placeholder="Filter..." class="form-control input-sm" />
+        </div>
+      </rd-widget-taskbar>
+      <rd-widget-body classes="no-padding">
+        <div class="table-responsive">
+          <table class="table table-hover">
+            <thead>
+              <tr>
+                <th></th>
+                <th>
+                  <a ui-sref="endpoints" ng-click="order('Name')">
+                    Name
+                    <span ng-show="sortType == 'Name' && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
+                    <span ng-show="sortType == 'Name' && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
+                  </a>
+                </th>
+                <th>
+                  <a ui-sref="endpoints" ng-click="order('URL')">
+                    URL
+                    <span ng-show="sortType == 'URL' && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
+                    <span ng-show="sortType == 'URL' && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
+                  </a>
+                </th>
+                <th>
+                  <a ui-sref="endpoints" ng-click="order('TLS')">
+                    TLS
+                    <span ng-show="sortType == 'TLS' && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
+                    <span ng-show="sortType == 'TLS' && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
+                  </a>
+                </th>
+                <th></th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr dir-paginate="endpoint in (state.filteredEndpoints = (endpoints | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
+                <td><input type="checkbox" ng-model="endpoint.Checked" ng-change="selectItem(endpoint)" /></td>
+                <td><i class="fa fa-star" aria-hidden="true" ng-if="endpoint.Id === activeEndpoint.Id"></i> {{ endpoint.Name }}</td>
+                <td>{{ endpoint.URL | stripprotocol }}</td>
+                <td><i class="fa fa-shield" aria-hidden="true" ng-if="endpoint.TLS"></i></td>
+                <td>
+                  <span ng-if="endpoint.Id !== activeEndpoint.Id">
+                    <a ui-sref="endpoint({id: endpoint.Id})"><i class="fa fa-pencil-square-o" aria-hidden="true"></i> Edit</a>
+                  </span>
+                  <span class="small text-muted" ng-if="endpoint.Id === activeEndpoint.Id">
+                    <i class="fa fa-lock" aria-hidden="true"></i> You cannot edit the active endpoint
+                  </span>
+              </td>
+              </tr>
+              <tr ng-if="!endpoints">
+                <td colspan="5" class="text-center text-muted">Loading...</td>
+              </tr>
+              <tr ng-if="endpoints.length == 0">
+                <td colspan="5" class="text-center text-muted">No endpoints available.</td>
+              </tr>
+            </tbody>
+          </table>
+          <div ng-if="endpoints" class="pull-left pagination-controls">
+            <dir-pagination-controls></dir-pagination-controls>
+          </div>
+        </div>
+      </rd-widget-body>
+    <rd-widget>
+  </div>
+</div>

app/components/endpoints/endpointsController.js

@@ -0,0 +1,100 @@
+angular.module('endpoints', [])
+.controller('EndpointsController', ['$scope', '$state', 'EndpointService', 'Settings', 'Messages',
+function ($scope, $state, EndpointService, Settings, Messages) {
+  $scope.state = {
+    error: '',
+    uploadInProgress: false,
+    selectedItemCount: 0
+  };
+  $scope.sortType = 'Name';
+  $scope.sortReverse = true;
+  $scope.pagination_count = Settings.pagination_count;
+
+  $scope.formValues = {
+    Name: '',
+    URL: '',
+    TLS: false,
+    TLSCACert: null,
+    TLSCert: null,
+    TLSKey: null
+  };
+
+  $scope.order = function(sortType) {
+    $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
+    $scope.sortType = sortType;
+  };
+
+  $scope.selectItem = function (item) {
+    if (item.Checked) {
+      $scope.state.selectedItemCount++;
+    } else {
+      $scope.state.selectedItemCount--;
+    }
+  };
+
+  $scope.addEndpoint = function() {
+    $scope.state.error = '';
+    var name = $scope.formValues.Name;
+    var URL = $scope.formValues.URL;
+    var TLS = $scope.formValues.TLS;
+    var TLSCAFile = $scope.formValues.TLSCACert;
+    var TLSCertFile = $scope.formValues.TLSCert;
+    var TLSKeyFile = $scope.formValues.TLSKey;
+    EndpointService.createRemoteEndpoint(name, URL, TLS, TLSCAFile, TLSCertFile, TLSKeyFile, false).then(function success(data) {
+      Messages.send("Endpoint created", name);
+      $state.reload();
+    }, function error(err) {
+      $scope.state.uploadInProgress = false;
+      $scope.state.error = err.msg;
+    }, function update(evt) {
+      if (evt.upload) {
+        $scope.state.uploadInProgress = evt.upload;
+      }
+    });
+  };
+
+  $scope.removeAction = function () {
+    $('#loadEndpointsSpinner').show();
+    var counter = 0;
+    var complete = function () {
+      counter = counter - 1;
+      if (counter === 0) {
+        $('#loadEndpointsSpinner').hide();
+      }
+    };
+    angular.forEach($scope.endpoints, function (endpoint) {
+      if (endpoint.Checked) {
+        counter = counter + 1;
+        EndpointService.deleteEndpoint(endpoint.Id).then(function success(data) {
+          Messages.send("Endpoint deleted", endpoint.Name);
+          var index = $scope.endpoints.indexOf(endpoint);
+          $scope.endpoints.splice(index, 1);
+          complete();
+        }, function error(err) {
+          Messages.error("Failure", err, 'Unable to remove endpoint');
+          complete();
+        });
+      }
+    });
+  };
+
+  function fetchEndpoints() {
+    $('#loadEndpointsSpinner').show();
+    EndpointService.endpoints().then(function success(data) {
+      $scope.endpoints = data;
+      EndpointService.getActive().then(function success(data) {
+        $scope.activeEndpoint = data;
+        $('#loadEndpointsSpinner').hide();
+      }, function error(err) {
+        $('#loadEndpointsSpinner').hide();
+        Messages.error("Failure", err, "Unable to retrieve active endpoint");
+      });
+    }, function error(err) {
+      $('#loadEndpointsSpinner').hide();
+      Messages.error("Failure", err, "Unable to retrieve endpoints");
+      $scope.endpoints = [];
+    });
+  }
+
+  fetchEndpoints();
+}]);

app/components/events/events.html

@@ -49,13 +49,16 @@
               </tr>
             </thead>
             <tbody>
-              <tr ng-repeat="event in (events | filter:state.filter | orderBy:sortType:sortReverse)">
+              <tr dir-paginate="event in (events | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count)">
                 <td>{{ event.Time|getisodatefromtimestamp }}</td>
                 <td>{{ event.Type }}</td>
                 <td>{{ event.Details }}</td>
               </tr>
             </tbody>
           </table>
+          <div ng-if="events" class="pull-left pagination-controls">
+            <dir-pagination-controls></dir-pagination-controls>
+          </div>
         </div>
       </rd-widget-body>
     <rd-widget>

app/components/events/eventsController.js

@@ -4,6 +4,7 @@ function ($scope, Settings, Messages, Events) {
   $scope.state = {};
   $scope.sortType = 'Time';
   $scope.sortReverse = true;
+  $scope.pagination_count = Settings.pagination_count;
 
   $scope.order = function(sortType) {
     $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;

app/components/image/image.html

@@ -3,7 +3,7 @@
     <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>
-    Images > <a ui-sref="image({id: image.Id})">{{ image.Id }}</a>
+    <a ui-sref="images">Images</a> > <a ui-sref="image({id: image.Id})">{{ image.Id }}</a>
   </rd-header-content>
 </rd-header>
 
@@ -13,7 +13,7 @@
       <rd-widget-header icon="fa fa-tags" title="Image tags"></rd-widget-header>
       <rd-widget-body classes="no-padding">
         <div style="margin: 5px 10px;">
-          <span ng-repeat="tag in RepoTags" class="label label-primary image-tag">
+          <span ng-repeat="tag in RepoTags" class="label label-primary image-tag space-right">
             <a data-toggle="tooltip" class="interactive" title="Push to registry" ng-click="pushImage(tag)">
               <i class="fa fa-upload white-icon" aria-hidden="true"></i>
             </a>
@@ -82,7 +82,7 @@
               <td>ID</td>
               <td>
                 {{ image.Id }}
-                <button class="btn btn-xs btn-danger" ng-click="removeImage(image.Id)"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Delete this image</button>
+                <button class="btn btn-xs btn-danger" ng-click="removeImage(image.Id)"><i class="fa fa-trash space-right" aria-hidden="true"></i>Delete this image</button>
               </td>
             </tr>
             <tr ng-if="image.Parent">
@@ -130,7 +130,7 @@
             <tr ng-if="image.ContainerConfig.ExposedPorts">
               <td>EXPOSE</td>
               <td>
-                <span class="label label-default tag" ng-repeat="port in exposedPorts">
+                <span class="label label-default space-right" ng-repeat="port in exposedPorts">
                   {{ port }}
                 </span>
               </td>
@@ -138,7 +138,7 @@
             <tr ng-if="image.ContainerConfig.Volumes">
               <td>VOLUME</td>
               <td>
-                <span class="label label-default tag" ng-repeat="volume in volumes">
+                <span class="label label-default space-right" ng-repeat="volume in volumes">
                   {{ volume }}
                 </span>
               </td>

app/components/image/imageController.js

@@ -23,7 +23,7 @@ function ($scope, $stateParams, $state, Image, ImageHelper, Messages) {
     $('#loadingViewSpinner').show();
     var image = _.toLower($scope.config.Image);
     var registry = _.toLower($scope.config.Registry);
-    var imageConfig = ImageHelper.createImageConfig(image, registry);
+    var imageConfig = ImageHelper.createImageConfigForCommit(image, registry);
     Image.tag({id: $stateParams.id, tag: imageConfig.tag, repo: imageConfig.repo}, function (d) {
       Messages.send('Image successfully tagged');
       $('#loadingViewSpinner').hide();

app/components/images/images.html

@@ -55,7 +55,7 @@
       </rd-widget-header>
       <rd-widget-taskbar classes="col-lg-12">
         <div class="pull-left">
-          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Remove</button>
+          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
         </div>
         <div class="pull-right">
           <input type="text" id="filter" ng-model="state.filter" placeholder="Filter..." class="form-control input-sm" />
@@ -98,7 +98,7 @@
               </tr>
             </thead>
             <tbody>
-              <tr ng-repeat="image in (state.filteredImages = (images | filter:state.filter | orderBy:sortType:sortReverse))">
+              <tr dir-paginate="image in (state.filteredImages = (images | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
                 <td><input type="checkbox" ng-model="image.Checked" ng-change="selectItem(image)" /></td>
                 <td><a ui-sref="image({id: image.Id})">{{ image.Id|truncate:20}}</a></td>
                 <td>
@@ -107,11 +107,17 @@
                 <td>{{ image.VirtualSize|humansize }}</td>
                 <td>{{ image.Created|getisodatefromtimestamp }}</td>
               </tr>
+              <tr ng-if="!images">
+                <td colspan="5" class="text-center text-muted">Loading...</td>
+              </tr>
               <tr ng-if="images.length == 0">
                 <td colspan="5" class="text-center text-muted">No images available.</td>
               </tr>
             </tbody>
           </table>
+          <div ng-if="images" class="pull-left pagination-controls">
+            <dir-pagination-controls></dir-pagination-controls>
+          </div>
         </div>
       </rd-widget-body>
       <rd-widget>

app/components/images/imagesController.js

@@ -1,11 +1,11 @@
 angular.module('images', [])
-.controller('ImagesController', ['$scope', '$state', 'Config', 'Image', 'Messages',
-function ($scope, $state, Config, Image, Messages) {
+.controller('ImagesController', ['$scope', '$state', 'Config', 'Image', 'ImageHelper', 'Messages', 'Settings',
+function ($scope, $state, Config, Image, ImageHelper, Messages, Settings) {
   $scope.state = {};
   $scope.sortType = 'RepoTags';
   $scope.sortReverse = true;
   $scope.state.selectedItemCount = 0;
-  $scope.images = [];
+  $scope.pagination_count = Settings.pagination_count;
 
   $scope.config = {
     Image: '',
@@ -25,24 +25,11 @@ function ($scope, $state, Config, Image, Messages) {
     }
   };
 
-  function createImageConfig(imageName, registry) {
-    var imageNameAndTag = imageName.split(':');
-    var image = imageNameAndTag[0];
-    if (registry) {
-      image = registry + '/' + imageNameAndTag[0];
-    }
-    var imageConfig = {
-      fromImage: image,
-      tag: imageNameAndTag[1] ? imageNameAndTag[1] : 'latest'
-    };
-    return imageConfig;
-  }
-
   $scope.pullImage = function() {
     $('#pullImageSpinner').show();
     var image = _.toLower($scope.config.Image);
     var registry = _.toLower($scope.config.Registry);
-    var imageConfig = createImageConfig(image, registry);
+    var imageConfig = ImageHelper.createImageConfigForContainer(image, registry);
     Image.create(imageConfig, function (data) {
         var err = data.length > 0 && data[data.length - 1].hasOwnProperty('error');
         if (err) {
@@ -51,7 +38,7 @@ function ($scope, $state, Config, Image, Messages) {
           Messages.error('Error', {}, detail.error);
         } else {
           $('#pullImageSpinner').hide();
-          $state.go('images', {}, {reload: true});
+          $state.reload();
         }
     }, function (e) {
       $('#pullImageSpinner').hide();
@@ -98,11 +85,11 @@ function ($scope, $state, Config, Image, Messages) {
     }, function (e) {
       $('#loadImagesSpinner').hide();
       Messages.error("Failure", e, "Unable to retrieve images");
+      $scope.images = [];
     });
   }
 
   Config.$promise.then(function (c) {
-    $scope.availableRegistries = c.registries;
     fetchImages();
   });
 }]);

app/components/main/mainController.js

@@ -1,30 +1,15 @@
-angular.module('dashboard')
-.controller('MasterCtrl', ['$scope', '$cookieStore', 'Settings', 'Config', 'Info',
-function ($scope, $cookieStore, Settings, Config, Info) {
+angular.module('main', [])
+.controller('MainController', ['$scope', '$cookieStore',
+function ($scope, $cookieStore) {
+
   /**
   * Sidebar Toggle & Cookie Control
   */
   var mobileView = 992;
-
   $scope.getWidth = function() {
     return window.innerWidth;
   };
 
-  $scope.swarm_mode = false;
-
-  Config.$promise.then(function (c) {
-    $scope.swarm = c.swarm;
-    Info.get({}, function(d) {
-      if ($scope.swarm && !_.startsWith(d.ServerVersion, 'swarm')) {
-        $scope.swarm_mode = true;
-        $scope.swarm_manager = false;
-        if (d.Swarm.ControlAvailable) {
-          $scope.swarm_manager = true;
-        }
-      }
-    });
-  });
-
   $scope.$watch($scope.getWidth, function(newValue, oldValue) {
     if (newValue >= mobileView) {
       if (angular.isDefined($cookieStore.get('toggle'))) {
@@ -46,6 +31,4 @@ function ($scope, $cookieStore, Settings, Config, Info) {
   window.onresize = function() {
     $scope.$apply();
   };
-
-  $scope.uiVersion = Settings.uiVersion;
 }]);

app/components/network/network.html

@@ -3,7 +3,7 @@
     <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>
-    Networks > <a ui-sref="network({id: network.Id})">{{ network.Name }}</a>
+    <a ui-sref="networks">Networks</a> > <a ui-sref="network({id: network.Id})">{{ network.Name }}</a>
   </rd-header-content>
 </rd-header>
 
@@ -22,7 +22,7 @@
               <td>ID</td>
               <td>
                 {{ network.Id }}
-                <button class="btn btn-xs btn-danger" ng-click="removeNetwork(network.Id)"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Delete this network</button>
+                <button class="btn btn-xs btn-danger" ng-click="removeNetwork(network.Id)"><i class="fa fa-trash space-right" aria-hidden="true"></i>Delete this network</button>
               </td>
             </tr>
             <tr>
@@ -65,3 +65,34 @@
     </rd-widget>
   </div>
 </div>
+
+
+<div class="row" ng-if="!(network.Containers | emptyobject)">
+  <div class="col-lg-12 col-md-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-server" title="Containers in network"></rd-widget-header>
+      <rd-widget-body classes="no-padding">
+        <table class="table">
+          <thead>
+            <th>Container Name</th>
+            <th>IPv4 Address</th>
+            <th>IPv6 Address</th>
+            <th>MacAddress</th>
+            <th>Actions</th>
+          </thead>
+          <tbody>
+            <tr ng-repeat="container in containersInNetwork">
+              <td><a ui-sref="container({id: container.Id})">{{ container.Name }}</a></td>
+              <td>{{ container.IPv4Address || '-' }}</td>
+              <td>{{ container.IPv6Address || '-' }}</td>
+              <td>{{ container.MacAddress || '-' }}</td>
+              <td>
+                <button type="button" class="btn btn-xs btn-danger" ng-click="containerLeaveNetwork(network, container.Id)"><i class="fa fa-trash space-right" aria-hidden="true"></i>Leave Network</button>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>

app/components/network/networkController.js

@@ -1,6 +1,6 @@
 angular.module('network', [])
-.controller('NetworkController', ['$scope', '$state', '$stateParams', 'Network', 'Messages',
-function ($scope, $state, $stateParams, Network, Messages) {
+.controller('NetworkController', ['$scope', '$state', '$stateParams', 'Network', 'Container', 'ContainerHelper', 'Messages',
+function ($scope, $state, $stateParams, Network, Container, ContainerHelper, Messages) {
 
   $scope.removeNetwork = function removeNetwork(networkId) {
     $('#loadingViewSpinner').show();
@@ -19,12 +19,53 @@ function ($scope, $state, $stateParams, Network, Messages) {
     });
   };
 
-  $('#loadingViewSpinner').show();
-  Network.get({id: $stateParams.id}, function (d) {
-    $scope.network = d;
-    $('#loadingViewSpinner').hide();
-  }, function (e) {
-    $('#loadingViewSpinner').hide();
-    Messages.error("Failure", e, "Unable to retrieve network info");
-  });
+  $scope.containerLeaveNetwork = function containerLeaveNetwork(network, containerId) {
+    $('#loadingViewSpinner').show();
+    Network.disconnect({id: $stateParams.id}, { Container: containerId, Force: false }, function (d) {
+      if (d.message) {
+        $('#loadingViewSpinner').hide();
+        Messages.send("Error", {}, d.message);
+      } else {
+        $('#loadingViewSpinner').hide();
+        Messages.send("Container left network", $stateParams.id);
+        $state.go('network', {id: network.Id}, {reload: true});
+      }
+    }, function (e) {
+      $('#loadingViewSpinner').hide();
+      Messages.error("Failure", e, "Unable to disconnect container from network");
+    });
+  };
+
+  function getNetwork() {
+    $('#loadingViewSpinner').show();
+    Network.get({id: $stateParams.id}, function (d) {
+      $scope.network = d;
+      getContainersInNetwork(d);
+      $('#loadingViewSpinner').hide();
+    }, function (e) {
+      $('#loadingViewSpinner').hide();
+      Messages.error("Failure", e, "Unable to retrieve network info");
+    });
+  }
+
+  function getContainersInNetwork(network) {
+    if (network.Containers) {
+      Container.query({
+        filters: {network: [$stateParams.id]}
+      }, function (containersInNetworkResult) {
+        if ($scope.containersToHideLabels) {
+          containersInNetworkResult = ContainerHelper.hideContainers(containersInNetworkResult, $scope.containersToHideLabels);
+        }
+        var containersInNetwork = [];
+        containersInNetworkResult.forEach(function(container) {
+          var containerInNetwork = network.Containers[container.Id];
+          containerInNetwork.Id = container.Id;
+          containersInNetwork.push(containerInNetwork);
+        });
+        $scope.containersInNetwork = containersInNetwork;
+      });
+    }
+  }
+
+  getNetwork();
 }]);

app/components/networks/networks.html

@@ -23,12 +23,12 @@
           </div>
           <!-- !name-input -->
           <!-- tag-note -->
-          <div class="form-group" ng-if="swarm">
+          <div class="form-group" ng-if="endpointMode.provider === 'DOCKER_SWARM' || endpointMode.provider === 'DOCKER_SWARM_MODE'">
             <div class="col-sm-12">
               <span class="small text-muted">Note: The network will be created using the overlay driver and will allow containers to communicate across the hosts of your cluster.</span>
             </div>
           </div>
-          <div class="form-group" ng-if="!swarm">
+          <div class="form-group" ng-if="endpointMode.provider === 'DOCKER_STANDALONE'">
             <div class="col-sm-12">
               <span class="small text-muted">Note: The network will be created using the bridge driver.</span>
             </div>
@@ -57,7 +57,7 @@
       </rd-widget-header>
       <rd-widget-taskbar classes="col-lg-12">
         <div class="pull-left">
-          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Remove</button>
+          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
         </div>
         <div class="pull-right">
           <input type="text" id="filter" ng-model="state.filter" placeholder="Filter..." class="form-control input-sm" />
@@ -121,7 +121,7 @@
               </tr>
             </thead>
             <tbody>
-              <tr ng-repeat="network in ( state.filteredNetworks = (networks | filter:state.filter | orderBy:sortType:sortReverse))">
+              <tr dir-paginate="network in ( state.filteredNetworks = (networks | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
                 <td><input type="checkbox" ng-model="network.Checked" ng-change="selectItem(network)"/></td>
                 <td><a ui-sref="network({id: network.Id})">{{ network.Name|truncate:40}}</a></td>
                 <td>{{ network.Id }}</td>
@@ -131,11 +131,17 @@
                 <td>{{ network.IPAM.Config[0].Subnet ? network.IPAM.Config[0].Subnet : '-' }}</td>
                 <td>{{ network.IPAM.Config[0].Gateway ? network.IPAM.Config[0].Gateway : '-' }}</td>
               </tr>
+              <tr ng-if="!networks">
+                <td colspan="8" class="text-center text-muted">Loading...</td>
+              </tr>
               <tr ng-if="networks.length == 0">
                 <td colspan="8" class="text-center text-muted">No networks available.</td>
               </tr>
             </tbody>
           </table>
+          <div ng-if="networks" class="pull-left pagination-controls">
+            <dir-pagination-controls></dir-pagination-controls>
+          </div>
         </div>
       </rd-widget-body>
     <rd-widget>

app/components/networks/networksController.js

@@ -1,20 +1,19 @@
 angular.module('networks', [])
-.controller('NetworksController', ['$scope', '$state', 'Network', 'Config', 'Messages',
-function ($scope, $state, Network, Config, Messages) {
+.controller('NetworksController', ['$scope', '$state', 'Network', 'Config', 'Messages', 'Settings',
+function ($scope, $state, Network, Config, Messages, Settings) {
   $scope.state = {};
   $scope.state.selectedItemCount = 0;
   $scope.state.advancedSettings = false;
   $scope.sortType = 'Name';
   $scope.sortReverse = false;
-  $scope.networks = [];
-
+  $scope.pagination_count = Settings.pagination_count;
   $scope.config = {
     Name: ''
   };
 
   function prepareNetworkConfiguration() {
     var config = angular.copy($scope.config);
-    if ($scope.swarm) {
+    if ($scope.endpointMode.provider === 'DOCKER_SWARM' || $scope.endpointMode.provider === 'DOCKER_SWARM_MODE') {
       config.Driver = 'overlay';
       // Force IPAM Driver to 'default', should not be required.
       // See: https://github.com/docker/docker/issues/25735
@@ -35,7 +34,7 @@ function ($scope, $state, Network, Config, Messages) {
       } else {
         Messages.send("Network created", d.Id);
         $('#createNetworkSpinner').hide();
-        $state.go('networks', {}, {reload: true});
+        $state.reload();
       }
     }, function (e) {
       $('#createNetworkSpinner').hide();
@@ -93,11 +92,11 @@ function ($scope, $state, Network, Config, Messages) {
     }, function (e) {
       $('#loadNetworksSpinner').hide();
       Messages.error("Failure", e, "Unable to retrieve networks");
+      $scope.networks = [];
     });
   }
 
   Config.$promise.then(function (c) {
-    $scope.swarm = c.swarm;
     fetchNetworks();
   });
 }]);

app/components/service/service.html

@@ -6,7 +6,7 @@
     <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>
-    Services > <a ui-sref="service({id: service.Id})">{{ service.Name }}</a>
+    <a ui-sref="services">Services</a> > <a ui-sref="service({id: service.Id})">{{ service.Name }}</a>
   </rd-header-content>
 </rd-header>
 
@@ -33,7 +33,7 @@
               <td>ID</td>
               <td>
                 {{ service.Id }}
-                <button class="btn btn-xs btn-danger" ng-click="removeService()"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Delete this service</button>
+                <button class="btn btn-xs btn-danger" ng-click="removeService()"><i class="fa fa-trash space-right" aria-hidden="true"></i>Delete this service</button>
               </td>
             </tr>
             <tr>
@@ -43,20 +43,29 @@
             <tr ng-if="service.Mode === 'replicated'">
               <td>Replicas</td>
               <td>
-                <span ng-if="service.Mode === 'replicated' && !service.Scale">
+                <span ng-if="service.Mode === 'replicated' && !service.EditReplicas">
                   {{ service.Replicas }}
-                  <a class="interactive" ng-click="service.Scale = true; service.ReplicaCount = service.Replicas;"><i class="fa fa-arrows-v" aria-hidden="true"></i> Scale</a>
+                  <a class="interactive" ng-click="service.EditReplicas = true;"><i class="fa fa-arrows-v" aria-hidden="true"></i> Scale</a>
                 </span>
-                <span ng-if="service.Mode === 'replicated' && service.Scale">
-                  <input class="input-sm" type="number" ng-model="service.Replicas" />
-                  <a class="interactive" ng-click="service.Scale = false;"><i class="fa fa-times"></i></a>
+                <span ng-if="service.Mode === 'replicated' && service.EditReplicas">
+                  <input class="input-sm" type="number" ng-model="service.newServiceReplicas" />
+                  <a class="interactive" ng-click="service.EditReplicas = false;"><i class="fa fa-times"></i></a>
                   <a class="interactive" ng-click="scaleService(service)"><i class="fa fa-check-square-o"></i></a>
                 </span>
               </td>
             </tr>
             <tr>
               <td>Image</td>
-              <td>{{ service.Image }}</td>
+              <td ng-if="!service.EditImage">
+                {{ service.Image }}
+                <a href="" data-toggle="tooltip" title="Edit service image" ng-click="service.EditImage = true;"><i class="fa fa-edit"></i></a>
+              </td>
+
+              <td ng-if="service.EditImage">
+                <input type="text" class="containerNameInput" ng-model="service.newServiceImage">
+                <a class="interactive" ng-click="service.EditImage = false;"><i class="fa fa-times"></i></a>
+                <a class="interactive" ng-click="changeServiceImage(service)"><i class="fa fa-check-square-o"></i></a>
+              </td>
             </tr>
             <tr ng-if="service.Ports">
               <td>Published ports</td>
@@ -66,31 +75,154 @@
                 </div>
               </td>
             </tr>
-            <tr ng-if="service.Env">
-              <td>Env</td>
+            <tr ng-if="service.EnvironmentVariables">
+              <td>Environment variables</td>
               <td>
-                <table class="table table-bordered table-condensed">
-                  <tr ng-repeat="var in service.Env">
-                    <td>{{ var|key: '=' }}</td>
-                    <td>{{ var|value: '=' }}</td>
-                  </tr>
-                </table>
+                <div class="form-group">
+                  <div class="col-sm-11 nopadding">
+                    <span class="label label-default interactive fit-text-size" ng-click="addEnvironmentVariable(service)">
+                      <i class="fa fa-plus-circle" aria-hidden="true"></i> environment variable
+                    </span>
+                  </div>
+                  <!-- environment-variable-input-list -->
+                  <div class="col-sm-11 form-inline nopadding" style="margin-top: 10px;">
+                    <div ng-repeat="var in service.EnvironmentVariables" style="margin-top: 2px;">
+                      <div class="input-group col-sm-5 input-group-sm">
+                        <span class="input-group-addon fit-text-size">name</span>
+                        <input type="text" class="form-control" ng-model="var.key" ng-disabled="var.added" placeholder="e.g. FOO">
+                      </div>
+                      <div class="input-group col-sm-5 input-group-sm">
+                        <span class="input-group-addon fit-text-size">value</span>
+                        <input type="text" class="form-control" ng-model="var.value" ng-change="updateEnvironmentVariable(service, var)" placeholder="e.g. bar">
+                        <span class="input-group-btn">
+                          <button class="btn btn-default" type="button" ng-click="removeEnvironmentVariable(service, $index)">
+                            <i class="fa fa-minus" aria-hidden="true"></i>
+                          </button>
+                        </span>
+                      </div>
+                    </div>
+                  </div>
+                  <!-- !environment-variable-input-list -->
+                </div>
               </td>
             </tr>
-            <tr ng-if="service.Labels">
+            <tr>
               <td>Labels</td>
               <td>
-                <table class="table table-bordered table-condensed">
-                  <tr ng-repeat="(k, v) in service.Labels">
-                    <td>{{ k }}</td>
-                    <td>{{ v }}</td>
-                  </tr>
-                </table>
+                <div class="form-group">
+                  <div class="col-sm-11 nopadding">
+                    <span class="label label-default interactive fit-text-size" ng-click="addLabel(service)">
+                      <i class="fa fa-plus-circle" aria-hidden="true"></i> label
+                    </span>
+                  </div>
+                  <!-- labels-input-list -->
+                  <div class="col-sm-11 form-inline nopadding" style="margin-top: 10px;">
+                    <div ng-repeat="label in service.ServiceLabels" style="margin-top: 2px;">
+                      <div class="input-group col-sm-5 input-group-sm">
+                        <span class="input-group-addon fit-text-size">name</span>
+                        <input type="text" class="form-control" ng-model="label.key" placeholder="e.g. com.example.foo" ng-change="updateLabel(service, label)">
+                      </div>
+                      <div class="input-group col-sm-5 input-group-sm">
+                        <span class="input-group-addon fit-text-size">value</span>
+                        <input type="text" class="form-control" ng-model="label.value" placeholder="e.g. bar" ng-change="updateLabel(service, label)">
+                        <span class="input-group-btn">
+                          <button class="btn btn-default" type="button" ng-click="removeLabel(service, $index)">
+                            <i class="fa fa-minus" aria-hidden="true"></i>
+                          </button>
+                        </span>
+                      </div>
+                    </div>
+                  </div>
+                  <!-- !labels-input-list -->
+                </div>
+              </td>
+            </tr>
+            <tr>
+              <td>Container labels</td>
+              <td>
+                <div class="form-group">
+                  <div class="col-sm-11 nopadding">
+                    <span class="label label-default interactive fit-text-size" ng-click="addContainerLabel(service)">
+                      <i class="fa fa-plus-circle" aria-hidden="true"></i> container label
+                    </span>
+                  </div>
+                  <!-- labels-input-list -->
+                  <div class="col-sm-11 form-inline nopadding" style="margin-top: 10px;">
+                    <div ng-repeat="label in service.ServiceContainerLabels" style="margin-top: 2px;">
+                      <div class="input-group col-sm-5 input-group-sm">
+                        <span class="input-group-addon fit-text-size">name</span>
+                        <input type="text" class="form-control" ng-model="label.key" placeholder="e.g. com.example.foo" ng-change="updateLabel(service, label)">
+                      </div>
+                      <div class="input-group col-sm-5 input-group-sm">
+                        <span class="input-group-addon fit-text-size">value</span>
+                        <input type="text" class="form-control" ng-model="label.value" placeholder="e.g. bar" ng-change="updateLabel(service, label)">
+                        <span class="input-group-btn">
+                          <button class="btn btn-default" type="button" ng-click="removeContainerLabel(service, $index)">
+                            <i class="fa fa-minus" aria-hidden="true"></i>
+                          </button>
+                        </span>
+                      </div>
+                    </div>
+                  </div>
+                  <!-- !labels-input-list -->
+                </div>
+              </td>
+            </tr>
+            <tr>
+              <td>Update Parallelism</td>
+              <td>
+                <span ng-if="!service.EditParallelism">
+                  {{ service.UpdateParallelism }}
+                  <a class="interactive" ng-click="service.EditParallelism = true;"><i class="fa fa-arrows-v" aria-hidden="true"></i> Change</a>
+                </span>
+                <span ng-if="service.EditParallelism">
+                  <input class="input-sm" type="number" ng-model="service.newServiceUpdateParallelism" />
+                  <a class="interactive" ng-click="service.EditParallelism = false;"><i class="fa fa-times"></i></a>
+                  <a class="interactive" ng-click="changeParallelism(service)"><i class="fa fa-check-square-o"></i></a>
+                </span>
+              </td>
+            </tr>
+            <tr>
+              <td>Update Delay</td>
+              <td>
+                <span ng-if="!service.EditDelay">
+                  {{ service.UpdateDelay }}
+                  <a class="interactive" ng-click="service.EditDelay = true;"><i class="fa fa-arrows-v" aria-hidden="true"></i> Change</a>
+                </span>
+                <span ng-if="service.EditDelay">
+                  <input class="input-sm" type="number" ng-model="service.newServiceUpdateDelay" />
+                  <a class="interactive" ng-click="service.EditDelay = false;"><i class="fa fa-times"></i></a>
+                  <a class="interactive" ng-click="changeUpdateDelay(service)"><i class="fa fa-check-square-o"></i></a>
+                </span>
+              </td>
+            </tr>
+            <tr>
+              <td>Update Failure Action</td>
+              <td>
+                <div class="form-group">
+                  <div class="col-sm-3">
+                    <label class="radio-inline">
+                      <input type="radio" name="failure_action" ng-model="service.newServiceUpdateFailureAction" value="continue" ng-change="changeUpdateFailureAction(service)">
+                      Continue
+                    </label>
+                    <label class="radio-inline">
+                      <input type="radio" name="failure_action" ng-model="service.newServiceUpdateFailureAction" value="pause" ng-change="changeUpdateFailureAction(service)">
+                      Pause
+                    </label>
+                  </div>
+                  <div class="col-sm-8"></div>
+                </div>
               </td>
             </tr>
           </tbody>
         </table>
       </rd-widget-body>
+      <rd-widget-footer ng-if="service.hasChanges">
+        <div>
+            <button type="button" class="btn btn-primary" ng-click="updateService(service)">Save changes</button>
+            <button type="button" class="btn btn-default" ng-click="cancelChanges(service)">Reset</button>
+        </div>
+      </rd-widget-footer>
     </rd-widget>
   </div>
 </div>
@@ -126,16 +258,16 @@
                 </a>
               </th>
               <th>
-                <a ui-sref="service" ng-click="order('UpdatedAt')">
+                <a ui-sref="service" ng-click="order('Updated')">
                   Last update
-                  <span ng-show="sortType == 'UpdatedAt' && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
-                  <span ng-show="sortType == 'UpdatedAt' && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
+                  <span ng-show="sortType == 'Updated' && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
+                  <span ng-show="sortType == 'Updated' && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
                 </a>
               </th>
             </tr>
           </thead>
           <tbody>
-            <tr ng-repeat="task in (filteredTasks = ( tasks | orderBy:sortType:sortReverse))">
+            <tr dir-paginate="task in (filteredTasks = ( tasks | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
               <td><a ui-sref="task({ id: task.Id })">{{ task.Id }}</a></td>
               <td><span class="label label-{{ task.Status|taskstatusbadge }}">{{ task.Status }}</span></td>
               <td>{{ task.Slot }}</td>
@@ -144,6 +276,9 @@
             </tr>
           </tbody>
         </table>
+        <div ng-if="tasks" class="pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </rd-widget-body>
     </rd-widget>
   </div>

app/components/service/serviceController.js

@@ -1,12 +1,15 @@
 angular.module('service', [])
-.controller('ServiceController', ['$scope', '$stateParams', '$state', 'Service', 'ServiceHelper', 'Task', 'Node', 'Messages',
-function ($scope, $stateParams, $state, Service, ServiceHelper, Task, Node, Messages) {
+.controller('ServiceController', ['$scope', '$stateParams', '$state', 'Service', 'ServiceHelper', 'Task', 'Node', 'Messages', 'Settings',
+function ($scope, $stateParams, $state, Service, ServiceHelper, Task, Node, Messages, Settings) {
 
   $scope.service = {};
   $scope.tasks = [];
   $scope.displayNode = false;
   $scope.sortType = 'Status';
   $scope.sortReverse = false;
+  $scope.pagination_count = Settings.pagination_count;
+
+  var previousServiceValues = {};
 
   $scope.order = function (sortType) {
     $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
@@ -14,37 +17,103 @@ function ($scope, $stateParams, $state, Service, ServiceHelper, Task, Node, Mess
   };
 
   $scope.renameService = function renameService(service) {
+    updateServiceAttribute(service, 'Name', service.newServiceName || service.name);
+    service.EditName = false;
+  };
+  $scope.changeServiceImage = function changeServiceImage(service) {
+    updateServiceAttribute(service, 'Image', service.newServiceImage || service.image);
+    service.EditImage = false;
+  };
+  $scope.scaleService = function scaleService(service) {
+    updateServiceAttribute(service, 'Replicas', service.newServiceReplicas || service.Replicas);
+    service.EditReplicas = false;
+  };
+
+  $scope.addEnvironmentVariable = function addEnvironmentVariable(service) {
+    service.EnvironmentVariables.push({ key: '', value: '', originalValue: '' });
+    service.hasChanges = true;
+  };
+  $scope.removeEnvironmentVariable = function removeEnvironmentVariable(service, index) {
+    var removedElement = service.EnvironmentVariables.splice(index, 1);
+    service.hasChanges = service.hasChanges || removedElement !== null;
+  };
+  $scope.updateEnvironmentVariable = function updateEnvironmentVariable(service, variable) {
+    service.hasChanges = service.hasChanges || variable.value !== variable.originalValue;
+  };
+  $scope.addLabel = function addLabel(service) {
+    service.hasChanges = true;
+    service.ServiceLabels.push({ key: '', value: '', originalValue: '' });
+  };
+  $scope.removeLabel = function removeLabel(service, index) {
+    var removedElement = service.ServiceLabels.splice(index, 1);
+    service.hasChanges = service.hasChanges || removedElement !== null;
+  };
+  $scope.updateLabel = function updateLabel(service, label) {
+    service.hasChanges = service.hasChanges || label.value !== label.originalValue;
+  };
+  $scope.addContainerLabel = function addContainerLabel(service) {
+    service.hasChanges = true;
+    service.ServiceContainerLabels.push({ key: '', value: '', originalValue: '' });
+  };
+  $scope.removeContainerLabel = function removeContainerLabel(service, index) {
+    var removedElement = service.ServiceContainerLabels.splice(index, 1);
+    service.hasChanges = service.hasChanges || removedElement !== null;
+  };
+
+  $scope.changeParallelism = function changeParallelism(service) {
+    updateServiceAttribute(service, 'UpdateParallelism', service.newServiceUpdateParallelism);
+    service.EditParallelism = false;
+  };
+  $scope.changeUpdateDelay = function changeUpdateDelay(service) {
+    updateServiceAttribute(service, 'UpdateDelay', service.newServiceUpdateDelay);
+    service.EditDelay = false;
+  };
+  $scope.changeUpdateFailureAction = function changeUpdateFailureAction(service) {
+    updateServiceAttribute(service, 'UpdateFailureAction', service.newServiceUpdateFailureAction);
+  };
+
+  $scope.cancelChanges = function changeServiceImage(service) {
+    Object.keys(previousServiceValues).forEach(function(attribute) {
+      service[attribute] = previousServiceValues[attribute]; // reset service values
+      service['newService' + attribute] = previousServiceValues[attribute]; // reset edit fields
+    });
+    previousServiceValues = {}; // clear out all changes
+    // clear out environment variable changes
+    service.EnvironmentVariables = translateEnvironmentVariables(service.Env);
+    service.ServiceLabels = translateLabelsToServiceLabels(service.Labels);
+    service.ServiceContainerLabels = translateLabelsToServiceLabels(service.ContainerLabels);
+
+    service.hasChanges = false;
+  };
+
+  $scope.updateService = function updateService(service) {
     $('#loadServicesSpinner').show();
-    var serviceName = service.Name;
     var config = ServiceHelper.serviceToConfig(service.Model);
     config.Name = service.newServiceName;
+    config.Labels = translateServiceLabelsToLabels(service.ServiceLabels);
+    config.TaskTemplate.ContainerSpec.Env = translateEnvironmentVariablesToEnv(service.EnvironmentVariables);
+    config.TaskTemplate.ContainerSpec.Labels = translateServiceLabelsToLabels(service.ServiceContainerLabels);
+    config.TaskTemplate.ContainerSpec.Image = service.newServiceImage;
+    if (service.Mode === 'replicated') {
+      config.Mode.Replicated.Replicas = service.Replicas;
+    }
+
+    config.UpdateConfig = {
+      Parallelism: service.newServiceUpdateParallelism,
+      Delay: service.newServiceUpdateDelay,
+      FailureAction: service.newServiceUpdateFailureAction
+    };
+
     Service.update({ id: service.Id, version: service.Version }, config, function (data) {
       $('#loadServicesSpinner').hide();
-      Messages.send("Service successfully renamed", "New name: " + service.newServiceName);
+      Messages.send("Service successfully updated", "Service updated");
       $state.go('service', {id: service.Id}, {reload: true});
     }, function (e) {
       $('#loadServicesSpinner').hide();
-      service.EditName = false;
-      service.Name = serviceName;
-      Messages.error("Failure", e, "Unable to rename service");
+      Messages.error("Failure", e, "Unable to update service");
     });
   };
 
-  $scope.scaleService = function scaleService(service) {
-    $('#loadServicesSpinner').show();
-    var config = ServiceHelper.serviceToConfig(service.Model);
-    config.Mode.Replicated.Replicas = service.Replicas;
-    Service.update({ id: service.Id, version: service.Version }, config, function (data) {
-      $('#loadServicesSpinner').hide();
-      Messages.send("Service successfully scaled", "New replica count: " + service.Replicas);
-      $state.go('service', {id: service.Id}, {reload: true});
-    }, function (e) {
-      $('#loadServicesSpinner').hide();
-      service.Scale = false;
-      service.Replicas = service.ReplicaCount;
-      Messages.error("Failure", e, "Unable to scale service");
-    });
-  };
 
   $scope.removeService = function removeService() {
     $('#loadingViewSpinner').show();
@@ -68,6 +137,16 @@ function ($scope, $stateParams, $state, Service, ServiceHelper, Task, Node, Mess
     Service.get({id: $stateParams.id}, function (d) {
       var service = new ServiceViewModel(d);
       service.newServiceName = service.Name;
+      service.newServiceImage = service.Image;
+      service.newServiceReplicas = service.Replicas;
+      service.newServiceUpdateParallelism = service.UpdateParallelism;
+      service.newServiceUpdateDelay = service.UpdateDelay;
+      service.newServiceUpdateFailureAction = service.UpdateFailureAction;
+
+      service.EnvironmentVariables = translateEnvironmentVariables(service.Env);
+      service.ServiceLabels = translateLabelsToServiceLabels(service.Labels);
+      service.ServiceContainerLabels = translateLabelsToServiceLabels(service.ContainerLabels);
+
       $scope.service = service;
       Task.query({filters: {service: [service.Name]}}, function (tasks) {
         Node.query({}, function (nodes) {
@@ -93,5 +172,60 @@ function ($scope, $stateParams, $state, Service, ServiceHelper, Task, Node, Mess
     });
   }
 
+  function updateServiceAttribute(service, name, newValue) {
+    // ensure we only capture the original previous value, in case we update the attribute multiple times
+    if (!previousServiceValues[name]) {
+      previousServiceValues[name] = service[name];
+    }
+    // update the attribute
+    service[name] = newValue;
+    service.hasChanges = true;
+  }
+
+  function translateEnvironmentVariables(env) {
+    if (env) {
+      var variables = [];
+      env.forEach(function(variable) {
+        var idx = variable.indexOf('=');
+        var keyValue = [variable.slice(0,idx), variable.slice(idx+1)];
+        var originalValue = (keyValue.length > 1) ? keyValue[1] : '';
+        variables.push({ key: keyValue[0], value: originalValue, originalValue: originalValue, added: true});
+      });
+      return variables;
+    }
+    return [];
+  }
+  function translateEnvironmentVariablesToEnv(env) {
+    if (env) {
+      var variables = [];
+      env.forEach(function(variable) {
+        if (variable.key && variable.key !== '' && variable.value && variable.value !== '') {
+          variables.push(variable.key + '=' + variable.value);
+        }
+      });
+      return variables;
+    }
+    return [];
+  }
+
+  function translateLabelsToServiceLabels(Labels) {
+    var labels = [];
+    if (Labels) {
+      Object.keys(Labels).forEach(function(key) {
+        labels.push({ key: key, value: Labels[key], originalValue: Labels[key], added: true});
+      });
+    }
+    return labels;
+  }
+  function translateServiceLabelsToLabels(labels) {
+    var Labels = {};
+    if (labels) {
+      labels.forEach(function(label) {
+        Labels[label.key] = label.value;
+      });
+    }
+    return Labels;
+  }
+
   fetchServiceDetails();
 }]);

app/components/services/services.html

@@ -17,7 +17,7 @@
       </rd-widget-header>
       <rd-widget-taskbar classes="col-lg-12 col-md-12 col-xs-12">
         <div class="pull-left">
-          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Remove</button>
+          <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
           <a class="btn btn-default btn-responsive" type="button" ui-sref="actions.create.service">Add service</a>
         </div>
         <div class="pull-right">
@@ -52,7 +52,7 @@
               </th>
             </thead>
             <tbody>
-              <tr ng-repeat="service in (state.filteredServices = ( services | filter:state.filter | orderBy:sortType:sortReverse))">
+              <tr dir-paginate="service in (state.filteredServices = ( services | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
                 <td><input type="checkbox" ng-model="service.Checked" ng-change="selectItem(service)"/></td>
                 <td><a ui-sref="service({id: service.Id})">{{ service.Name }}</a></td>
                 <td>{{ service.Image }}</td>
@@ -69,8 +69,17 @@
                   </span>
                 </td>
               </tr>
+              <tr ng-if="!services">
+                <td colspan="4" class="text-center text-muted">Loading...</td>
+              </tr>
+              <tr ng-if="services.length == 0">
+                <td colspan="4" class="text-center text-muted">No services available.</td>
+              </tr>
             </tbody>
           </table>
+          <div ng-if="services" class="pull-left pagination-controls">
+            <dir-pagination-controls></dir-pagination-controls>
+          </div>
         </div>
       </rd-widget-body>
     <rd-widget>

app/components/services/servicesController.js

@@ -1,12 +1,11 @@
 angular.module('services', [])
-.controller('ServicesController', ['$scope', '$stateParams', '$state', 'Service', 'ServiceHelper', 'Messages',
-function ($scope, $stateParams, $state, Service, ServiceHelper, Messages) {
-
-  $scope.services = [];
+.controller('ServicesController', ['$scope', '$stateParams', '$state', 'Service', 'ServiceHelper', 'Messages', 'Settings',
+function ($scope, $stateParams, $state, Service, ServiceHelper, Messages, Settings) {
   $scope.state = {};
   $scope.state.selectedItemCount = 0;
   $scope.sortType = 'Name';
   $scope.sortReverse = false;
+  $scope.pagination_count = Settings.pagination_count;
 
   $scope.scaleService = function scaleService(service) {
     $('#loadServicesSpinner').show();
@@ -15,7 +14,7 @@ function ($scope, $stateParams, $state, Service, ServiceHelper, Messages) {
     Service.update({ id: service.Id, version: service.Version }, config, function (data) {
       $('#loadServicesSpinner').hide();
       Messages.send("Service successfully scaled", "New replica count: " + service.Replicas);
-      $state.go('services', {}, {reload: true});
+      $state.reload();
     }, function (e) {
       $('#loadServicesSpinner').hide();
       service.Scale = false;
@@ -77,6 +76,7 @@ function ($scope, $stateParams, $state, Service, ServiceHelper, Messages) {
     }, function(e) {
       $('#loadServicesSpinner').hide();
       Messages.error("Failure", e, "Unable to retrieve services");
+      $scope.services = [];
     });
   }
 

app/components/settings/settings.html

@@ -0,0 +1,67 @@
+<rd-header>
+  <rd-header-title title="Settings">
+  </rd-header-title>
+  <rd-header-content>Settings</rd-header-content>
+</rd-header>
+
+<div class="row">
+  <div class="col-lg-12 col-md-12 col-xs-12">
+    <rd-widget>
+      <rd-widget-header icon="fa-lock" title="Change user password"></rd-widget-header>
+      <rd-widget-body>
+        <form class="form-horizontal" style="margin-top: 15px;">
+          <!-- current-password-input -->
+          <div class="form-group">
+            <label for="current_password" class="col-sm-2 control-label text-left">Current password</label>
+            <div class="col-sm-8">
+              <div class="input-group">
+                <span class="input-group-addon"><i class="fa fa-lock" aria-hidden="true"></i></span>
+                <input type="password" class="form-control" ng-model="formValues.currentPassword" id="current_password">
+              </div>
+            </div>
+          </div>
+          <!-- !current-password-input -->
+          <div class="form-group" style="margin-left: 5px;">
+            <p>
+              <i ng-class="{true: 'fa fa-check green-icon', false: 'fa fa-times red-icon'}[formValues.newPassword.length >= 8]" aria-hidden="true"></i>
+              Your new password must be at least 8 characters long
+            </p>
+          </div>
+          <!-- new-password-input -->
+          <div class="form-group">
+            <label for="new_password" class="col-sm-2 control-label text-left">New password</label>
+            <div class="col-sm-8">
+              <div class="input-group">
+                <span class="input-group-addon"><i class="fa fa-lock" aria-hidden="true"></i></span>
+                <input type="password" class="form-control" ng-model="formValues.newPassword" id="new_password">
+              </div>
+            </div>
+          </div>
+          <!-- !new-password-input -->
+          <!-- confirm-password-input -->
+          <div class="form-group">
+            <label for="confirm_password" class="col-sm-2 control-label text-left">Confirm password</label>
+            <div class="col-sm-8">
+              <div class="input-group">
+                <span class="input-group-addon"><i class="fa fa-lock" aria-hidden="true"></i></span>
+                <input type="password" class="form-control" ng-model="formValues.confirmPassword" id="confirm_password">
+                <span class="input-group-addon"><i ng-class="{true: 'fa fa-check green-icon', false: 'fa fa-times red-icon'}[formValues.newPassword !== '' && formValues.newPassword === formValues.confirmPassword]" aria-hidden="true"></i></span>
+              </div>
+            </div>
+          </div>
+          <!-- !confirm-password-input -->
+          <div class="form-group">
+            <div class="col-sm-2">
+              <button type="submit" class="btn btn-primary btn-sm" ng-disabled="!formValues.currentPassword || formValues.newPassword.length < 8 || formValues.newPassword !== formValues.confirmPassword" ng-click="updatePassword()">Update password</button>
+            </div>
+            <div class="col-sm-10">
+              <p class="pull-left text-danger" ng-if="invalidPassword" style="margin: 5px;">
+                <i class="fa fa-exclamation-circle" aria-hidden="true"></i> Current password is not valid
+              </p>
+            </div>
+          </div>
+        </form>
+      </rd-widget-body>
+    </rd-widget>
+  </div>
+</div>

app/components/settings/settingsController.js

@@ -0,0 +1,30 @@
+angular.module('settings', [])
+.controller('SettingsController', ['$scope', '$state', '$sanitize', 'Users', 'Messages',
+function ($scope, $state, $sanitize, Users, Messages) {
+  $scope.formValues = {
+    currentPassword: '',
+    newPassword: '',
+    confirmPassword: ''
+  };
+
+  $scope.updatePassword = function() {
+    $scope.invalidPassword = false;
+    $scope.error = false;
+    var currentPassword = $sanitize($scope.formValues.currentPassword);
+    Users.checkPassword({ username: $scope.username, password: currentPassword }, function (d) {
+      if (d.valid) {
+        var newPassword = $sanitize($scope.formValues.newPassword);
+        Users.update({ username: $scope.username, password: newPassword }, function (d) {
+          Messages.send("Success", "Password successfully updated");
+          $state.reload();
+        }, function (e) {
+          Messages.error("Failure", e, "Unable to update password");
+        });
+      } else {
+        $scope.invalidPassword = true;
+      }
+    }, function (e) {
+      Messages.error("Failure", e, "Unable to check password validity");
+    });
+  };
+}]);

app/components/sidebar/sidebar.html

@@ -0,0 +1,66 @@
+<!-- Sidebar -->
+<div id="sidebar-wrapper">
+  <ul class="sidebar">
+    <li class="sidebar-main">
+      <a ng-click="toggleSidebar()" class="interactive">
+        <img ng-if="logo" ng-src="{{ logo }}" class="img-responsive logo">
+        <img ng-if="!logo" src="images/logo.png" class="img-responsive logo" alt="Portainer">
+        <span class="menu-icon glyphicon glyphicon-transfer"></span>
+      </a>
+    </li>
+    <li class="sidebar-title">
+      <span>Active endpoint</span>
+    </li>
+    <li class="sidebar-title">
+      <select class="select-endpoint form-control" ng-options="endpoint.Name for endpoint in endpoints" ng-model="activeEndpoint" ng-change="switchEndpoint(activeEndpoint)">
+      </select>
+    </li>
+    <li class="sidebar-title"><span>Endpoint actions</span></li>
+    <li class="sidebar-list">
+      <a ui-sref="dashboard">Dashboard <span class="menu-icon fa fa-tachometer"></span></a>
+    </li>
+    <li class="sidebar-list">
+      <a ui-sref="templates">App Templates <span class="menu-icon fa fa-rocket"></span></a>
+    </li>
+    <li class="sidebar-list" ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">
+      <a ui-sref="services">Services <span class="menu-icon fa fa-list-alt"></span></a>
+    </li>
+    <li class="sidebar-list">
+      <a ui-sref="containers">Containers <span class="menu-icon fa fa-server"></span></a>
+    </li>
+    <li class="sidebar-list">
+      <a ui-sref="images">Images <span class="menu-icon fa fa-clone"></span></a>
+    </li>
+    <li class="sidebar-list">
+      <a ui-sref="networks">Networks <span class="menu-icon fa fa-sitemap"></span></a>
+    </li>
+    <li class="sidebar-list">
+      <a ui-sref="volumes">Volumes <span class="menu-icon fa fa-cubes"></span></a>
+    </li>
+    <li class="sidebar-list" ng-if="endpointMode.provider === 'DOCKER_STANDALONE'">
+      <a ui-sref="events">Events <span class="menu-icon fa fa-history"></span></a>
+    </li>
+    <li class="sidebar-list" ng-if="endpointMode.provider === 'DOCKER_SWARM' || (endpointMode.provider === 'DOCKER_SWARM_MODE' && endpointMode.role === 'MANAGER')">
+      <a ui-sref="swarm">Swarm <span class="menu-icon fa fa-object-group"></span></a>
+    </li>
+    <li class="sidebar-list" ng-if="endpointMode.provider === 'DOCKER_STANDALONE'">
+      <a ui-sref="docker">Docker <span class="menu-icon fa fa-th"></span></a>
+    </li>
+    <li class="sidebar-title"><span>Portainer settings</span></li>
+    <li class="sidebar-list">
+      <a ui-sref="settings">Password <span class="menu-icon fa fa-lock"></span></a>
+    </li>
+    <li class="sidebar-list">
+      <a ui-sref="endpoints">Endpoints <span class="menu-icon fa fa-plug"></span></a>
+    </li>
+  </ul>
+  <div class="sidebar-footer">
+    <div class="col-xs-12">
+      <a href="https://github.com/portainer/portainer" target="_blank">
+        <i class="fa fa-github" aria-hidden="true"></i>
+        Portainer {{ uiVersion }}
+      </a>
+    </div>
+  </div>
+</div>
+<!-- End Sidebar -->

app/components/sidebar/sidebarController.js

@@ -0,0 +1,38 @@
+angular.module('sidebar', [])
+.controller('SidebarController', ['$scope', '$state', 'Settings', 'Config', 'EndpointService', 'EndpointMode', 'Messages',
+function ($scope, $state, Settings, Config, EndpointService, EndpointMode, Messages) {
+
+  Config.$promise.then(function (c) {
+    $scope.logo = c.logo;
+  });
+
+  $scope.uiVersion = Settings.uiVersion;
+
+  $scope.switchEndpoint = function(endpoint) {
+    EndpointService.setActive(endpoint.Id).then(function success(data) {
+      EndpointMode.determineEndpointMode();
+      $state.reload();
+    }, function error(err) {
+      Messages.error("Failure", err, "Unable to switch to new endpoint");
+    });
+  };
+
+  function fetchEndpoints() {
+    EndpointService.endpoints().then(function success(data) {
+      $scope.endpoints = data;
+      EndpointService.getActive().then(function success(data) {
+        angular.forEach($scope.endpoints, function (endpoint) {
+          if (endpoint.Id === data.Id) {
+            $scope.activeEndpoint = endpoint;
+          }
+        });
+      }, function error(err) {
+        Messages.error("Failure", err, "Unable to retrieve active endpoint");
+      });
+    }, function error(err) {
+      $scope.endpoints = [];
+    });
+  }
+
+  fetchEndpoints();
+}]);

app/components/stats/stats.html

@@ -1,7 +1,7 @@
 <rd-header>
   <rd-header-title title="Container stats"></rd-header-title>
   <rd-header-content>
-    Containers > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a> > Stats
+    <a ui-sref="containers">Containers</a> > <a ui-sref="container({id: container.Id})">{{ container.Name|trimcontainername }}</a> > Stats
   </rd-header-content>
 </rd-header>
 
@@ -59,15 +59,24 @@
         <table class="table table-striped">
           <thead>
             <tr>
-              <th ng-repeat="title in containerTop.Titles">{{title}}</th>
+              <th ng-repeat="title in containerTop.Titles">
+                <a ui-sref="stats({id: container.Id})" ng-click="order(title)">
+                  {{title}}
+                  <span ng-show="sortType == title && !sortReverse" class="glyphicon glyphicon-chevron-down"></span>
+                  <span ng-show="sortType == title && sortReverse" class="glyphicon glyphicon-chevron-up"></span>
+                </a>
+              </th>
             </tr>
           </thead>
           <tbody>
-            <tr ng-repeat="processInfos in containerTop.Processes">
+            <tr dir-paginate="processInfos in state.filteredProcesses = (containerTop.Processes | orderBy:sortType:sortReverse |  itemsPerPage: pagination_count)">
               <td ng-repeat="processInfo in processInfos track by $index">{{processInfo}}</td>
             </tr>
           </tbody>
         </table>
+        <div ng-if="containerTop.Processes" class="pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </rd-widget-body>
     </rd-widget>
   </div>

app/components/stats/statsController.js

@@ -4,6 +4,14 @@ function (Settings, $scope, Messages, $timeout, Container, ContainerTop, $stateP
   // TODO: Force scale to 0-100 for cpu, fix charts on dashboard,
   // TODO: Force memory scale to 0 - max memory
   $scope.ps_args = '';
+  $scope.state = {};
+  $scope.sortType = 'CMD';
+  $scope.sortReverse = false;
+  $scope.pagination_count = Settings.pagination_count;
+  $scope.order = function (sortType) {
+    $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
+    $scope.sortType = sortType;
+  };
   $scope.getTop = function () {
       ContainerTop.get($stateParams.id, {
           ps_args: $scope.ps_args

app/components/swarm/swarm.html

@@ -16,14 +16,14 @@
           <tbody>
             <tr>
               <td>Nodes</td>
-              <td ng-if="!swarm_mode">{{ swarm.Nodes }}</td>
-              <td ng-if="swarm_mode">{{ info.Swarm.Nodes }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM'">{{ swarm.Nodes }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">{{ info.Swarm.Nodes }}</td>
             </tr>
-            <tr ng-if="!swarm_mode">
+            <tr ng-if="endpointMode.provider === 'DOCKER_SWARM'">
               <td>Images</td>
               <td>{{ info.Images }}</td>
             </tr>
-            <tr ng-if="!swarm_mode">
+            <tr ng-if="endpointMode.provider === 'DOCKER_SWARM'">
               <td>Swarm version</td>
               <td>{{ docker.Version|swarmversion }}</td>
             </tr>
@@ -31,29 +31,29 @@
               <td>Docker API version</td>
               <td>{{ docker.ApiVersion }}</td>
             </tr>
-            <tr ng-if="!swarm_mode">
+            <tr ng-if="endpointMode.provider === 'DOCKER_SWARM'">
               <td>Strategy</td>
               <td>{{ swarm.Strategy }}</td>
             </tr>
             <tr>
               <td>Total CPU</td>
-              <td ng-if="!swarm_mode">{{ info.NCPU }}</td>
-              <td ng-if="swarm_mode">{{ totalCPU }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM'">{{ info.NCPU }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">{{ totalCPU }}</td>
             </tr>
             <tr>
               <td>Total memory</td>
-              <td ng-if="!swarm_mode">{{ info.MemTotal|humansize: 2 }}</td>
-              <td ng-if="swarm_mode">{{ totalMemory|humansize: 2 }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM'">{{ info.MemTotal|humansize: 2 }}</td>
+              <td ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">{{ totalMemory|humansize: 2 }}</td>
             </tr>
-            <tr ng-if="!swarm_mode">
+            <tr ng-if="endpointMode.provider === 'DOCKER_SWARM'">
               <td>Operating system</td>
               <td>{{ info.OperatingSystem }}</td>
             </tr>
-            <tr ng-if="!swarm_mode">
+            <tr ng-if="endpointMode.provider === 'DOCKER_SWARM'">
               <td>Kernel version</td>
               <td>{{ info.KernelVersion }}</td>
             </tr>
-            <tr ng-if="!swarm_mode">
+            <tr ng-if="endpointMode.provider === 'DOCKER_SWARM'">
               <td>Go version</td>
               <td>{{ docker.GoVersion }}</td>
             </tr>
@@ -65,7 +65,7 @@
 </div>
 
 <div class="row">
-  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12" ng-if="!swarm_mode">
+  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12" ng-if="endpointMode.provider === 'DOCKER_SWARM'">
     <rd-widget>
       <rd-widget-header icon="fa-hdd-o" title="Node status"></rd-widget-header>
       <rd-widget-body classes="no-padding">
@@ -117,7 +117,7 @@
             </tr>
           </thead>
           <tbody>
-            <tr ng-repeat="node in (state.filteredNodes = (swarm.Status | filter:state.filter | orderBy:sortType:sortReverse))">
+            <tr dir-paginate="node in (state.filteredNodes = (swarm.Status | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
               <td>{{ node.name }}</td>
               <td>{{ node.cpu }}</td>
               <td>{{ node.memory }}</td>
@@ -127,10 +127,13 @@
             </tr>
           </tbody>
         </table>
+        <div class="pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </rd-widget-body>
     </rd-widget>
   </div>
-  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12" ng-if="swarm_mode">
+  <div class="col-lg-12 col-md-12 col-sm-12 col-xs-12" ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">
     <rd-widget>
       <rd-widget-header icon="fa-hdd-o" title="Node status"></rd-widget-header>
       <rd-widget-body classes="no-padding">
@@ -182,7 +185,7 @@
             </tr>
           </thead>
           <tbody>
-            <tr ng-repeat="node in (state.filteredNodes = (nodes | filter:state.filter | orderBy:sortType:sortReverse))">
+            <tr dir-paginate="node in (state.filteredNodes = (nodes | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
               <td>{{ node.Description.Hostname }}</td>
               <td>{{ node.Spec.Role }}</td>
               <td>{{ node.Description.Resources.NanoCPUs / 1000000000 }}</td>
@@ -192,6 +195,9 @@
             </tr>
           </tbody>
         </table>
+        <div class="pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </rd-widget-body>
     </rd-widget>
   </div>

app/components/swarm/swarmController.js

@@ -1,15 +1,15 @@
 angular.module('swarm', [])
-.controller('SwarmController', ['$scope', 'Info', 'Version', 'Node',
-function ($scope, Info, Version, Node) {
+.controller('SwarmController', ['$scope', 'Info', 'Version', 'Node', 'Settings',
+function ($scope, Info, Version, Node, Settings) {
 
   $scope.sortType = 'Name';
   $scope.sortReverse = true;
   $scope.info = {};
   $scope.docker = {};
   $scope.swarm = {};
-  $scope.swarm_mode = false;
   $scope.totalCPU = 0;
   $scope.totalMemory = 0;
+  $scope.pagination_count = Settings.pagination_count;
 
   $scope.order = function(sortType) {
     $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
@@ -22,8 +22,7 @@ function ($scope, Info, Version, Node) {
 
   Info.get({}, function (d) {
     $scope.info = d;
-    if (!_.startsWith(d.ServerVersion, 'swarm')) {
-      $scope.swarm_mode = true;
+    if ($scope.endpointMode.provider === 'DOCKER_SWARM_MODE') {
       Node.query({}, function(d) {
         $scope.nodes = d;
         var CPU = 0, memory = 0;

app/components/task/task.html

@@ -3,7 +3,7 @@
     <i id="loadingViewSpinner" class="fa fa-cog fa-spin"></i>
   </rd-header-title>
   <rd-header-content>
-    Services > <a ui-sref="service({id: task.ServiceID})">{{ serviceName }}</a> > {{ task.ID }}
+    <a ui-sref="services">Services</a> > <a ui-sref="service({id: task.ServiceID})">{{ serviceName }}</a> > {{ task.ID }}
   </rd-header-content>
 </rd-header>
 

app/components/templates/templates.html

@@ -6,20 +6,19 @@
   </rd-header-title>
   <rd-header-content>Templates</rd-header-content>
 </rd-header>
-
-<div class="row" ng-if="selectedTemplate">
+<div id="selectedTemplate" class="row" ng-if="state.selectedTemplate">
   <div class="col-lg-12 col-md-12 col-xs-12">
     <rd-widget>
-      <rd-widget-custom-header icon="selectedTemplate.logo" title="selectedTemplate.image">
+      <rd-widget-custom-header icon="state.selectedTemplate.logo" title="state.selectedTemplate.image">
       </rd-widget-custom-header>
       <rd-widget-body classes="padding">
         <form class="form-horizontal">
-          <div class="form-group" ng-if="globalNetworkCount === 0 && !swarm_mode">
+          <div class="form-group" ng-if="globalNetworkCount === 0 && endpointMode.provider === 'DOCKER_SWARM'">
             <div class="col-sm-12">
               <span class="small text-muted">When using Swarm, we recommend deploying containers in a shared network. Looks like you don't have any shared network, head over the <a ui-sref="networks">networks view</a> to create one.</span>
             </div>
           </div>
-          <div class="form-group" ng-if="swarm_mode">
+          <div class="form-group" ng-if="endpointMode.provider === 'DOCKER_SWARM_MODE'">
             <div class="col-sm-12">
               <i class="fa fa-exclamation-triangle" aria-hidden="true"></i>
               <span class="small text-muted">App templates cannot be used with swarm-mode at the moment. You can still use them to quickly deploy containers to the Docker host.</span>
@@ -33,24 +32,68 @@
             </div>
             <label for="container_network" class="col-sm-2 control-label text-right">Network</label>
             <div class="col-sm-4">
-              <select class="selectpicker form-control" ng-options="net.Name for net in availableNetworks" ng-model="formValues.network">
+              <select class="form-control" ng-options="net.Name for net in availableNetworks" ng-model="formValues.network">
                 <option disabled hidden value="">Select a network</option>
               </select>
             </div>
           </div>
           <!-- !name-and-network-inputs -->
-          <div ng-repeat="var in selectedTemplate.env" ng-if="!var.set" class="form-group">
+          <div ng-repeat="var in state.selectedTemplate.env" ng-if="!var.set" class="form-group">
             <label for="field_{{ $index }}" class="col-sm-2 control-label text-left">{{ var.label }}</label>
             <div class="col-sm-10">
-              <select ng-if="(!swarm || swarm && swarm_mode) && var.type === 'container'" ng-options="container|containername for container in runningContainers" class="selectpicker form-control" ng-model="var.value">
+              <select ng-if="endpointMode.provider !== 'DOCKER_SWARM' && var.type === 'container'" ng-options="container|containername for container in runningContainers" class="form-control" ng-model="var.value">
                 <option selected disabled hidden value="">Select a container</option>
               </select>
-              <select ng-if="swarm && !swarm_mode && var.type === 'container'" ng-options="container|swarmcontainername for container in runningContainers" class="selectpicker form-control" ng-model="var.value">
+              <select ng-if="endpointMode.provider === 'DOCKER_SWARM' && var.type === 'container'" ng-options="container|swarmcontainername for container in runningContainers" class="form-control" ng-model="var.value">
                 <option selected disabled hidden value="">Select a container</option>
               </select>
               <input ng-if="!var.type || !var.type === 'container'" type="text" class="form-control" ng-model="var.value" id="field_{{ $index }}">
             </div>
           </div>
+          <div class="form-group">
+            <div class="col-sm-12">
+              <a class="small interactive" ng-if="!state.showAdvancedOptions" ng-click="state.showAdvancedOptions = true;">
+                <i class="fa fa-plus space-right" aria-hidden="true"></i> Show advanced options
+              </a>
+              <a class="small interactive" ng-if="state.showAdvancedOptions" ng-click="state.showAdvancedOptions = false;">
+                <i class="fa fa-minus space-right" aria-hidden="true"></i> Hide advanced options
+              </a>
+            </div>
+          </div>
+          <div class="form-group" ng-if="state.showAdvancedOptions">
+            <label for="container_ports" class="col-sm-1 control-label text-left">Port mapping</label>
+            <div class="col-sm-11" style="margin-top: 5px;">
+              <span class="label label-default interactive" ng-click="addPortBinding()">
+                <i class="fa fa-plus-circle" aria-hidden="true"></i> map additional port
+              </span>
+            </div>
+            <!-- port-mapping-input-list -->
+            <div class="col-sm-offset-1 col-sm-11 form-inline" style="margin-top: 10px;">
+              <div ng-repeat="portBinding in formValues.ports" style="margin-top: 2px;">
+                <div class="input-group col-sm-5 input-group-sm">
+                  <span class="input-group-addon">host</span>
+                  <input type="text" class="form-control" ng-model="portBinding.hostPort" placeholder="e.g. 80 or 1.2.3.4:80 (optional)">
+                </div>
+                <div class="input-group col-sm-5 input-group-sm">
+                  <span class="input-group-addon">container</span>
+                  <input type="text" class="form-control" ng-model="portBinding.containerPort" placeholder="e.g. 80">
+                </div>
+                <div class="input-group col-sm-1 input-group-sm">
+                  <select class="form-control" ng-model="portBinding.protocol">
+                    <option value="tcp">tcp</option>
+                    <option value="udp">udp</option>
+                  </select>
+                  <span class="input-group-btn">
+                    <button class="btn btn-default" type="button" ng-click="removePortBinding($index)">
+                      <i class="fa fa-minus" aria-hidden="true"></i>
+                    </button>
+                  </span>
+                </div>
+              </div>
+            </div>
+            <!-- !port-mapping-input-list -->
+          </div>
+          <!-- !port-mapping -->
           <div class="form-group">
             <div class="col-sm-12">
               <button type="button" class="btn btn-default btn-sm" ng-disabled="!formValues.network" ng-click="createTemplate()">Create</button>
@@ -63,7 +106,7 @@
   </div>
 </div>
 
-<div class="row" ng-if="selectedTemplate">
+<div class="row" ng-if="state.selectedTemplate">
 
 </div>
 
@@ -77,15 +120,21 @@
       </rd-widget-header>
       <rd-widget-body classes="padding">
         <div class="template-list">
-          <div ng-repeat="tpl in templates" class="container-template hvr-grow" id="template_{{ $index }}" ng-click="selectTemplate($index)">
+          <div dir-paginate="tpl in templates | itemsPerPage: pagination_count" class="container-template hvr-underline-from-center" id="template_{{ tpl.index }}" ng-click="selectTemplate(tpl.index)">
             <img class="logo" ng-src="{{ tpl.logo }}" />
             <div class="title">{{ tpl.title }}</div>
             <div class="description">{{ tpl.description }}</div>
           </div>
+          <div ng-if="!templates" class="text-center text-muted">
+            Loading...
+          </div>
           <div ng-if="templates.length == 0" class="text-center text-muted">
             No templates available.
           </div>
         </div>
+        <div ng-if="templates">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </rd-widget-body>
     </rd-widget>
   </div>

app/components/templates/templatesController.js

@@ -1,16 +1,27 @@
 angular.module('templates', [])
-.controller('TemplatesController', ['$scope', '$q', '$state', '$filter', 'Config', 'Info', 'Container', 'ContainerHelper', 'Image', 'Volume', 'Network', 'Templates', 'Messages',
-function ($scope, $q, $state, $filter, Config, Info, Container, ContainerHelper, Image, Volume, Network, Templates, Messages) {
-  $scope.templates = [];
-  $scope.selectedTemplate = null;
+.controller('TemplatesController', ['$scope', '$q', '$state', '$filter', '$anchorScroll', 'Config', 'Info', 'Container', 'ContainerHelper', 'Image', 'ImageHelper', 'Volume', 'Network', 'Templates', 'TemplateHelper', 'Messages', 'Settings',
+function ($scope, $q, $state, $filter, $anchorScroll, Config, Info, Container, ContainerHelper, Image, ImageHelper, Volume, Network, Templates, TemplateHelper, Messages, Settings) {
+  $scope.state = {
+    selectedTemplate: null,
+    showAdvancedOptions: false
+  };
   $scope.formValues = {
     network: "",
-    name: ""
+    name: "",
+    ports: []
   };
-  $scope.templates = [];
+  $scope.pagination_count = Settings.pagination_count;
 
   var selectedItem = -1;
 
+  $scope.addPortBinding = function() {
+    $scope.formValues.ports.push({ hostPort: '', containerPort: '', protocol: 'tcp' });
+  };
+
+  $scope.removePortBinding = function(index) {
+    $scope.formValues.ports.splice(index, 1);
+  };
+
   // TODO: centralize, already present in createContainerController
   function createContainer(config) {
     Container.create(config, function (d) {
@@ -76,6 +87,26 @@ function ($scope, $q, $state, $filter, Config, Info, Container, ContainerHelper,
     };
   }
 
+  function preparePortBindings(config, ports) {
+    var bindings = {};
+    ports.forEach(function (portBinding) {
+      if (portBinding.containerPort) {
+        var key = portBinding.containerPort + "/" + portBinding.protocol;
+        var binding = {};
+        if (portBinding.hostPort && portBinding.hostPort.indexOf(':') > -1) {
+          var hostAndPort = portBinding.hostPort.split(':');
+          binding.HostIp = hostAndPort[0];
+          binding.HostPort = hostAndPort[1];
+        } else {
+          binding.HostPort = portBinding.hostPort;
+        }
+        bindings[key] = [binding];
+        config.ExposedPorts[key] = {};
+      }
+    });
+    config.HostConfig.PortBindings = bindings;
+  }
+
   function createConfigFromTemplate(template) {
     var containerConfig = getInitialConfiguration();
     containerConfig.Image = template.image;
@@ -84,7 +115,7 @@ function ($scope, $q, $state, $filter, Config, Info, Container, ContainerHelper,
         if (v.value || v.set) {
           var val;
           if (v.type && v.type === 'container') {
-            if ($scope.swarm && $scope.formValues.network.Scope === 'global') {
+            if ($scope.endpointMode.provider === 'DOCKER_SWARM' && $scope.formValues.network.Scope === 'global') {
               val = $filter('swarmcontainername')(v.value);
             } else {
               var container = v.value;
@@ -97,15 +128,19 @@ function ($scope, $q, $state, $filter, Config, Info, Container, ContainerHelper,
         }
       });
     }
-    if (template.ports) {
-      template.ports.forEach(function (p) {
-        containerConfig.ExposedPorts[p] = {};
-        containerConfig.HostConfig.PortBindings[p] = [{ HostPort: ""}];
-      });
-    }
+    preparePortBindings(containerConfig, $scope.formValues.ports);
+    prepareImageConfig(containerConfig, template);
     return containerConfig;
   }
 
+  function prepareImageConfig(config, template) {
+    var image = _.toLower(template.image);
+    var registry = template.registry || '';
+    var imageConfig = ImageHelper.createImageConfigForContainer(image, registry);
+    config.Image = imageConfig.fromImage + ':' + imageConfig.tag;
+    $scope.imageConfig = imageConfig;
+  }
+
   function prepareVolumeQueries(template, containerConfig) {
     var volumeQueries = [];
     if (template.volumes) {
@@ -130,15 +165,11 @@ function ($scope, $q, $state, $filter, Config, Info, Container, ContainerHelper,
 
   $scope.createTemplate = function() {
     $('#createContainerSpinner').show();
-    var template = $scope.selectedTemplate;
+    var template = $scope.state.selectedTemplate;
     var containerConfig = createConfigFromTemplate(template);
-    var imageConfig = {
-      fromImage: template.image.split(':')[0],
-      tag: template.image.split(':')[1] ? template.image.split(':')[1] : 'latest'
-    };
     var createVolumeQueries = prepareVolumeQueries(template, containerConfig);
     $q.all(createVolumeQueries).then(function (d) {
-      pullImageAndCreateContainer(imageConfig, containerConfig);
+      pullImageAndCreateContainer($scope.imageConfig, containerConfig);
     });
   };
 
@@ -146,35 +177,36 @@ function ($scope, $q, $state, $filter, Config, Info, Container, ContainerHelper,
     $('#template_' + id).toggleClass("container-template--selected");
     if (selectedItem === id) {
       selectedItem = -1;
-      $scope.selectedTemplate = null;
+      $scope.state.selectedTemplate = null;
     } else {
       $('#template_' + selectedItem).toggleClass("container-template--selected");
       selectedItem = id;
-      $scope.selectedTemplate = $scope.templates[id];
+      var selectedTemplate = $scope.templates[id];
+      $scope.state.selectedTemplate = selectedTemplate;
+      $scope.formValues.ports = selectedTemplate.ports ? TemplateHelper.getPortBindings(selectedTemplate.ports) : [];
+      $anchorScroll('selectedTemplate');
     }
   };
 
   function initTemplates() {
     Templates.get(function (data) {
-      $scope.templates = data;
+      $scope.templates = data.map(function(tpl,index){
+        tpl.index = index;
+        return tpl;
+      });
       $('#loadTemplatesSpinner').hide();
     }, function (e) {
       $('#loadTemplatesSpinner').hide();
       Messages.error("Failure", e, "Unable to retrieve apps list");
+      $scope.templates = [];
     });
   }
 
   Config.$promise.then(function (c) {
-    $scope.swarm = c.swarm;
-    Info.get({}, function(info) {
-      if ($scope.swarm && !_.startsWith(info.ServerVersion, 'swarm')) {
-        $scope.swarm_mode = true;
-      }
-    });
     var containersToHideLabels = c.hiddenLabels;
     Network.query({}, function (d) {
       var networks = d;
-      if ($scope.swarm) {
+      if ($scope.endpointMode.provider === 'DOCKER_SWARM' || $scope.endpointMode.provider === 'DOCKER_SWARM_MODE') {
         networks = d.filter(function (network) {
           if (network.Scope === 'global') {
             return network;

app/components/volumes/volumes.html

@@ -16,7 +16,7 @@
     </rd-widget-header>
     <rd-widget-taskbar classes="col-lg-12">
       <div class="pull-left">
-        <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash btn-ico" aria-hidden="true"></i>Remove</button>
+        <button type="button" class="btn btn-danger" ng-click="removeAction()" ng-disabled="!state.selectedItemCount"><i class="fa fa-trash space-right" aria-hidden="true"></i>Remove</button>
         <a class="btn btn-default" type="button" ui-sref="actions.create.volume">Add volume</a>
       </div>
       <div class="pull-right">
@@ -53,17 +53,23 @@
             </tr>
           </thead>
           <tbody>
-            <tr ng-repeat="volume in (state.filteredVolumes = (volumes | filter:state.filter | orderBy:sortType:sortReverse))">
+            <tr dir-paginate="volume in (state.filteredVolumes = (volumes | filter:state.filter | orderBy:sortType:sortReverse | itemsPerPage: pagination_count))">
               <td><input type="checkbox" ng-model="volume.Checked" ng-change="selectItem(volume)"/></td>
               <td>{{ volume.Name|truncate:50 }}</td>
               <td>{{ volume.Driver }}</td>
               <td>{{ volume.Mountpoint }}</td>
             </tr>
+            <tr ng-if="!volumes">
+              <td colspan="4" class="text-center text-muted">Loading...</td>
+            </tr>
             <tr ng-if="volumes.length == 0">
               <td colspan="4" class="text-center text-muted">No volumes available.</td>
             </tr>
           </tbody>
         </table>
+        <div ng-if="volumes" class="pull-left pagination-controls">
+          <dir-pagination-controls></dir-pagination-controls>
+        </div>
       </div>
     </rd-widget-body>
     <rd-widget>

app/components/volumes/volumesController.js

@@ -1,15 +1,14 @@
 angular.module('volumes', [])
-.controller('VolumesController', ['$scope', '$state', 'Volume', 'Messages',
-function ($scope, $state, Volume, Messages) {
+.controller('VolumesController', ['$scope', '$state', 'Volume', 'Messages', 'Settings',
+function ($scope, $state, Volume, Messages, Settings) {
   $scope.state = {};
   $scope.state.selectedItemCount = 0;
   $scope.sortType = 'Name';
   $scope.sortReverse = true;
-  $scope.volumes = [];
-
   $scope.config = {
     Name: ''
   };
+  $scope.pagination_count = Settings.pagination_count;
 
   $scope.order = function(sortType) {
     $scope.sortReverse = ($scope.sortType === sortType) ? !$scope.sortReverse : false;
@@ -56,11 +55,12 @@ function ($scope, $state, Volume, Messages) {
   function fetchVolumes() {
     $('#loadVolumesSpinner').show();
     Volume.query({}, function (d) {
-      $scope.volumes = d.Volumes;
+      $scope.volumes = d.Volumes || [];
       $('#loadVolumesSpinner').hide();
     }, function (e) {
       $('#loadVolumesSpinner').hide();
       Messages.error("Failure", e, "Unable to retrieve volumes");
+      $scope.volumes = [];
     });
   }
   fetchVolumes();

app/directives/header-content.js

@@ -4,7 +4,7 @@ angular
   var directive = {
     requires: '^rdHeader',
     transclude: true,
-    template: '<div class="breadcrumb-links" ng-transclude></div>',
+    template: '<div class="breadcrumb-links"><div class="pull-left" ng-transclude></div><div class="pull-right"><a ui-sref="auth({logout: true})" class="text-danger" style="margin-right: 25px;"><u>log out <i class="fa fa-sign-out" aria-hidden="true"></i></u></a></div></div>',
     restrict: 'E'
   };
   return directive;

app/directives/header-title.js

@@ -1,14 +1,17 @@
 angular
 .module('portainer')
-.directive('rdHeaderTitle', function rdHeaderTitle() {
+.directive('rdHeaderTitle', ['$rootScope', function rdHeaderTitle($rootScope) {
   var directive = {
     requires: '^rdHeader',
     scope: {
       title: '@'
     },
+    link: function (scope, iElement, iAttrs) {
+      scope.username = $rootScope.username;
+    },
     transclude: true,
-    template: '<div class="page">{{title}}<span class="header_title_content" ng-transclude><span></div>',
+    template: '<div class="page white-space-normal">{{title}}<span class="header_title_content" ng-transclude></span><span class="pull-right user-box"><i class="fa fa-user-circle-o" aria-hidden="true"></i> {{username}}</span></div>',
     restrict: 'E'
   };
   return directive;
-});
+}]);

app/directives/widget-custom-header.js

@@ -8,7 +8,7 @@ angular
       icon: '='
     },
     transclude: true,
-    template: '<div class="widget-header"><div class="row"><span class="pull-left"><img class="custom-header-ico" ng-src="{{icon}}"></img> <span class="small text-muted"> {{title}} </span> </span><span class="pull-right col-xs-6 col-sm-4" ng-transclude></span></div></div>',
+    template: '<div class="widget-header"><div class="row"><span class="pull-left"><img class="custom-header-ico" ng-src="{{icon}}"></img> <span class="text-muted"> {{title}} </span> </span><span class="pull-right col-xs-6 col-sm-4" ng-transclude></span></div></div>',
     restrict: 'E'
   };
   return directive;

app/shared/filters.js

@@ -44,7 +44,7 @@ angular.module('portainer.filters', [])
       return 'warning';
     } else if (status.indexOf('created') !== -1) {
       return 'info';
-    } else if (status.indexOf('exited') !== -1) {
+    } else if (status.indexOf('stopped') !== -1) {
       return 'danger';
     }
     return 'success';
@@ -106,6 +106,12 @@ angular.module('portainer.filters', [])
     return 'Stopped';
   };
 })
+.filter('stripprotocol', function() {
+  'use strict';
+  return function (url) {
+    return url.replace(/.*?:\/\//g, '');
+  };
+})
 .filter('getstatelabel', function () {
   'use strict';
   return function (state) {
@@ -213,4 +219,13 @@ angular.module('portainer.filters', [])
   return function (ip) {
     return ip.slice(0, ip.indexOf('/'));
   };
+})
+.filter('arraytostr', function () {
+  'use strict';
+  return function (arr, separator) {
+    if (arr) {
+      return _.join(arr, separator);
+    }
+    return '';
+  };
 });

app/shared/helpers.js

@@ -2,7 +2,7 @@ angular.module('portainer.helpers', [])
 .factory('ImageHelper', [function ImageHelperFactory() {
   'use strict';
   return {
-    createImageConfig: function(imageName, registry) {
+    createImageConfigForCommit: function(imageName, registry) {
       var imageNameAndTag = imageName.split(':');
       var image = imageNameAndTag[0];
       if (registry) {
@@ -13,6 +13,18 @@ angular.module('portainer.helpers', [])
         tag: imageNameAndTag[1] ? imageNameAndTag[1] : 'latest'
       };
       return imageConfig;
+    },
+    createImageConfigForContainer: function (imageName, registry) {
+      var imageNameAndTag = imageName.split(':');
+      var image = imageNameAndTag[0];
+      if (registry) {
+        image = registry + '/' + imageNameAndTag[0];
+      }
+      var imageConfig = {
+        fromImage: image,
+        tag: imageNameAndTag[1] ? imageNameAndTag[1] : 'latest'
+      };
+      return imageConfig;
     }
   };
 }])
@@ -41,11 +53,52 @@ angular.module('portainer.helpers', [])
     serviceToConfig: function(service) {
       return {
         Name: service.Spec.Name,
+        Labels: service.Spec.Labels,
         TaskTemplate: service.Spec.TaskTemplate,
         Mode: service.Spec.Mode,
+        UpdateConfig: service.Spec.UpdateConfig,
         Networks: service.Spec.Networks,
         EndpointSpec: service.Spec.EndpointSpec
       };
     }
   };
+}])
+.factory('TemplateHelper', [function TemplateHelperFactory() {
+  'use strict';
+  return {
+    getPortBindings: function(ports) {
+      var bindings = [];
+      ports.forEach(function (port) {
+        var portAndProtocol = _.split(port, '/');
+        var binding = {
+          containerPort: portAndProtocol[0],
+          protocol: portAndProtocol[1]
+        };
+        bindings.push(binding);
+      });
+      return bindings;
+    },
+    //Not used atm, may prove useful later
+    getVolumeBindings: function(volumes) {
+      var bindings = [];
+      volumes.forEach(function (volume) {
+        bindings.push({ containerPath: volume });
+      });
+      return bindings;
+    },
+    //Not used atm, may prove useful later
+    getEnvBindings: function(env) {
+      var bindings = [];
+      env.forEach(function (envvar) {
+        var binding = {
+          name: envvar.name
+        };
+        if (envvar.set) {
+          binding.value = envvar.set;
+        }
+        bindings.push(binding);
+      });
+      return bindings;
+    }
+  };
 }]);

app/shared/services.js

@@ -6,7 +6,7 @@ angular.module('portainer.services', ['ngResource', 'ngSanitize'])
         return $resource(Settings.url + '/containers/:id/:action', {
             name: '@name'
         }, {
-            query: {method: 'GET', params: {all: 0, action: 'json'}, isArray: true},
+            query: {method: 'GET', params: {all: 0, action: 'json', filters: '@filters' }, isArray: true},
             get: {method: 'GET', params: {action: 'json'}},
             stop: {method: 'POST', params: {id: '@id', t: 5, action: 'stop'}},
             restart: {method: 'POST', params: {id: '@id', t: 5, action: 'restart'}},
@@ -166,14 +166,6 @@ angular.module('portainer.services', ['ngResource', 'ngSanitize'])
             get: {method: 'GET'}
         });
     }])
-    .factory('Auth', ['$resource', 'Settings', function AuthFactory($resource, Settings) {
-        'use strict';
-        // http://docs.docker.com/reference/api/docker_remote_api_<%= remoteApiVersion %>/#check-auth-configuration
-        return $resource(Settings.url + '/auth', {}, {
-            get: {method: 'GET'},
-            update: {method: 'POST'}
-        });
-    }])
     .factory('Info', ['$resource', 'Settings', function InfoFactory($resource, Settings) {
         'use strict';
         // http://docs.docker.com/reference/api/docker_remote_api_<%= remoteApiVersion %>/#display-system-wide-information
@@ -197,12 +189,12 @@ angular.module('portainer.services', ['ngResource', 'ngSanitize'])
         'use strict';
         // http://docs.docker.com/reference/api/docker_remote_api_<%= remoteApiVersion %>/#2-5-networks
         return $resource(Settings.url + '/volumes/:name/:action', {name: '@name'}, {
-            query: {method: 'GET'},
-            get: {method: 'GET'},
-            create: {method: 'POST', params: {action: 'create'}, transformResponse: genericHandler},
-            remove: {
-              method: 'DELETE', transformResponse: genericHandler
-            }
+          query: {method: 'GET'},
+          get: {method: 'GET'},
+          create: {method: 'POST', params: {action: 'create'}, transformResponse: genericHandler},
+          remove: {
+            method: 'DELETE', transformResponse: genericHandler
+          }
         });
     }])
     .factory('Config', ['$resource', 'CONFIG_ENDPOINT', function ConfigFactory($resource, CONFIG_ENDPOINT) {
@@ -213,7 +205,7 @@ angular.module('portainer.services', ['ngResource', 'ngSanitize'])
         get: {method: 'GET', isArray: true}
       });
     }])
-    .factory('Settings', ['DOCKER_ENDPOINT', 'DOCKER_PORT', 'UI_VERSION', function SettingsFactory(DOCKER_ENDPOINT, DOCKER_PORT, UI_VERSION) {
+    .factory('Settings', ['DOCKER_ENDPOINT', 'DOCKER_PORT', 'UI_VERSION', 'PAGINATION_MAX_ITEMS', function SettingsFactory(DOCKER_ENDPOINT, DOCKER_PORT, UI_VERSION, PAGINATION_MAX_ITEMS) {
         'use strict';
         var url = DOCKER_ENDPOINT;
         if (DOCKER_PORT) {
@@ -225,9 +217,231 @@ angular.module('portainer.services', ['ngResource', 'ngSanitize'])
           endpoint: DOCKER_ENDPOINT,
           uiVersion: UI_VERSION,
           url: url,
-          firstLoad: firstLoad
+          firstLoad: firstLoad,
+          pagination_count: PAGINATION_MAX_ITEMS
         };
     }])
+    .factory('Auth', ['$resource', 'AUTH_ENDPOINT', function AuthFactory($resource, AUTH_ENDPOINT) {
+      'use strict';
+      return $resource(AUTH_ENDPOINT, {}, {
+        login: {
+          method: 'POST'
+        }
+      });
+    }])
+    .factory('Users', ['$resource', 'USERS_ENDPOINT', function UsersFactory($resource, USERS_ENDPOINT) {
+      'use strict';
+      return $resource(USERS_ENDPOINT + '/:username/:action', {}, {
+        create: { method: 'POST' },
+        get: { method: 'GET', params: { username: '@username' } },
+        update: { method: 'PUT', params: { username: '@username' } },
+        checkPassword: { method: 'POST', params: { username: '@username', action: 'passwd' } },
+        checkAdminUser: { method: 'GET', params: { username: 'admin', action: 'check' } },
+        initAdminUser: { method: 'POST', params: { username: 'admin', action: 'init' } }
+      });
+    }])
+    .factory('EndpointMode', ['$rootScope', 'Info', function EndpointMode($rootScope, Info) {
+      'use strict';
+      return {
+        determineEndpointMode: function() {
+          Info.get({}, function(d) {
+            var mode = {
+              provider: '',
+              role: ''
+            };
+            if (_.startsWith(d.ServerVersion, 'swarm')) {
+              mode.provider = "DOCKER_SWARM";
+              if (d.SystemStatus[0][1] === 'primary') {
+                mode.role = "PRIMARY";
+              } else {
+                mode.role = "REPLICA";
+              }
+            } else {
+              if (!d.Swarm || _.isEmpty(d.Swarm.NodeID)) {
+                mode.provider = "DOCKER_STANDALONE";
+              } else {
+                mode.provider = "DOCKER_SWARM_MODE";
+                if (d.Swarm.ControlAvailable) {
+                  mode.role = "MANAGER";
+                } else {
+                  mode.role = "WORKER";
+                }
+              }
+            }
+            $rootScope.endpointMode = mode;
+          });
+        }
+      };
+    }])
+    .factory('Authentication', ['$q', '$rootScope', 'Auth', 'jwtHelper', 'localStorageService', function AuthenticationFactory($q, $rootScope, Auth, jwtHelper, localStorageService) {
+      'use strict';
+      return {
+        init: function() {
+          var jwt = localStorageService.get('JWT');
+          if (jwt) {
+            var tokenPayload = jwtHelper.decodeToken(jwt);
+            $rootScope.username = tokenPayload.username;
+          }
+        },
+        login: function(username, password) {
+          return $q(function (resolve, reject) {
+            Auth.login({username: username, password: password}).$promise
+            .then(function(data) {
+              localStorageService.set('JWT', data.jwt);
+              $rootScope.username = username;
+              resolve();
+            }, function() {
+              reject();
+            });
+          });
+        },
+        logout: function() {
+          localStorageService.remove('JWT');
+        },
+        isAuthenticated: function() {
+          var jwt = localStorageService.get('JWT');
+          return jwt && !jwtHelper.isTokenExpired(jwt);
+        }
+      };
+    }])
+    .factory('FileUploadService', ['$q', 'Upload', function FileUploadFactory($q, Upload) {
+      'use strict';
+      function uploadFile(url, file) {
+        var deferred = $q.defer();
+        Upload.upload({
+          url: url,
+          data: { file: file }
+        }).then(function success(data) {
+          deferred.resolve(data);
+        }, function error(e) {
+          deferred.reject(e);
+        }, function progress(evt) {
+        });
+        return deferred.promise;
+      }
+      return {
+        uploadTLSFilesForEndpoint: function(endpointID, TLSCAFile, TLSCertFile, TLSKeyFile) {
+          var deferred = $q.defer();
+          var queue = [];
+
+          if (TLSCAFile !== null) {
+            var uploadTLSCA = uploadFile('api/upload/tls/' + endpointID + '/ca', TLSCAFile);
+            queue.push(uploadTLSCA);
+          }
+          if (TLSCertFile !== null) {
+            var uploadTLSCert = uploadFile('api/upload/tls/' + endpointID + '/cert', TLSCertFile);
+            queue.push(uploadTLSCert);
+          }
+          if (TLSKeyFile !== null) {
+            var uploadTLSKey = uploadFile('api/upload/tls/' + endpointID + '/key', TLSKeyFile);
+            queue.push(uploadTLSKey);
+          }
+          $q.all(queue).then(function (data) {
+            deferred.resolve(data);
+          }, function (err) {
+            deferred.reject(err);
+          }, function update(evt) {
+            deferred.notify(evt);
+          });
+          return deferred.promise;
+        }
+      };
+    }])
+    .factory('Endpoints', ['$resource', 'ENDPOINTS_ENDPOINT', function EndpointsFactory($resource, ENDPOINTS_ENDPOINT) {
+      'use strict';
+      return $resource(ENDPOINTS_ENDPOINT + '/:id/:action', {}, {
+        create: { method: 'POST' },
+        query: { method: 'GET', isArray: true },
+        get: { method: 'GET', params: { id: '@id' } },
+        update: { method: 'PUT', params: { id: '@id' } },
+        remove: { method: 'DELETE', params: { id: '@id'} },
+        getActiveEndpoint: { method: 'GET', params: { id: '0' } },
+        setActiveEndpoint: { method: 'POST', params: { id: '@id', action: 'active' } }
+      });
+    }])
+    .factory('EndpointService', ['$q', '$timeout', 'Endpoints', 'FileUploadService', function EndpointServiceFactory($q, $timeout, Endpoints, FileUploadService) {
+      'use strict';
+      return {
+        getActive: function() {
+          return Endpoints.getActiveEndpoint().$promise;
+        },
+        setActive: function(endpointID) {
+          return Endpoints.setActiveEndpoint({id: endpointID}).$promise;
+        },
+        endpoint: function(endpointID) {
+          return Endpoints.get({id: endpointID}).$promise;
+        },
+        endpoints: function() {
+          return Endpoints.query({}).$promise;
+        },
+        updateEndpoint: function(ID, name, URL, TLS, TLSCAFile, TLSCertFile, TLSKeyFile) {
+          var endpoint = {
+            id: ID,
+            Name: name,
+            URL: "tcp://" + URL,
+            TLS: TLS
+          };
+          var deferred = $q.defer();
+          Endpoints.update({}, endpoint, function success(data) {
+            FileUploadService.uploadTLSFilesForEndpoint(ID, TLSCAFile, TLSCertFile, TLSKeyFile).then(function success(data) {
+              deferred.notify({upload: false});
+              deferred.resolve(data);
+            }, function error(err) {
+              deferred.notify({upload: false});
+              deferred.reject({msg: 'Unable to upload TLS certs', err: err});
+            });
+          }, function error(err) {
+            deferred.reject({msg: 'Unable to update endpoint', err: err});
+          });
+          return deferred.promise;
+        },
+        deleteEndpoint: function(endpointID) {
+          return Endpoints.remove({id: endpointID}).$promise;
+        },
+        createLocalEndpoint: function(name, URL, TLS, active) {
+          var endpoint = {
+            Name: "local",
+            URL: "unix:///var/run/docker.sock",
+            TLS: false
+          };
+          return Endpoints.create({active: active}, endpoint).$promise;
+        },
+        createRemoteEndpoint: function(name, URL, TLS, TLSCAFile, TLSCertFile, TLSKeyFile, active) {
+          var endpoint = {
+            Name: name,
+            URL: 'tcp://' + URL,
+            TLS: TLS
+          };
+          var deferred = $q.defer();
+          Endpoints.create({active: active}, endpoint, function success(data) {
+            var endpointID = data.Id;
+            if (TLS) {
+              deferred.notify({upload: true});
+              FileUploadService.uploadTLSFilesForEndpoint(endpointID, TLSCAFile, TLSCertFile, TLSKeyFile).then(function success(data) {
+                deferred.notify({upload: false});
+                if (active) {
+                  Endpoints.setActiveEndpoint({}, {id: endpointID}, function success(data) {
+                    deferred.resolve(data);
+                  }, function error(err) {
+                    deferred.reject({msg: 'Unable to create endpoint', err: err});
+                  });
+                } else {
+                  deferred.resolve(data);
+                }
+              }, function error(err) {
+                deferred.notify({upload: false});
+                deferred.reject({msg: 'Unable to upload TLS certs', err: err});
+              });
+            } else {
+              deferred.resolve(data);
+            }
+          }, function error(err) {
+            deferred.reject({msg: 'Unable to create endpoint', err: err});
+          });
+          return deferred.promise;
+        }
+      };
+    }])
     .factory('Messages', ['$rootScope', '$sanitize', function MessagesFactory($rootScope, $sanitize) {
         'use strict';
         return {

app/shared/viewmodel.js

@@ -35,8 +35,9 @@ function ServiceViewModel(data) {
   } else {
     this.Mode = 'global';
   }
-  if (data.Spec.Labels) {
-    this.Labels = data.Spec.Labels;
+  this.Labels = data.Spec.Labels;
+  if (data.Spec.TaskTemplate.ContainerSpec) {
+    this.ContainerLabels = data.Spec.TaskTemplate.ContainerSpec.Labels;
   }
   if (data.Spec.TaskTemplate.ContainerSpec.Env) {
     this.Env = data.Spec.TaskTemplate.ContainerSpec.Env;
@@ -44,6 +45,16 @@ function ServiceViewModel(data) {
   if (data.Endpoint.Ports) {
     this.Ports = data.Endpoint.Ports;
   }
+  if (data.Spec.UpdateConfig) {
+    this.UpdateParallelism = (typeof data.Spec.UpdateConfig.Parallelism !== undefined) ? data.Spec.UpdateConfig.Parallelism || 0 : 1;
+    this.UpdateDelay = data.Spec.UpdateConfig.Delay || 0;
+    this.UpdateFailureAction = data.Spec.UpdateConfig.FailureAction || 'pause';
+  } else {
+    this.UpdateParallelism = 1;
+    this.UpdateDelay = 0;
+    this.UpdateFailureAction = 'pause';
+  }
+
   this.Checked = false;
   this.Scale = false;
   this.EditName = false;
@@ -52,9 +63,10 @@ function ServiceViewModel(data) {
 function ContainerViewModel(data) {
   this.Id = data.Id;
   this.Status = data.Status;
+  this.State = data.State;
   this.Names = data.Names;
   // Unavailable in Docker < 1.10
-  if (data.NetworkSettings) {
+  if (data.NetworkSettings && !_.isEmpty(data.NetworkSettings.Networks)) {
     this.IP = data.NetworkSettings.Networks[Object.keys(data.NetworkSettings.Networks)[0]].IPAddress;
   }
   this.Image = data.Image;

assets/css/app.css

@@ -1,117 +1,27 @@
-.container > hr {
-    margin: 60px 0;
+html, body, #content-wrapper, .page-content, #view {
+  height: 100%;
+  width: 100%;
 }
 
-.jumbotron {
-    margin: 80px 0;
-    text-align: center;
-}
-
-.jumbotron h1 {
-    font-size: 100px;
-    line-height: 1;
-}
-
-.jumbotron .lead {
-    font-size: 24px;
-    line-height: 1.25;
-}
-
-.jumbotron .btn {
-    padding: 14px 24px;
-    font-size: 21px;
-}
-
-.marketing {
-    margin: 60px 0;
-}
-
-.marketing p + h4 {
-    margin-top: 28px;
-}
-
-.masthead .nav {
-    margin: 0;
-    margin: 0 0 2em 0;
-    width: 100%;
-}
-
-.masthead .nav.well {
-    padding: 0;
-}
-
-.masthead .nav li {
-    display: table-cell;
-    float: none;
-    width: 1%;
-}
-
-.masthead .nav li a {
-    font-weight: bold;
-    text-align: center;
-    border-right: 1px solid rgba(0,0,0,.1);
-    border-left: 1px solid rgba(255,255,255,.75);
-}
-
-.masthead .nav li:first-child a {
-    border-left: 0;
-    border-radius: 3px 0 0 3px;
-}
-.masthead .nav li:last-child a {
-    border-right: 0;
-    border-radius: 0 3px 3px 0;
+.white-space-normal {
+  white-space: normal !important;
 }
 
 .btn-group button {
-    margin: 3px;
-}
-
-.detail {
-    width: 80%;
-    margin: 0 auto;
-}
-
-.center {
-    width: 100%;
-    margin: 0 auto;
-}
-
-.btn-remove {
-    max-width: 70%;
-    margin: 0 auto;
-}
-
-.actions {
-    margin: 0 auto;
-}
-
-.container-bottom {
-    height: 50px;
-}
-
-.well {
-    padding: 10px 15px 0 15px;
+  margin: 3px;
 }
 
 .messages {
-    max-height: 50px;
-    overflow-x: hidden;
-    overflow-y: scroll;
+  max-height: 50px;
+  overflow-x: hidden;
+  overflow-y: scroll;
 }
 
 .legend .title {
-    padding: 0 0.3em;
-    margin: 0.5em;
-    border-style: solid;
-    border-width: 0 0 0 1em;
-}
-
-.inline-four .form-control {
-    max-width: 25%;
-}
-
-.dropdown {
-    cursor: pointer;
+  padding: 0 0.3em;
+  margin: 0.5em;
+  border-style: solid;
+  border-width: 0 0 0 1em;
 }
 
 .logo {
@@ -162,11 +72,7 @@ input[type="radio"] {
   vertical-align: middle;
 }
 
-.clickable {
-  cursor: pointer;
-}
-
-.text-icon {
+.space-right {
   margin-right: 5px;
 }
 
@@ -182,16 +88,17 @@ input[type="radio"] {
   color: white;
 }
 
-.image-tag {
-  margin-right: 5px;
-}
-
-.label.tag {
-  margin-right: 5px;
-}
-
 .widget .widget-body table tbody .image-tag {
   font-size: 90% !important;
+  margin-right: 5px;
+}
+
+.widget .widget-body table tbody .fit-text-size {
+  font-size: 90% !important;
+}
+
+.nopadding {
+  padding: 0 !important;
 }
 
 .terminal-container {
@@ -203,30 +110,73 @@ input[type="radio"] {
   cursor: pointer;
 }
 
-.action-group {
-  margin: 10px;
-}
-
-.btn-ico {
-  margin-right: 5px;
-}
-
 .template-list {
   display: flex;
   flex-wrap: wrap;
 }
 
 .custom-header-ico {
-  max-width: 16px;
-  max-height: 16px;
+  max-width: 32px;
+  max-height: 32px;
+  margin-right: 2px;
+}
+
+.btn-responsive {
+  padding: 5px 10px;
+  font-size: 12px;
+  line-height: 1.5;
+  border-radius: 3px;
+}
+
+@media screen and (min-width: 1107px) {
+  .btn-responsive {
+    padding: 6px 12px;
+    font-size: 14px;
+    line-height: 1.42857143;
+    border-radius: 4px;
+  }
+}
+
+/* Underline From Center */
+.hvr-underline-from-center {
+  display: inline-block;
+  vertical-align: middle;
+  -webkit-transform: translateZ(0);
+  transform: translateZ(0);
+  box-shadow: 0 0 1px rgba(0, 0, 0, 0);
+  -webkit-backface-visibility: hidden;
+  backface-visibility: hidden;
+  -moz-osx-font-smoothing: grayscale;
+  position: relative;
+  overflow: hidden;
+}
+.hvr-underline-from-center:before {
+  content: "";
+  position: absolute;
+  z-index: -1;
+  left: 50%;
+  right: 50%;
+  bottom: 0;
+  background: #85898b;
+  height: 2px;
+  -webkit-transition-property: left, right;
+  transition-property: left, right;
+  -webkit-transition-duration: 0.3s;
+  transition-duration: 0.3s;
+  -webkit-transition-timing-function: ease-out;
+  transition-timing-function: ease-out;
+}
+.hvr-underline-from-center:hover:before, .hvr-underline-from-center:focus:before, .hvr-underline-from-center:active:before {
+  left: 0;
+  right: 0;
 }
 
 .container-template {
   font-size: 1em;
   width: 256px;
   height: 128px;
-  margin: 10px;
-  padding: 10px;
+  margin: 15px;
+  padding: 5px;
   display: flex;
   flex-direction: column;
   justify-content: center;
@@ -259,20 +209,56 @@ input[type="radio"] {
 .container-template .description {
   text-align: center;
   font-size: 0.8em;
+  margin-bottom: 5px;
 }
 
-.btn-responsive {
-  padding: 5px 10px;
-  font-size: 12px;
-  line-height: 1.5;
-  border-radius: 3px;
+.page-wrapper {
+  margin-top: 25px;
+  height: 100%;
+  width: 100%;
+  display: flex;
+  align-items: center;
 }
 
-@media screen and (min-width: 1107px) {
-  .btn-responsive {
-    padding: 6px 12px;
-    font-size: 14px;
-    line-height: 1.42857143;
-    border-radius: 4px;
-  }
+.simple-box {
+  margin-bottom: 80px;
+}
+
+.simple-box > div:first-child {
+  padding-bottom: 10px;
+}
+
+.simple-box-logo {
+  display: block;
+  margin: auto;
+  position: relative;
+  width: 240px;
+  margin-bottom: 10px;
+}
+
+.login-form > div {
+  margin-bottom: 25px;
+}
+
+.login-form > div:last-child {
+  margin-top: 10px;
+  margin-bottom: 10px;
+}
+
+.panel-body {
+  padding-top: 30px;
+  background-color: #ffffff;
+}
+
+.pagination-controls {
+  margin-left: 10px;
+}
+
+.user-box {
+  margin-right: 25px;
+}
+
+.select-endpoint {
+  width: 80%;
+  margin: 0 auto;
 }