internal/control/org.go

  1package control
  2
  3import (
  4	"errors"
  5	"fmt"
  6	"io"
  7	"os"
  8	"path/filepath"
  9
 10	"gitbay.org/gitbay/internal/policy"
 11	"gitbay.org/gitbay/internal/protocol"
 12	"gitbay.org/gitbay/internal/store"
 13)
 14
 15func init() {
 16	register(Command{Path: []string{"org", "create"},
 17		Summary:  "create an organization (you become its first admin)",
 18		Usage:    "org create <name>",
 19		Examples: []string{"org create krz"}, Run: runOrgCreate})
 20	register(Command{Path: []string{"org", "list"},
 21		Summary:  "list organizations you belong to",
 22		Usage:    "org list",
 23		Examples: []string{"org list"}, ReadOnly: true, Run: runOrgList})
 24	register(Command{Path: []string{"org", "show"},
 25		Summary:  "show an organization and its members",
 26		Usage:    "org show <name>",
 27		Examples: []string{"org show krz"}, ReadOnly: true, Run: runOrgShow})
 28	register(Command{Path: []string{"org", "rename"},
 29		Summary:  "rename an organization",
 30		Usage:    "org rename <old> <new> (clone URLs change)",
 31		Examples: []string{"org rename krz krazywarez"}, Run: runOrgRename})
 32	register(Command{Path: []string{"org", "delete"},
 33		Summary: "delete an empty organization",
 34		Usage:   "org delete <name> --yes",
 35		Flags: []Flag{
 36			{"--yes", "", "confirm the permanent delete", ""},
 37		},
 38		Examples: []string{"org delete krz --yes"}, Run: runOrgDelete})
 39	register(Command{Path: []string{"org", "members", "add"},
 40		NeedsRecentSignIn: true,
 41		Summary:           "add or update a member",
 42		Usage:             "org members add <org> <user> [--role member|admin]",
 43		Flags: []Flag{
 44			{"--role", "member|admin", "the member's role", "member"},
 45		},
 46		Examples: []string{"org members add krz cmc --role admin"}, Run: runOrgMembersAdd})
 47	register(Command{Path: []string{"org", "members", "remove"},
 48		Summary:  "remove a member",
 49		Usage:    "org members remove <org> <user>",
 50		Examples: []string{"org members remove krz cmc"}, Run: runOrgMembersRemove})
 51	register(Command{Path: []string{"org", "members", "list"},
 52		Summary:  "list members",
 53		Usage:    "org members list <org>",
 54		Examples: []string{"org members list krz"}, ReadOnly: true, Run: runOrgMembersList})
 55}
 56
 57// orgAdmin loads an org and requires the caller to be one of its admins.
 58func orgAdmin(c *Ctx, name string) (store.Org, int) {
 59	org, err := c.Store.OrgByName(name)
 60	if errors.Is(err, store.ErrNotFound) {
 61		return org, c.fail(protocol.ExitNotFound, "no organization %q", name)
 62	}
 63	if err != nil {
 64		return org, c.fail(protocol.ExitFailure, "%v", err)
 65	}
 66	role, err := c.Store.OrgRole(org.ID, c.User.ID)
 67	if err != nil {
 68		return org, c.fail(protocol.ExitFailure, "%v", err)
 69	}
 70	if role != "admin" {
 71		return org, c.fail(protocol.ExitDenied, "only admins of %s can do that; ask one", name)
 72	}
 73	return org, -1
 74}
 75
 76func runOrgCreate(c *Ctx, args []string) int {
 77	if len(args) != 1 {
 78		return c.usage()
 79	}
 80	if err := policy.ValidateOwnerName(args[0]); err != nil {
 81		return c.failInput(err)
 82	}
 83	orgCreateMu.Lock()
 84	if code := checkOrgQuota(c); code >= 0 {
 85		orgCreateMu.Unlock()
 86		return code
 87	}
 88	_, err := c.Store.CreateOrg(args[0], c.User.ID)
 89	orgCreateMu.Unlock()
 90	if err != nil {
 91		return c.fail(protocol.ExitFailure, "%v", err)
 92	}
 93	return c.emit(map[string]string{"org": args[0], "role": "admin"}, func(w io.Writer) {
 94		fmt.Fprintf(w, "created organization %s; you are its admin\n", args[0])
 95	})
 96}
 97
 98func runOrgList(c *Ctx, args []string) int {
 99	orgs, err := c.Store.ListOrgsForUser(c.User.ID)
100	if err != nil {
101		return c.fail(protocol.ExitFailure, "%v", err)
102	}
103	type out struct {
104		Org  string `json:"org"`
105		Role string `json:"role"`
106	}
107	var ds []out
108	for _, o := range orgs {
109		ds = append(ds, out{o.Username, o.Role})
110	}
111	return c.emitView(ds, func(w io.Writer) {
112		tb := c.table(w, "ORG", "ROLE")
113		for _, d := range ds {
114			tb.row(cRef(d.Org), cState(d.Role))
115		}
116		tb.flush()
117	}, func() screen {
118		rows := make([]row, len(ds))
119		for i, d := range ds {
120			rows[i] = rowOf(cLink(d.Org, c.siteURL(d.Org)), cState(d.Role))
121		}
122		s := listScreen("Organizations", rows)
123		if len(ds) > 0 {
124			s.actions = []action{{"Read", []string{"org", "show", ds[0].Org}}}
125		}
126		return s
127	})
128}
129
130func runOrgShow(c *Ctx, args []string) int {
131	if len(args) != 1 {
132		return c.usage()
133	}
134	org, err := c.Store.OrgByName(args[0])
135	if errors.Is(err, store.ErrNotFound) {
136		return c.fail(protocol.ExitNotFound, "no organization %q", args[0])
137	}
138	if err != nil {
139		return c.fail(protocol.ExitFailure, "%v", err)
140	}
141	members, err := c.Store.OrgMembers(org.ID)
142	if err != nil {
143		return c.fail(protocol.ExitFailure, "%v", err)
144	}
145	type memberOut struct {
146		User string `json:"user"`
147		Role string `json:"role"`
148	}
149	var ms []memberOut
150	for _, m := range members {
151		ms = append(ms, memberOut{m.Username, m.Role})
152	}
153	d := struct {
154		Org     string      `json:"org"`
155		Members []memberOut `json:"members"`
156	}{org.Name, ms}
157	return c.emitView(d, func(w io.Writer) {
158		v := c.view(w)
159		v.title(d.Org, "", "")
160		if len(ms) > 0 {
161			v.section("members")
162			tb := c.table(w, "USER", "ROLE")
163			for _, m := range ms {
164				tb.row(cRef(m.User), cState(m.Role))
165			}
166			tb.flush()
167		}
168	}, func() screen {
169		members := section{title: "Members", n: len(ms)}
170		for _, m := range ms {
171			members.rows = append(members.rows, rowOf(cRef(m.User), cState(m.Role)))
172		}
173		return screen{
174			fields:   []field{{"Org", []cell{cLink(d.Org, c.siteURL(d.Org))}}},
175			sections: []section{members},
176			actions: []action{
177				{"Members", []string{"org", "members", "add", d.Org, "<user>"}},
178				{"Org", []string{"org", "team", "list", d.Org}},
179				{"Org", []string{"org", "label", "list", d.Org}},
180				{"Org", []string{"org", "milestone", "list", d.Org}},
181			},
182		}
183	})
184}
185
186func runOrgRename(c *Ctx, args []string) int {
187	if len(args) != 2 {
188		return c.usage()
189	}
190	org, code := orgAdmin(c, args[0])
191	if code >= 0 {
192		return code
193	}
194	newName := args[1]
195	if err := policy.ValidateOwnerName(newName); err != nil {
196		return c.failInput(err)
197	}
198	oldDir := filepath.Join(c.Cfg.Server.Root, "repos", org.Name)
199	newDir := filepath.Join(c.Cfg.Server.Root, "repos", newName)
200	if _, err := os.Stat(newDir); err == nil {
201		return c.fail(protocol.ExitFailure, "repository directory %s already exists", newName)
202	}
203	release, lockCode := holdOffBackup(c)
204	if lockCode >= 0 {
205		return lockCode
206	}
207	defer release()
208	if err := c.Store.RenameOrg(org.ID, newName); err != nil {
209		return c.failErr(err)
210	}
211	// Repo paths on disk derive from the owner name; move the tree. If the
212	// move fails, revert the database so name and disk stay consistent.
213	if _, err := os.Stat(oldDir); err == nil {
214		if err := os.Rename(oldDir, newDir); err != nil {
215			c.Store.RenameOrg(org.ID, org.Name)
216			return c.fail(protocol.ExitFailure, "moving repositories: %v", err)
217		}
218	}
219	return c.emit(map[string]string{"org": newName, "was": org.Name}, func(w io.Writer) {
220		fmt.Fprintf(w, "renamed %s to %s — clone URLs now use %s/<repo>\n", org.Name, newName, newName)
221	})
222}
223
224func runOrgDelete(c *Ctx, args []string) int {
225	var name string
226	yes := false
227	for _, a := range args {
228		if a == "--yes" {
229			yes = true
230		} else if name == "" {
231			name = a
232		} else {
233			return c.usage()
234		}
235	}
236	if name == "" {
237		return c.usage()
238	}
239	org, code := orgAdmin(c, name)
240	if code >= 0 {
241		return code
242	}
243	if !yes {
244		return c.fail(protocol.ExitUsage, "org delete is permanent; re-run with --yes")
245	}
246	if err := c.Store.DeleteOrg(org.ID); err != nil {
247		return c.fail(protocol.ExitFailure, "%v", err)
248	}
249	return c.emit(map[string]string{"deleted": name}, func(w io.Writer) {
250		fmt.Fprintf(w, "deleted organization %s\n", name)
251	})
252}
253
254func runOrgMembersAdd(c *Ctx, args []string) int {
255	f, err := c.parseArgs(args, flagSpec{Values: []string{"--role"}, MaxPos: -1, Usage: "org members add <org> <user> [--role member|admin]"})
256	if err != nil {
257		return c.fail(protocol.ExitUsage, "%v", err)
258	}
259	role, rest := "member", f.Pos
260	if f.Has("--role") {
261		role = f.Value("--role")
262	}
263	if len(rest) != 2 || (role != "member" && role != "admin") {
264		return c.usage()
265	}
266	org, code := orgAdmin(c, rest[0])
267	if code >= 0 {
268		return code
269	}
270	target, err := c.Store.UserByUsername(rest[1])
271	if errors.Is(err, store.ErrNotFound) {
272		return c.fail(protocol.ExitNotFound, "no such user %q", rest[1])
273	}
274	if err != nil {
275		return c.fail(protocol.ExitFailure, "%v", err)
276	}
277	if target.Ghost {
278		return c.fail(protocol.ExitDenied, "%v", errGhost)
279	}
280	if err := c.Store.SetOrgMember(org.ID, target.ID, role); err != nil {
281		return c.failErr(err)
282	}
283	return c.emit(map[string]string{"org": org.Name, "user": target.Username, "role": role}, func(w io.Writer) {
284		fmt.Fprintf(w, "%s is now a %s of %s\n", target.Username, role, org.Name)
285	})
286}
287
288func runOrgMembersRemove(c *Ctx, args []string) int {
289	if len(args) != 2 {
290		return c.usage()
291	}
292	org, code := orgAdmin(c, args[0])
293	if code >= 0 {
294		return code
295	}
296	target, err := c.Store.UserByUsername(args[1])
297	if errors.Is(err, store.ErrNotFound) {
298		return c.fail(protocol.ExitNotFound, "no such user %q", args[1])
299	}
300	if err != nil {
301		return c.fail(protocol.ExitFailure, "%v", err)
302	}
303	if err := c.Store.RemoveOrgMember(org.ID, target.ID); err != nil {
304		if errors.Is(err, store.ErrNotFound) {
305			return c.fail(protocol.ExitNotFound, "%s is not a member of %s", target.Username, org.Name)
306		}
307		return c.failErr(err)
308	}
309	return c.emit(map[string]string{"org": org.Name, "removed": target.Username}, func(w io.Writer) {
310		fmt.Fprintf(w, "removed %s from %s\n", target.Username, org.Name)
311	})
312}
313
314func runOrgMembersList(c *Ctx, args []string) int {
315	if len(args) != 1 {
316		return c.usage()
317	}
318	return runOrgShow(c, args)
319}