Multiple playgrounds support (play-with-docker#215)

* Add Playground struct and basic support for creating it and retrieving
it

* Add missing functions in pwd mock

* Get playground from request domain and validate it exists. If valid set
it on the newly created session.

* Move playground specific configurations to the playground struct and use
it everytime we need that conf.

* Don't allow to specify a duration bigger that the allowed in the
playground

Author: xetorthio

api.go

@@ -3,6 +3,7 @@ package main
 import (
 	"log"
 	"os"
+	"time"
 
 	"github.com/play-with-docker/play-with-docker/config"
 	"github.com/play-with-docker/play-with-docker/docker"
@@ -11,6 +12,7 @@ import (
 	"github.com/play-with-docker/play-with-docker/id"
 	"github.com/play-with-docker/play-with-docker/provisioner"
 	"github.com/play-with-docker/play-with-docker/pwd"
+	"github.com/play-with-docker/play-with-docker/pwd/types"
 	"github.com/play-with-docker/play-with-docker/scheduler"
 	"github.com/play-with-docker/play-with-docker/scheduler/task"
 	"github.com/play-with-docker/play-with-docker/storage"
@@ -41,6 +43,16 @@ func main() {
 
 	sch.Start()
 
+	d, err := time.ParseDuration(config.DefaultSessionDuration)
+	if err != nil {
+		log.Fatalf("Cannot parse duration %s. Got: %v", config.DefaultSessionDuration, err)
+	}
+
+	playground := types.Playground{Domain: config.PlaygroundDomain, DefaultDinDInstanceImage: config.DefaultDinDImage, AllowWindowsInstances: config.NoWindows, DefaultSessionDuration: d, AvailableDinDInstanceImages: []string{config.DefaultDinDImage}}
+	if _, err := core.PlaygroundNew(playground); err != nil {
+		log.Fatalf("Cannot create default playground. Got: %v", err)
+	}
+
 	handlers.Bootstrap(core, e)
 	handlers.Register(nil)
 }

config/config.go

@@ -2,10 +2,7 @@ package config
 
 import (
 	"flag"
-	"fmt"
-	"os"
 	"regexp"
-	"time"
 
 	"github.com/gorilla/securecookie"
 
@@ -27,10 +24,9 @@ const (
 var NameFilter = regexp.MustCompile(PWDHostPortGroupRegex)
 var AliasFilter = regexp.MustCompile(AliasPortGroupRegex)
 
-var PortNumber, Key, Cert, SessionsFile, PWDContainerName, L2ContainerName, L2Subdomain, PWDCName, HashKey, SSHKeyPath, L2RouterIP, DindVolumeSize, CookieHashKey, CookieBlockKey string
+var PortNumber, Key, Cert, SessionsFile, PWDContainerName, L2ContainerName, L2Subdomain, HashKey, SSHKeyPath, L2RouterIP, DindVolumeSize, CookieHashKey, CookieBlockKey, DefaultDinDImage, DefaultSessionDuration string
 var UseLetsEncrypt, ExternalDindVolume, NoWindows bool
 var LetsEncryptCertsDir string
-var LetsEncryptDomains stringslice
 var MaxLoadAvg float64
 var ForceTLS bool
 var Providers map[string]*oauth2.Config
@@ -40,18 +36,9 @@ var GithubClientID, GithubClientSecret string
 var FacebookClientID, FacebookClientSecret string
 var DockerClientID, DockerClientSecret string
 
-type stringslice []string
-
-func (i *stringslice) String() string {
-	return fmt.Sprintf("%s", *i)
-}
-func (i *stringslice) Set(value string) error {
-	*i = append(*i, value)
-	return nil
-}
+var PlaygroundDomain string
 
 func ParseFlags() {
-	flag.Var(&LetsEncryptDomains, "letsencrypt-domain", "List of domains to validate with let's encrypt")
 	flag.StringVar(&LetsEncryptCertsDir, "letsencrypt-certs-dir", "/certs", "Path where let's encrypt certs will be stored")
 	flag.BoolVar(&UseLetsEncrypt, "letsencrypt-enable", false, "Enabled let's encrypt tls certificates")
 	flag.BoolVar(&ForceTLS, "tls", false, "Use TLS to connect to docker daemons")
@@ -63,7 +50,6 @@ func ParseFlags() {
 	flag.StringVar(&L2ContainerName, "l2", "l2", "Container name used to run L2 Router")
 	flag.StringVar(&L2RouterIP, "l2-ip", "", "Host IP address for L2 router ping response")
 	flag.StringVar(&L2Subdomain, "l2-subdomain", "direct", "Subdomain to the L2 Router")
-	flag.StringVar(&PWDCName, "cname", "", "CNAME given to this host")
 	flag.StringVar(&HashKey, "hash_key", "salmonrosado", "Hash key to use for cookies")
 	flag.StringVar(&DindVolumeSize, "dind-volume-size", "5G", "Dind volume folder size")
 	flag.BoolVar(&NoWindows, "win-disable", false, "Disable windows instances")
@@ -72,6 +58,8 @@ func ParseFlags() {
 	flag.StringVar(&SSHKeyPath, "ssh_key_path", "", "SSH Private Key to use")
 	flag.StringVar(&CookieHashKey, "cookie-hash-key", "", "Hash key to use to validate cookies")
 	flag.StringVar(&CookieBlockKey, "cookie-block-key", "", "Block key to use to encrypt cookies")
+	flag.StringVar(&DefaultDinDImage, "default-dind-image", "franela/dind", "Default DinD image to use if not specified otherwise")
+	flag.StringVar(&DefaultSessionDuration, "default-session-duration", "4h", "Default session duration if not specified otherwise")
 
 	flag.StringVar(&GithubClientID, "oauth-github-client-id", "", "Github OAuth Client ID")
 	flag.StringVar(&GithubClientSecret, "oauth-github-client-secret", "", "Github OAuth Client Secret")
@@ -82,6 +70,8 @@ func ParseFlags() {
 	flag.StringVar(&DockerClientID, "oauth-docker-client-id", "", "Docker OAuth Client ID")
 	flag.StringVar(&DockerClientSecret, "oauth-docker-client-secret", "", "Docker OAuth Client Secret")
 
+	flag.StringVar(&PlaygroundDomain, "playground-domain", "localhost", "Domain to use for the playground")
+
 	flag.Parse()
 
 	SecureCookie = securecookie.New([]byte(CookieHashKey), []byte(CookieBlockKey))
@@ -126,38 +116,3 @@ func registerOAuthProviders() {
 		Providers["docker"] = conf
 	}
 }
-
-func GetDindImageName() string {
-	dindImage := os.Getenv("DIND_IMAGE")
-	defaultDindImageName := "franela/dind"
-	if len(dindImage) == 0 {
-		dindImage = defaultDindImageName
-	}
-	return dindImage
-}
-
-func GetSSHImage() string {
-	sshImage := os.Getenv("SSH_IMAGE")
-	defaultSSHImage := "franela/ssh"
-	if len(sshImage) == 0 {
-		return defaultSSHImage
-	}
-	return sshImage
-}
-
-func GetDuration(reqDur string) time.Duration {
-	var defaultDuration = 4 * time.Hour
-	if reqDur != "" {
-		if dur, err := time.ParseDuration(reqDur); err == nil && dur <= defaultDuration {
-			return dur
-		}
-		return defaultDuration
-	}
-
-	envDur := os.Getenv("EXPIRY")
-	if dur, err := time.ParseDuration(envDur); err == nil {
-		return dur
-	}
-
-	return defaultDuration
-}

docker-compose.yml

@@ -14,16 +14,13 @@ services:
         # use the latest golang image
         image: golang
         # go to the right place and starts the app
-        command: /bin/sh -c 'ssh-keygen -N "" -t rsa -f /etc/ssh/ssh_host_rsa_key >/dev/null; cd /go/src/github.com/play-with-docker/play-with-docker; go run api.go -save /pwd/sessions -name l2'
+        command: /bin/sh -c 'ssh-keygen -N "" -t rsa -f /etc/ssh/ssh_host_rsa_key >/dev/null; cd /go/src/github.com/play-with-docker/play-with-docker; go run api.go -save /pwd/sessions -name l2 -default-dind-image franela/dind:hybrid'
         volumes:
             # since this app creates networks and launches containers, we need to talk to docker daemon
             - /var/run/docker.sock:/var/run/docker.sock
             # mount the box mounted shared folder to the container
             - $GOPATH/src:/go/src
             - sessions:/pwd
-        environment:
-            GOOGLE_RECAPTCHA_DISABLED: "true"
-            DIND_IMAGE: "franela/dind:hybrid"
     l2:
         container_name: l2
         # use the latest golang image

handlers/bootstrap.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"context"
 	"crypto/tls"
 	"fmt"
 	"log"
@@ -11,6 +12,7 @@ import (
 
 	gh "github.com/gorilla/handlers"
 	"github.com/gorilla/mux"
+	lru "github.com/hashicorp/golang-lru"
 	"github.com/play-with-docker/play-with-docker/config"
 	"github.com/play-with-docker/play-with-docker/event"
 	"github.com/play-with-docker/play-with-docker/pwd"
@@ -92,10 +94,22 @@ func Register(extend HandlerExtender) {
 	}
 
 	if config.UseLetsEncrypt {
+		domainCache, err := lru.New(5000)
+		if err != nil {
+			log.Fatalf("Could not start domain cache. Got: %v", err)
+		}
 		certManager := autocert.Manager{
-			Prompt:     autocert.AcceptTOS,
-			HostPolicy: autocert.HostWhitelist(config.LetsEncryptDomains...),
-			Cache:      autocert.DirCache(config.LetsEncryptCertsDir),
+			Prompt: autocert.AcceptTOS,
+			HostPolicy: func(ctx context.Context, host string) error {
+				if _, found := domainCache.Get(host); !found {
+					if playground := core.PlaygroundFindByDomain(host); playground == nil {
+						return fmt.Errorf("Playground for domain %s was not found", host)
+					}
+					domainCache.Add(host, true)
+				}
+				return nil
+			},
+			Cache: autocert.DirCache(config.LetsEncryptCertsDir),
 		}
 
 		httpServer.TLSConfig = &tls.Config{

handlers/get_instance_images.go

@@ -2,15 +2,16 @@ package handlers
 
 import (
 	"encoding/json"
+	"log"
 	"net/http"
-
-	"github.com/play-with-docker/play-with-docker/config"
 )
 
 func GetInstanceImages(rw http.ResponseWriter, req *http.Request) {
-	instanceImages := []string{
-		config.GetDindImageName(),
-		"franela/dind:dev",
+	playground := core.PlaygroundFindByDomain(req.Host)
+	if playground == nil {
+		log.Printf("Playground for domain %s was not found!", req.Host)
+		rw.WriteHeader(http.StatusBadRequest)
+		return
 	}
-	json.NewEncoder(rw).Encode(instanceImages)
+	json.NewEncoder(rw).Encode(playground.AvailableDinDInstanceImages)
 }

handlers/home.go

@@ -1,10 +1,10 @@
 package handlers
 
 import (
+	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
-	"github.com/play-with-docker/play-with-docker/config"
 )
 
 func Home(w http.ResponseWriter, r *http.Request) {
@@ -21,7 +21,14 @@ func Home(w http.ResponseWriter, r *http.Request) {
 		go core.SessionDeployStack(s)
 	}
 
-	if config.NoWindows {
+	playground := core.PlaygroundGet(s.PlaygroundId)
+	if playground == nil {
+		log.Printf("Playground with id %s for session %s was not found!", s.PlaygroundId, s.Id)
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	if !playground.AllowWindowsInstances {
 		http.ServeFile(w, r, "./www/index-nw.html")
 	} else {
 		http.ServeFile(w, r, "./www/index.html")

handlers/new_instance.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 
 	"github.com/gorilla/mux"
-	"github.com/play-with-docker/play-with-docker/config"
 	"github.com/play-with-docker/play-with-docker/provisioner"
 	"github.com/play-with-docker/play-with-docker/pwd"
 	"github.com/play-with-docker/play-with-docker/pwd/types"
@@ -23,7 +22,14 @@ func NewInstance(rw http.ResponseWriter, req *http.Request) {
 
 	s := core.SessionGet(sessionId)
 
-	if body.Type == "windows" && config.NoWindows {
+	playground := core.PlaygroundGet(s.PlaygroundId)
+	if playground == nil {
+		log.Printf("Playground with id %s for session %s was not found!", s.PlaygroundId, s.Id)
+		rw.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	if body.Type == "windows" && !playground.AllowWindowsInstances {
 		rw.WriteHeader(http.StatusUnauthorized)
 		return
 	}

handlers/new_session.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"path"
 	"strings"
+	"time"
 
 	"github.com/play-with-docker/play-with-docker/config"
 	"github.com/play-with-docker/play-with-docker/provisioner"
@@ -49,8 +50,32 @@ func NewSession(rw http.ResponseWriter, req *http.Request) {
 		}
 
 	}
-	duration := config.GetDuration(reqDur)
-	s, err := core.SessionNew(userId, duration, stack, stackName, imageName)
+
+	playground := core.PlaygroundFindByDomain(req.Host)
+	if playground == nil {
+		log.Printf("Playground for domain %s was not found!", req.Host)
+		rw.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	var duration time.Duration
+	if reqDur != "" {
+		d, err := time.ParseDuration(reqDur)
+		if err != nil {
+			rw.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		if d > playground.DefaultSessionDuration {
+			log.Printf("Specified session duration was %s but maximum allowed by this playground is %d\n", d.String(), playground.DefaultSessionDuration.String())
+			rw.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		duration = d
+	} else {
+		duration = playground.DefaultSessionDuration
+	}
+
+	s, err := core.SessionNew(playground, userId, duration, stack, stackName, imageName)
 	if err != nil {
 		if provisioner.OutOfCapacity(err) {
 			http.Redirect(rw, req, "/ooc", http.StatusFound)
@@ -62,9 +87,6 @@ func NewSession(rw http.ResponseWriter, req *http.Request) {
 		//TODO: Return some error code
 	} else {
 		hostname := req.Host
-		if config.PWDCName != "" {
-			hostname = fmt.Sprintf("%s.%s", config.PWDCName, req.Host)
-		}
 		// If request is not a form, return sessionId in the body
 		if req.Header.Get("X-Requested-With") == "XMLHttpRequest" {
 			resp := NewSessionResponse{SessionId: s.Id, Hostname: hostname}

provisioner/dind.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	lru "github.com/hashicorp/golang-lru"
-	"github.com/play-with-docker/play-with-docker/config"
 	"github.com/play-with-docker/play-with-docker/docker"
 	"github.com/play-with-docker/play-with-docker/id"
 	"github.com/play-with-docker/play-with-docker/pwd/types"
@@ -44,7 +43,11 @@ func checkHostnameExists(sessionId, hostname string, instances []*types.Instance
 
 func (d *DinD) InstanceNew(session *types.Session, conf types.InstanceConfig) (*types.Instance, error) {
 	if conf.ImageName == "" {
-		conf.ImageName = config.GetDindImageName()
+		playground, err := d.storage.PlaygroundGet(session.PlaygroundId)
+		if err != nil {
+			return nil, err
+		}
+		conf.ImageName = playground.DefaultDinDInstanceImage
 	}
 	log.Printf("NewInstance - using image: [%s]\n", conf.ImageName)
 	if conf.Hostname == "" {

pwd/client_test.go

@@ -43,7 +43,9 @@ func TestClientNew(t *testing.T) {
 	p := NewPWD(_f, _e, _s, sp, ipf)
 	p.generator = _g
 
-	session, err := p.SessionNew("", time.Hour, "", "", "")
+	playground := &types.Playground{Id: "foobar"}
+
+	session, err := p.SessionNew(playground, "", time.Hour, "", "", "")
 	assert.Nil(t, err)
 
 	client := p.ClientNew("foobar", session)
@@ -81,8 +83,9 @@ func TestClientCount(t *testing.T) {
 
 	p := NewPWD(_f, _e, _s, sp, ipf)
 	p.generator = _g
+	playground := &types.Playground{Id: "foobar"}
 
-	session, err := p.SessionNew("", time.Hour, "", "", "")
+	session, err := p.SessionNew(playground, "", time.Hour, "", "", "")
 	assert.Nil(t, err)
 
 	p.ClientNew("foobar", session)
@@ -122,8 +125,9 @@ func TestClientResizeViewPort(t *testing.T) {
 	_e.M.On("Emit", event.INSTANCE_VIEWPORT_RESIZE, "aaaabbbbcccc", []interface{}{uint(80), uint(24)}).Return()
 	p := NewPWD(_f, _e, _s, sp, ipf)
 	p.generator = _g
+	playground := &types.Playground{Id: "foobar"}
 
-	session, err := p.SessionNew("", time.Hour, "", "", "")
+	session, err := p.SessionNew(playground, "", time.Hour, "", "", "")
 	assert.Nil(t, err)
 	client := p.ClientNew("foobar", session)
 	_s.On("ClientFindBySessionId", "aaaabbbbcccc").Return([]*types.Client{client}, nil)