Add codes

controller/common.go

@@ -0,0 +1,34 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/model"
+)
+
+func newModel(ctx web.Context) web.Map {
+	return web.Map{
+		"ContextUser": ctx.User(),
+	}
+}
+
+func newPagerModel(ctx web.Context, totalCount, size, page int) web.Map {
+	pager := model.NewPager(ctx.Request().RequestURI, totalCount, size, page)
+	return newModel(ctx).Add("Pager", pager)
+}
+
+func ajaxResult(ctx web.Context, err error) error {
+	if err != nil {
+		return err
+	}
+
+	return ctx.JSON(web.Map{
+		"success": err == nil,
+	})
+}
+
+func ajaxSuccess(ctx web.Context, data interface{}) error {
+	return ctx.JSON(web.Map{
+		"success": true,
+		"data":    data,
+	})
+}

controller/config.go

@@ -0,0 +1,70 @@
+package controller
+
+import (
+	"strings"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/auxo/util/cast"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type ConfigController struct {
+	List   web.HandlerFunc `path:"/" name:"config.list" authorize:"!" desc:"config list page"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"config.delete" authorize:"!" desc:"delete config"`
+	New    web.HandlerFunc `path:"/new" name:"config.new" authorize:"!" desc:"new config page"`
+	Create web.HandlerFunc `path:"/new" method:"post" name:"config.create" authorize:"!" desc:"create config"`
+}
+
+func Config() (c *ConfigController) {
+	c = &ConfigController{}
+
+	c.List = func(ctx web.Context) error {
+		name := ctx.Q("name")
+		page := cast.ToIntD(ctx.Q("page"), 1)
+		configs, totalCount, err := docker.ConfigList(name, page, model.PageSize)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, page).
+			Add("Name", name).
+			Add("Configs", configs)
+		return ctx.Render("config/list", m)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		ids := strings.Split(ctx.F("ids"), ",")
+		err := docker.ConfigRemove(ids)
+		return ajaxResult(ctx, err)
+	}
+
+	c.New = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("config/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		v := struct {
+			Name   string `json:"name"`
+			Data   string `json:"data"`
+			Labels []struct {
+				Name  string `json:"name"`
+				Value string `json:"value"`
+			} `json:"labels"`
+		}{}
+		err := ctx.Bind(&v)
+		if err == nil {
+			labels := make(map[string]string)
+			for _, l := range v.Labels {
+				if l.Name != "" && l.Value != "" {
+					labels[l.Name] = l.Value
+				}
+			}
+			err = docker.ConfigCreate(v.Name, []byte(v.Data), labels)
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/container.go

@@ -0,0 +1,65 @@
+package controller
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/auxo/util/cast"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type ContainerController struct {
+	List   web.HandlerFunc `path:"/" name:"container.list" authorize:"!" desc:"container list page"`
+	Detail web.HandlerFunc `path:"/:id/detail" name:"container.detail" authorize:"!" desc:"container detail page"`
+	Raw    web.HandlerFunc `path:"/:id/raw" name:"container.raw" authorize:"!" desc:"container raw page"`
+}
+
+func Container() (c *ContainerController) {
+	c = &ContainerController{}
+
+	c.List = func(ctx web.Context) error {
+		name := ctx.Q("name")
+		page := cast.ToIntD(ctx.Q("page"), 1)
+		containers, totalCount, err := docker.ContainerList(name, page, model.PageSize)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, page).
+			Add("Name", name).
+			Add("Containers", containers)
+		return ctx.Render("container/list", m)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		id := ctx.P("id")
+		container, err := docker.ContainerInspect(id)
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Container", container)
+		return ctx.Render("container/detail", m)
+	}
+
+	c.Raw = func(ctx web.Context) error {
+		id := ctx.P("id")
+		container, raw, err := docker.ContainerInspectRaw(id)
+		if err != nil {
+			return err
+		}
+
+		buf := &bytes.Buffer{}
+		err = json.Indent(buf, raw, "", "    ")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Container", container).Add("Raw", string(buf.Bytes()))
+		return ctx.Render("container/raw", m)
+	}
+
+	return
+}

controller/event.go

@@ -0,0 +1,38 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/model"
+)
+
+type EventController struct {
+	List web.HandlerFunc `path:"/" name:"event.list" authorize:"!" desc:"event list page"`
+}
+
+func Event() (c *EventController) {
+	c = &EventController{}
+
+	c.List = func(ctx web.Context) error {
+		args := &model.EventListArgs{}
+		err := ctx.Bind(args)
+		if err != nil {
+			return err
+		}
+		args.PageSize = model.PageSize
+		if args.PageIndex == 0 {
+			args.PageIndex = 1
+		}
+
+		events, totalCount, err := biz.Event.List(args)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, args.PageIndex).
+			Add("Events", events).Add("Args", args)
+		return ctx.Render("system/event/list", m)
+	}
+
+	return
+}

controller/home.go

@@ -0,0 +1,102 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/errors"
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type HomeController struct {
+	Index    web.HandlerFunc `path:"/" name:"index" authorize:"?" desc:"index page"`
+	Error404 web.HandlerFunc `path:"/404" name:"404" authorize:"*" desc:"404 page"`
+	Login    web.HandlerFunc `path:"/login" name:"login" authorize:"*" desc:"sign in page"`
+	InitGet  web.HandlerFunc `path:"/init" name:"init" authorize:"*" desc:"initialize page"`
+	InitPost web.HandlerFunc `path:"/init" method:"post" name:"init" authorize:"*" desc:"initialize system"`
+}
+
+func Home() (c *HomeController) {
+	c = &HomeController{}
+
+	c.Index = func(ctx web.Context) (err error) {
+		var (
+			count int
+			m     = newModel(ctx)
+		)
+
+		if count, err = docker.NodeCount(); err != nil {
+			return
+		}
+		m.Add("NodeCount", count)
+
+		if count, err = docker.NetworkCount(); err != nil {
+			return
+		}
+		m.Add("NetworkCount", count)
+
+		if count, err = docker.ServiceCount(); err != nil {
+			return
+		}
+		m.Add("ServiceCount", count)
+
+		if count, err = docker.StackCount(); err != nil {
+			return
+		}
+		m.Add("StackCount", count)
+
+		return ctx.Render("index", m)
+	}
+
+	c.Login = func(ctx web.Context) error {
+		count, err := biz.User.Count()
+		if err != nil {
+			return err
+		} else if count == 0 {
+			return ctx.Redirect("init")
+		}
+		if ctx.User() != nil {
+			u := ctx.Q("from")
+			if u == "" {
+				u = "/"
+			}
+			return ctx.Redirect(u)
+		}
+		return ctx.Render("login", nil)
+	}
+
+	c.InitGet = func(ctx web.Context) error {
+		count, err := biz.User.Count()
+		if err != nil {
+			return err
+		} else if count > 0 {
+			return ctx.Redirect("login")
+		}
+		return ctx.Render("init", nil)
+	}
+
+	c.InitPost = func(ctx web.Context) error {
+		count, err := biz.User.Count()
+		if err != nil {
+			return err
+		} else if count > 0 {
+			return errors.New("Swirl was already initialized")
+		}
+
+		user := &model.User{}
+		err = ctx.Bind(user)
+		if err != nil {
+			return err
+		}
+
+		user.Admin = true
+		user.Type = model.UserTypeInternal
+		err = biz.User.Create(user, nil)
+		return ajaxResult(ctx, err)
+	}
+
+	c.Error404 = func(ctx web.Context) error {
+		return ctx.Render("404", nil)
+	}
+	return
+}

controller/image.go

@@ -0,0 +1,34 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/auxo/util/cast"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type ImageController struct {
+	List web.HandlerFunc `path:"/" name:"image.list" authorize:"!" desc:"image list page"`
+	//Detail web.HandlerFunc `path:"/:id/detail" name:"image.detail" authorize:"!" desc:"image detail page"`
+	//Raw    web.HandlerFunc `path:"/:id/raw" name:"image.raw" authorize:"!" desc:"image raw page"`
+}
+
+func Image() (c *ImageController) {
+	c = &ImageController{}
+
+	c.List = func(ctx web.Context) error {
+		name := ctx.Q("name")
+		page := cast.ToIntD(ctx.Q("page"), 1)
+		images, totalCount, err := docker.ImageList(name, page, model.PageSize)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, page).
+			Add("Name", name).
+			Add("Images", images)
+		return ctx.Render("image/list", m)
+	}
+
+	return
+}

controller/network.go

@@ -0,0 +1,102 @@
+package controller
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type NetworkController struct {
+	List       web.HandlerFunc `path:"/" name:"network.list" authorize:"!" desc:"network list page"`
+	New        web.HandlerFunc `path:"/new" name:"network.new" authorize:"!" desc:"new network page"`
+	Create     web.HandlerFunc `path:"/create" method:"post" name:"network.create" authorize:"!" desc:"create network"`
+	Delete     web.HandlerFunc `path:"/delete" method:"post" name:"network.delete" authorize:"!" desc:"delete network"`
+	Disconnect web.HandlerFunc `path:"/:name/disconnect" method:"post" name:"network.disconnect" authorize:"!" desc:"disconnect network"`
+	Detail     web.HandlerFunc `path:"/:name/detail" name:"network.detail" authorize:"!" desc:"network detail page"`
+	Raw        web.HandlerFunc `path:"/:name/raw" name:"network.raw" authorize:"!" desc:"network raw page"`
+}
+
+// Network create a NetworkController instance.
+func Network() (c *NetworkController) {
+	c = &NetworkController{}
+
+	c.List = func(ctx web.Context) error {
+		networks, err := docker.NetworkList()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Networks", networks)
+		return ctx.Render("network/list", m)
+	}
+
+	c.New = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("/network/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		info := &model.NetworkCreateInfo{}
+		err := ctx.Bind(info)
+		if err != nil {
+			return err
+		}
+		err = docker.NetworkCreate(info)
+		if err == nil {
+			biz.Event.CreateNetwork(model.EventActionCreate, info.Name, info.Name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		name := ctx.F("name")
+		err := docker.NetworkRemove(name)
+		if err == nil {
+			biz.Event.CreateNetwork(model.EventActionDelete, name, name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Disconnect = func(ctx web.Context) error {
+		name := ctx.P("name")
+		container := ctx.F("container")
+		err := docker.NetworkDisconnect(name, container)
+		if err == nil {
+			biz.Event.CreateNetwork(model.EventActionDisconnect, name, name+" <-> "+container, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		name := ctx.P("name")
+		network, err := docker.NetworkInspect(name)
+		if err != nil {
+			return err
+		}
+		m := newModel(ctx).Add("Network", network)
+		return ctx.Render("network/detail", m)
+	}
+
+	c.Raw = func(ctx web.Context) error {
+		name := ctx.P("name")
+		raw, err := docker.NetworkInspectRaw(name)
+		if err != nil {
+			return err
+		}
+
+		buf := &bytes.Buffer{}
+		err = json.Indent(buf, raw, "", "    ")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Network", name).Add("Raw", string(buf.Bytes()))
+		return ctx.Render("network/raw", m)
+	}
+
+	return
+}

controller/node.go

@@ -0,0 +1,95 @@
+package controller
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type NodeController struct {
+	List   web.HandlerFunc `path:"/" name:"node.list" authorize:"!" desc:"node list page"`
+	Detail web.HandlerFunc `path:"/:id/detail" name:"node.detail" authorize:"!" desc:"node detail page"`
+	Raw    web.HandlerFunc `path:"/:id/raw" name:"node.raw" authorize:"!" desc:"node raw page"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"node.delete" authorize:"!" desc:"delete node"`
+	Edit   web.HandlerFunc `path:"/:id/edit" name:"node.edit" authorize:"!" desc:"node edit page"`
+	Update web.HandlerFunc `path:"/:id/update" method:"post" name:"node.update" authorize:"!" desc:"update node"`
+}
+
+func Node() (c *NodeController) {
+	c = &NodeController{}
+
+	c.List = func(ctx web.Context) error {
+		nodes, err := docker.NodeList()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Nodes", nodes)
+		return ctx.Render("node/list", m)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := docker.NodeRemove(id)
+		return ajaxResult(ctx, err)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		id := ctx.P("id")
+		node, _, err := docker.NodeInspect(id)
+		if err != nil {
+			return err
+		}
+
+		tasks, err := docker.TaskList("", id)
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Node", node).Add("Tasks", tasks)
+		return ctx.Render("node/detail", m)
+	}
+
+	c.Raw = func(ctx web.Context) error {
+		id := ctx.P("id")
+		node, raw, err := docker.NodeInspect(id)
+		if err != nil {
+			return err
+		}
+
+		buf := &bytes.Buffer{}
+		err = json.Indent(buf, raw, "", "    ")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("ID", id).Add("Node", node).Add("Raw", string(buf.Bytes()))
+		return ctx.Render("node/raw", m)
+	}
+
+	c.Edit = func(ctx web.Context) error {
+		id := ctx.P("id")
+		node, _, err := docker.NodeInspect(id)
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Node", node)
+		return ctx.Render("node/edit", m)
+	}
+
+	c.Update = func(ctx web.Context) error {
+		id := ctx.P("id")
+		info := &model.NodeUpdateInfo{}
+		err := ctx.Bind(info)
+		if err == nil {
+			err = docker.NodeUpdate(id, info)
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/profile.go

@@ -0,0 +1,52 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/model"
+)
+
+type ProfileController struct {
+	Index          web.HandlerFunc `path:"/" name:"profile.info" authorize:"?" desc:"profile info page"`
+	ModifyInfo     web.HandlerFunc `path:"/" method:"post" name:"profile.info.modify" authorize:"?" desc:"modify info"`
+	Password       web.HandlerFunc `path:"/password" name:"profile.password" authorize:"?" desc:"profile password page"`
+	ModifyPassword web.HandlerFunc `path:"/password" method:"post" name:"profile.password.modify" authorize:"?" desc:"modify password"`
+}
+
+func Profile() (c *ProfileController) {
+	c = &ProfileController{}
+
+	c.Index = func(ctx web.Context) error {
+		user, err := biz.User.GetByID(ctx.User().ID())
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("User", user)
+		return ctx.Render("profile/index", m)
+	}
+
+	c.ModifyInfo = func(ctx web.Context) error {
+		user := &model.User{}
+		err := ctx.Bind(user)
+		if err == nil {
+			user.ID = ctx.User().ID()
+			err = biz.User.UpdateInfo(user)
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Password = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("profile/password", m)
+	}
+
+	c.ModifyPassword = func(ctx web.Context) error {
+		old_pwd := ctx.F("password_old")
+		new_pwd := ctx.F("password")
+		err := biz.User.UpdatePassword(ctx.User().ID(), old_pwd, new_pwd)
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/registry.go

@@ -0,0 +1,56 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/model"
+)
+
+type RegistryController struct {
+	List   web.HandlerFunc `path:"/" name:"registry.list" authorize:"!" desc:"registry list page"`
+	Create web.HandlerFunc `path:"/create" method:"post" name:"registry.create" authorize:"!" desc:"create registry"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"registry.delete" authorize:"!" desc:"delete registry"`
+	Update web.HandlerFunc `path:"/update" method:"post" name:"registry.update" authorize:"!" desc:"update registry"`
+}
+
+func Registry() (c *RegistryController) {
+	c = &RegistryController{}
+
+	c.List = func(ctx web.Context) error {
+		registries, err := biz.Registry.List()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Registries", registries)
+		return ctx.Render("registry/list", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		registry := &model.Registry{}
+		err := ctx.Bind(registry)
+		if err != nil {
+			return err
+		}
+		err = biz.Registry.Create(registry, ctx.User())
+		return ajaxResult(ctx, err)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := biz.Registry.Delete(id, ctx.User())
+		return ajaxResult(ctx, err)
+	}
+
+	c.Update = func(ctx web.Context) error {
+		registry := &model.Registry{}
+		err := ctx.Bind(registry)
+		if err != nil {
+			return err
+		}
+		err = biz.Registry.Update(registry, ctx.User())
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/role.go

@@ -0,0 +1,100 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/misc"
+	"github.com/cuigh/swirl/model"
+)
+
+type RoleController struct {
+	Index  web.HandlerFunc `path:"/" name:"role.list" authorize:"!" desc:"role list page"`
+	New    web.HandlerFunc `path:"/new" name:"role.new" authorize:"!" desc:"new role page"`
+	Create web.HandlerFunc `path:"/new" method:"post" name:"role.create" authorize:"!" desc:"create role"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"role.delete" authorize:"!" desc:"delete role"`
+	Detail web.HandlerFunc `path:"/:id/detail" name:"role.detail" authorize:"!" desc:"role detail page"`
+	Edit   web.HandlerFunc `path:"/:id/edit" name:"role.edit" authorize:"!" desc:"edit role page"`
+	Update web.HandlerFunc `path:"/:id/update" method:"post" name:"role.update" authorize:"!" desc:"update role"`
+}
+
+func Role() (c *RoleController) {
+	c = &RoleController{}
+
+	c.Index = func(ctx web.Context) error {
+		roles, err := biz.Role.List()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Roles", roles)
+		return ctx.Render("system/role/list", m)
+	}
+
+	c.New = func(ctx web.Context) error {
+		m := newModel(ctx).Add("Perms", misc.Perms)
+		return ctx.Render("system/role/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		role := &model.Role{}
+		err := ctx.Bind(role)
+		if err == nil {
+			err = biz.Role.Create(role, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := biz.Role.Delete(id, ctx.User())
+		return ajaxResult(ctx, err)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		id := ctx.P("id")
+		role, err := biz.Role.Get(id)
+		if err != nil {
+			return err
+		}
+		if role == nil {
+			return web.ErrNotFound
+		}
+
+		perms := make(map[string]struct{})
+		for _, p := range role.Perms {
+			perms[p] = model.Placeholder
+		}
+		m := newModel(ctx).Add("Role", role).Add("Perms", misc.Perms).Add("CheckedPerms", perms)
+		return ctx.Render("system/role/detail", m)
+	}
+
+	c.Edit = func(ctx web.Context) error {
+		id := ctx.P("id")
+		role, err := biz.Role.Get(id)
+		if err != nil {
+			return err
+		}
+		if role == nil {
+			return web.ErrNotFound
+		}
+
+		perms := make(map[string]struct{})
+		for _, p := range role.Perms {
+			perms[p] = model.Placeholder
+		}
+		m := newModel(ctx).Add("Role", role).Add("Perms", misc.Perms).Add("CheckedPerms", perms)
+		return ctx.Render("system/role/edit", m)
+	}
+
+	c.Update = func(ctx web.Context) error {
+		role := &model.Role{}
+		err := ctx.Bind(role)
+		if err == nil {
+			role.ID = ctx.P("id")
+			err = biz.Role.Update(role, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/secret.go

@@ -0,0 +1,82 @@
+package controller
+
+import (
+	"strings"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/auxo/util/cast"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type SecretController struct {
+	List   web.HandlerFunc `path:"/" name:"secret.list" authorize:"!" desc:"secret list page"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"secret.delete" authorize:"!" desc:"delete secret"`
+	New    web.HandlerFunc `path:"/new" name:"secret.new" authorize:"!" desc:"new secret page"`
+	Create web.HandlerFunc `path:"/new" method:"post" name:"secret.create" authorize:"!" desc:"create secret"`
+}
+
+func Secret() (c *SecretController) {
+	c = &SecretController{}
+
+	c.List = func(ctx web.Context) error {
+		name := ctx.Q("name")
+		page := cast.ToIntD(ctx.Q("page"), 1)
+		secrets, totalCount, err := docker.SecretList(name, page, model.PageSize)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, page).
+			Add("Name", name).
+			Add("Secrets", secrets)
+		return ctx.Render("secret/list", m)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		ids := strings.Split(ctx.F("ids"), ",")
+		for _, id := range ids {
+			err := docker.SecretRemove(id)
+			if err != nil {
+				return ajaxResult(ctx, err)
+			} else {
+				// todo:
+				biz.Event.CreateSecret(model.EventActionDelete, id, ctx.User())
+			}
+		}
+		return ajaxSuccess(ctx, nil)
+	}
+
+	c.New = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("secret/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		v := struct {
+			Name   string `json:"name"`
+			Data   string `json:"data"`
+			Labels []struct {
+				Name  string `json:"name"`
+				Value string `json:"value"`
+			} `json:"labels"`
+		}{}
+		err := ctx.Bind(&v)
+		if err == nil {
+			labels := make(map[string]string)
+			for _, l := range v.Labels {
+				if l.Name != "" && l.Value != "" {
+					labels[l.Name] = l.Value
+				}
+			}
+			err = docker.SecretCreate(v.Name, []byte(v.Data), labels)
+			if err == nil {
+				biz.Event.CreateSecret(model.EventActionCreate, v.Name, ctx.User())
+			}
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/service.go

@@ -0,0 +1,210 @@
+package controller
+
+import (
+	"bytes"
+	"encoding/json"
+	"strconv"
+	"strings"
+
+	"github.com/cuigh/auxo/data/set"
+	"github.com/cuigh/auxo/errors"
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/auxo/util/cast"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type ServiceController struct {
+	List   web.HandlerFunc `path:"/" name:"service.list" authorize:"!" desc:"service list page"`
+	Detail web.HandlerFunc `path:"/:name/detail" name:"service.detail" authorize:"!" desc:"service detail page"`
+	Raw    web.HandlerFunc `path:"/:name/raw" name:"service.raw" authorize:"!" desc:"service raw page"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"service.delete" authorize:"!" desc:"delete service"`
+	Scale  web.HandlerFunc `path:"/scale" method:"post" name:"service.scale" authorize:"!" desc:"scale service"`
+	New    web.HandlerFunc `path:"/new" name:"service.new" authorize:"!" desc:"new service page"`
+	Create web.HandlerFunc `path:"/new" method:"post" name:"service.create" authorize:"!" desc:"create service"`
+	Edit   web.HandlerFunc `path:"/:name/edit" name:"service.edit" authorize:"!" desc:"service edit page"`
+	Update web.HandlerFunc `path:"/:name/update" method:"post" name:"service.update" authorize:"!" desc:"update service"`
+}
+
+func Service() (c *ServiceController) {
+	c = &ServiceController{}
+
+	c.List = func(ctx web.Context) error {
+		name := ctx.Q("name")
+		page := cast.ToIntD(ctx.Q("page"), 1)
+		services, totalCount, err := docker.ServiceList(name, page, model.PageSize)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, page).
+			Add("Name", name).
+			Add("Services", services)
+		return ctx.Render("service/list", m)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		name := ctx.P("name")
+		service, _, err := docker.ServiceInspect(name)
+		if err != nil {
+			return err
+		}
+
+		info := model.NewServiceDetailInfo(service)
+		for _, vip := range service.Endpoint.VirtualIPs {
+			n, err := docker.NetworkInspect(vip.NetworkID)
+			if err != nil {
+				return err
+			}
+			info.Networks = append(info.Networks, model.Network{ID: vip.NetworkID, Name: n.Name, Address: vip.Addr})
+		}
+
+		tasks, err := docker.TaskList(name, "")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Service", info).Add("Tasks", tasks)
+		return ctx.Render("service/detail", m)
+	}
+
+	c.Raw = func(ctx web.Context) error {
+		name := ctx.P("name")
+		_, raw, err := docker.ServiceInspect(name)
+		if err != nil {
+			return err
+		}
+
+		buf := &bytes.Buffer{}
+		err = json.Indent(buf, raw, "", "    ")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Service", name).Add("Raw", string(buf.Bytes()))
+		return ctx.Render("service/raw", m)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		names := strings.Split(ctx.F("names"), ",")
+		for _, name := range names {
+			if err := docker.ServiceRemove(name); err != nil {
+				return ajaxResult(ctx, err)
+			} else {
+				biz.Event.CreateService(model.EventActionDelete, name, ctx.User())
+			}
+		}
+		return ajaxSuccess(ctx, nil)
+	}
+
+	c.New = func(ctx web.Context) error {
+		networks, err := docker.NetworkList()
+		if err != nil {
+			return err
+		}
+		secrets, _, err := docker.SecretList("", 1, 100)
+		if err != nil {
+			return err
+		}
+		configs, _, err := docker.ConfigList("", 1, 100)
+		if err != nil {
+			return err
+		}
+		registries, err := biz.Registry.List()
+		if err != nil {
+			return err
+		}
+		m := newModel(ctx).Add("Networks", networks).Add("Secrets", secrets).Add("Configs", configs).Add("Registries", registries)
+		return ctx.Render("service/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		info := &model.ServiceInfo{}
+		err := ctx.Bind(info)
+		if err == nil {
+			if info.Registry != "" {
+				registry, err := biz.Registry.Get(info.Registry)
+				if err != nil {
+					return errors.Wrap("Load registry info failed", err)
+				} else if registry == nil {
+					return errors.New("Can't load registry info")
+				}
+
+				info.Image = registry.URL + "/" + info.Image
+				info.RegistryAuth = registry.GetEncodedAuth()
+			}
+			err = docker.ServiceCreate(info)
+		}
+
+		if err == nil {
+			biz.Event.CreateService(model.EventActionCreate, info.Name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Edit = func(ctx web.Context) error {
+		name := ctx.P("name")
+		service, _, err := docker.ServiceInspect(name)
+		if err != nil {
+			return err
+		}
+
+		networks, err := docker.NetworkList()
+		if err != nil {
+			return err
+		}
+		secrets, _, err := docker.SecretList("", 1, 100)
+		if err != nil {
+			return err
+		}
+		configs, _, err := docker.ConfigList("", 1, 100)
+		if err != nil {
+			return err
+		}
+
+		checkedNetworks := set.FromSlice(service.Endpoint.VirtualIPs, func(i int) interface{} { return service.Endpoint.VirtualIPs[i].NetworkID })
+		checkedSecrets := set.FromSlice(service.Spec.TaskTemplate.ContainerSpec.Secrets, func(i int) interface{} {
+			return service.Spec.TaskTemplate.ContainerSpec.Secrets[i].SecretName
+		})
+		checkedConfigs := set.FromSlice(service.Spec.TaskTemplate.ContainerSpec.Configs, func(i int) interface{} {
+			return service.Spec.TaskTemplate.ContainerSpec.Configs[i].ConfigName
+		})
+
+		m := newModel(ctx).Add("Service", model.NewServiceInfo(service)).
+			Add("Networks", networks).Add("CheckedNetworks", checkedNetworks).
+			Add("Secrets", secrets).Add("CheckedSecrets", checkedSecrets).
+			Add("Configs", configs).Add("CheckedConfigs", checkedConfigs)
+		return ctx.Render("service/edit", m)
+	}
+
+	c.Update = func(ctx web.Context) error {
+		info := &model.ServiceInfo{}
+		err := ctx.Bind(info)
+		if err == nil {
+			info.Name = ctx.P("name")
+			err = docker.ServiceUpdate(info)
+		}
+
+		if err == nil {
+			biz.Event.CreateService(model.EventActionUpdate, info.Name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Scale = func(ctx web.Context) error {
+		name := ctx.F("name")
+		count, err := strconv.Atoi(ctx.F("count"))
+		if err != nil {
+			return err
+		}
+
+		err = docker.ServiceScale(name, uint64(count))
+		if err == nil {
+			biz.Event.CreateService(model.EventActionScale, name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/setting.go

@@ -0,0 +1,37 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/model"
+)
+
+type SettingController struct {
+	Index  web.HandlerFunc `path:"/" name:"setting.edit" authorize:"!" desc:"settings edit page"`
+	Update web.HandlerFunc `path:"/" name:"setting.update" method:"post" authorize:"!" desc:"update settings"`
+}
+
+func Setting() (c *SettingController) {
+	c = &SettingController{}
+
+	c.Index = func(ctx web.Context) error {
+		setting, err := biz.Setting.Get()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Setting", setting)
+		return ctx.Render("system/setting/index", m)
+	}
+
+	c.Update = func(ctx web.Context) error {
+		setting := &model.Setting{}
+		err := ctx.Bind(setting)
+		if err == nil {
+			err = biz.Setting.Update(setting, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/stack.go

@@ -0,0 +1,177 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/biz/docker/compose"
+	"github.com/cuigh/swirl/model"
+)
+
+type StackController struct {
+	TaskList      web.HandlerFunc `path:"/task/" name:"stack.task.list" authorize:"!" desc:"stack task list page"`
+	TaskDelete    web.HandlerFunc `path:"/task/delete" method:"post" name:"stack.task.delete" authorize:"!" desc:"delete stack task"`
+	ArchiveList   web.HandlerFunc `path:"/archive/" name:"stack.archive.list" authorize:"!" desc:"stack archive list page"`
+	ArchiveDetail web.HandlerFunc `path:"/archive/:id/detail" name:"stack.archive.detail" authorize:"!" desc:"stack archive detail page"`
+	ArchiveEdit   web.HandlerFunc `path:"/archive/:id/edit" name:"stack.archive.edit" authorize:"!" desc:"stack archive edit page"`
+	ArchiveUpdate web.HandlerFunc `path:"/archive/:id/update" method:"post" name:"stack.archive.update" authorize:"!" desc:"update stack archive"`
+	ArchiveDelete web.HandlerFunc `path:"/archive/delete" method:"post" name:"stack.archive.delete" authorize:"!" desc:"delete stack archive"`
+	ArchiveDeploy web.HandlerFunc `path:"/archive/deploy" method:"post" name:"stack.archive.deploy" authorize:"!" desc:"deploy stack archive"`
+	ArchiveNew    web.HandlerFunc `path:"/archive/new" name:"stack.archive.new" authorize:"!" desc:"new stack.archive page"`
+	ArchiveCreate web.HandlerFunc `path:"/archive/new" method:"post" name:"stack.archive.create" authorize:"!" desc:"create stack.archive"`
+}
+
+func Stack() (c *StackController) {
+	c = &StackController{}
+
+	c.TaskList = func(ctx web.Context) error {
+		stacks, err := docker.StackList()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Stacks", stacks)
+		return ctx.Render("stack/task/list", m)
+	}
+
+	c.TaskDelete = func(ctx web.Context) error {
+		name := ctx.F("name")
+		err := docker.StackRemove(name)
+		if err == nil {
+			biz.Event.CreateStackTask(model.EventActionDelete, name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.ArchiveList = func(ctx web.Context) error {
+		args := &model.ArchiveListArgs{}
+		err := ctx.Bind(args)
+		if err != nil {
+			return err
+		}
+		args.PageSize = model.PageSize
+		if args.PageIndex == 0 {
+			args.PageIndex = 1
+		}
+
+		archives, totalCount, err := biz.Archive.List(args)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, args.PageIndex).
+			Add("Name", args.Name).
+			Add("Archives", archives)
+		return ctx.Render("stack/archive/list", m)
+	}
+
+	c.ArchiveDetail = func(ctx web.Context) error {
+		id := ctx.P("id")
+		archive, err := biz.Archive.Get(id)
+		if err != nil {
+			return err
+		}
+		if archive == nil {
+			return web.ErrNotFound
+		}
+
+		m := newModel(ctx).Add("Archive", archive)
+		return ctx.Render("stack/archive/detail", m)
+	}
+
+	c.ArchiveEdit = func(ctx web.Context) error {
+		id := ctx.P("id")
+		archive, err := biz.Archive.Get(id)
+		if err != nil {
+			return err
+		}
+		if archive == nil {
+			return web.ErrNotFound
+		}
+
+		m := newModel(ctx).Add("Archive", archive)
+		return ctx.Render("stack/archive/edit", m)
+	}
+
+	c.ArchiveUpdate = func(ctx web.Context) error {
+		archive := &model.Archive{}
+		err := ctx.Bind(archive)
+		if err == nil {
+			// Validate format
+			_, err = compose.Parse(archive.Name, archive.Content)
+			if err != nil {
+				return err
+			}
+
+			archive.UpdatedBy = ctx.User().ID()
+			err = biz.Archive.Update(archive)
+		}
+		if err == nil {
+			biz.Event.CreateStackArchive(model.EventActionUpdate, archive.ID, archive.Name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.ArchiveDelete = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := biz.Archive.Delete(id, ctx.User())
+		return ajaxResult(ctx, err)
+	}
+
+	c.ArchiveDeploy = func(ctx web.Context) error {
+		id := ctx.F("id")
+		archive, err := biz.Archive.Get(id)
+		if err != nil {
+			return err
+		}
+
+		cfg, err := compose.Parse(archive.Name, archive.Content)
+		if err != nil {
+			return err
+		}
+
+		registries, err := biz.Registry.List()
+		if err != nil {
+			return err
+		}
+
+		// Find auth info from registry
+		authes := map[string]string{}
+		for _, sc := range cfg.Services {
+			if _, ok := authes[sc.Image]; !ok {
+				for _, r := range registries {
+					if r.Match(sc.Image) {
+						authes[sc.Image] = r.GetEncodedAuth()
+					}
+				}
+			}
+		}
+
+		err = docker.StackDeploy(archive.Name, archive.Content, authes)
+		return ajaxResult(ctx, err)
+	}
+
+	c.ArchiveNew = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("stack/archive/new", m)
+	}
+
+	c.ArchiveCreate = func(ctx web.Context) error {
+		archive := &model.Archive{}
+		err := ctx.Bind(archive)
+		if err == nil {
+			// Validate format
+			_, err = compose.Parse(archive.Name, archive.Content)
+			if err != nil {
+				return err
+			}
+
+			archive.CreatedBy = ctx.User().ID()
+			archive.UpdatedBy = archive.CreatedBy
+			err = biz.Archive.Create(archive)
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/task.go

@@ -0,0 +1,48 @@
+package controller
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz/docker"
+)
+
+type TaskController struct {
+	Detail web.HandlerFunc `path:"/:id/detail" name:"task.detail" authorize:"!" desc:"task detail page"`
+	Raw    web.HandlerFunc `path:"/:id/raw" name:"task.raw" authorize:"!" desc:"task raw page"`
+}
+
+func Task() (c *TaskController) {
+	c = &TaskController{}
+
+	c.Detail = func(ctx web.Context) error {
+		id := ctx.P("id")
+		task, _, err := docker.TaskInspect(id)
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Task", task)
+		return ctx.Render("task/detail", m)
+	}
+
+	c.Raw = func(ctx web.Context) error {
+		id := ctx.P("id")
+		task, raw, err := docker.TaskInspect(id)
+		if err != nil {
+			return err
+		}
+
+		buf := &bytes.Buffer{}
+		err = json.Indent(buf, raw, "", "    ")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Task", task).Add("Raw", string(buf.Bytes()))
+		return ctx.Render("task/raw", m)
+	}
+
+	return
+}

controller/template.go

@@ -0,0 +1,18 @@
+package controller
+
+import "github.com/cuigh/auxo/net/web"
+
+type TemplateController struct {
+	List web.HandlerFunc `path:"/" name:"template.list" authorize:"!" desc:"service template list page"`
+}
+
+func Template() (c *TemplateController) {
+	c = &TemplateController{}
+
+	c.List = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("service/template/list", m)
+	}
+
+	return
+}

controller/user.go

@@ -0,0 +1,151 @@
+package controller
+
+import (
+	"github.com/cuigh/auxo/log"
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/model"
+)
+
+type UserController struct {
+	Index   web.HandlerFunc `path:"/" name:"user.list" authorize:"!" desc:"user list page"`
+	New     web.HandlerFunc `path:"/new" name:"user.new" authorize:"!" desc:"new user page"`
+	Create  web.HandlerFunc `path:"/new" method:"post" name:"user.create" authorize:"!" desc:"create user"`
+	Detail  web.HandlerFunc `path:"/:name/detail" name:"user.detail" authorize:"!" desc:"user detail page"`
+	Edit    web.HandlerFunc `path:"/:name/edit" name:"user.edit" authorize:"!" desc:"edit user page"`
+	Update  web.HandlerFunc `path:"/:name/update" method:"post" name:"user.update" authorize:"!" desc:"update user"`
+	Block   web.HandlerFunc `path:"/block" method:"post" name:"user.block" authorize:"!" desc:"block user"`
+	Unblock web.HandlerFunc `path:"/unblock" method:"post" name:"user.unblock" authorize:"!" desc:"unblock user"`
+	Delete  web.HandlerFunc `path:"/delete" method:"post" name:"user.delete" authorize:"!" desc:"delete user"`
+}
+
+func User() (c *UserController) {
+	c = &UserController{}
+
+	c.Index = func(ctx web.Context) error {
+		args := &model.UserListArgs{}
+		err := ctx.Bind(args)
+		if err != nil {
+			return err
+		}
+		args.PageSize = model.PageSize
+		if args.PageIndex == 0 {
+			args.PageIndex = 1
+		}
+
+		users, totalCount, err := biz.User.List(args)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, args.PageIndex).
+			Add("Query", args.Query).
+			Add("Filter", args.Filter).
+			Add("Users", users)
+		return ctx.Render("system/user/list", m)
+	}
+
+	c.New = func(ctx web.Context) error {
+		roles, err := biz.Role.List()
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Roles", roles)
+		return ctx.Render("system/user/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		user := &model.User{}
+		err := ctx.Bind(user)
+		if err == nil {
+			user.Type = model.UserTypeInternal
+			err = biz.User.Create(user, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		name := ctx.P("name")
+		user, err := biz.User.GetByName(name)
+		if err != nil {
+			return err
+		}
+		if user == nil {
+			return web.ErrNotFound
+		}
+
+		var (
+			roles map[string]string
+			role  *model.Role
+		)
+		if len(user.Roles) > 0 {
+			roles = map[string]string{}
+			for _, id := range user.Roles {
+				role, err = biz.Role.Get(id)
+				if err != nil {
+					return err
+				} else if role != nil {
+					roles[id] = role.Name
+				} else {
+					log.Get("user").Warnf("Role %v is invalid", id)
+				}
+			}
+		}
+
+		m := newModel(ctx).Add("User", user).Add("Roles", roles)
+		return ctx.Render("system/user/detail", m)
+	}
+
+	c.Edit = func(ctx web.Context) error {
+		name := ctx.P("name")
+		user, err := biz.User.GetByName(name)
+		if err != nil {
+			return err
+		}
+		if user == nil {
+			return web.ErrNotFound
+		}
+
+		roles, err := biz.Role.List()
+		if err != nil {
+			return err
+		}
+
+		userRoles := make(map[string]struct{})
+		for _, id := range user.Roles {
+			userRoles[id] = model.Placeholder
+		}
+		m := newModel(ctx).Add("User", user).Add("Roles", roles).Add("UserRoles", userRoles)
+		return ctx.Render("system/user/edit", m)
+	}
+
+	c.Update = func(ctx web.Context) error {
+		user := &model.User{}
+		err := ctx.Bind(user)
+		if err == nil {
+			err = biz.User.Update(user, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Block = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := biz.User.Block(id)
+		return ajaxResult(ctx, err)
+	}
+
+	c.Unblock = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := biz.User.Unblock(id)
+		return ajaxResult(ctx, err)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		id := ctx.F("id")
+		err := biz.User.Delete(id)
+		return ajaxResult(ctx, err)
+	}
+
+	return
+}

controller/volume.go

@@ -0,0 +1,108 @@
+package controller
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+
+	"github.com/cuigh/auxo/net/web"
+	"github.com/cuigh/auxo/util/cast"
+	"github.com/cuigh/swirl/biz"
+	"github.com/cuigh/swirl/biz/docker"
+	"github.com/cuigh/swirl/model"
+)
+
+type VolumeController struct {
+	List   web.HandlerFunc `path:"/" name:"volume.list" authorize:"!" desc:"volume list page"`
+	New    web.HandlerFunc `path:"/new" name:"volume.new" authorize:"!" desc:"new volume page"`
+	Create web.HandlerFunc `path:"/create" method:"post" name:"volume.create" authorize:"!" desc:"create volume"`
+	Delete web.HandlerFunc `path:"/delete" method:"post" name:"volume.delete" authorize:"!" desc:"delete volume"`
+	Prune  web.HandlerFunc `path:"/prune" method:"post" name:"volume.prune" authorize:"!" desc:"prune volume"`
+	Detail web.HandlerFunc `path:"/:name/detail" name:"volume.detail" authorize:"!" desc:"volume detail page"`
+	Raw    web.HandlerFunc `path:"/:name/raw" name:"volume.raw" authorize:"!" desc:"volume raw page"`
+}
+
+func Volume() (c *VolumeController) {
+	c = &VolumeController{}
+
+	c.List = func(ctx web.Context) error {
+		//name := ctx.Q("name")
+		page := cast.ToIntD(ctx.Q("page"), 1)
+		volumes, totalCount, err := docker.VolumeList(page, model.PageSize)
+		if err != nil {
+			return err
+		}
+
+		m := newPagerModel(ctx, totalCount, model.PageSize, page).
+			//Add("Name", name).
+			Add("Volumes", volumes)
+		return ctx.Render("volume/list", m)
+	}
+
+	c.New = func(ctx web.Context) error {
+		m := newModel(ctx)
+		return ctx.Render("/volume/new", m)
+	}
+
+	c.Create = func(ctx web.Context) error {
+		info := &model.VolumeCreateInfo{}
+		err := ctx.Bind(info)
+		if err != nil {
+			return err
+		}
+		err = docker.VolumeCreate(info)
+		if err == nil {
+			biz.Event.CreateVolume(model.EventActionCreate, info.Name, ctx.User())
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Delete = func(ctx web.Context) error {
+		names := strings.Split(ctx.F("names"), ",")
+		for _, name := range names {
+			if err := docker.VolumeRemove(name); err != nil {
+				return ajaxResult(ctx, err)
+			} else {
+				biz.Event.CreateVolume(model.EventActionDelete, name, ctx.User())
+			}
+		}
+		return ajaxSuccess(ctx, nil)
+	}
+
+	c.Prune = func(ctx web.Context) error {
+		report, err := docker.VolumePrune()
+		if err == nil {
+			return ajaxSuccess(ctx, report)
+		}
+		return ajaxResult(ctx, err)
+	}
+
+	c.Detail = func(ctx web.Context) error {
+		name := ctx.P("name")
+		volume, _, err := docker.VolumeInspectRaw(name)
+		if err != nil {
+			return err
+		}
+		m := newModel(ctx).Add("Volume", volume)
+		return ctx.Render("volume/detail", m)
+	}
+
+	c.Raw = func(ctx web.Context) error {
+		name := ctx.P("name")
+		_, raw, err := docker.VolumeInspectRaw(name)
+		if err != nil {
+			return err
+		}
+
+		buf := &bytes.Buffer{}
+		err = json.Indent(buf, raw, "", "    ")
+		if err != nil {
+			return err
+		}
+
+		m := newModel(ctx).Add("Volume", name).Add("Raw", string(buf.Bytes()))
+		return ctx.Render("volume/raw", m)
+	}
+
+	return
+}