16435: Merge branch 'master' into 16435-sync-groups-perm-levels
[arvados.git] / tools / sync-groups / sync-groups.go
1 // Copyright (C) The Arvados Authors. All rights reserved.
2 //
3 // SPDX-License-Identifier: AGPL-3.0
4
5 package main
6
7 import (
8         "bytes"
9         "encoding/csv"
10         "encoding/json"
11         "flag"
12         "fmt"
13         "io"
14         "log"
15         "net/url"
16         "os"
17         "strings"
18
19         "git.arvados.org/arvados.git/sdk/go/arvados"
20 )
21
22 var version = "dev"
23
24 type resourceList interface {
25         Len() int
26         GetItems() []interface{}
27 }
28
29 // GroupPermissions maps permission levels on groups (can_read, can_write, can_manage)
30 type GroupPermissions map[string]bool
31
32 // GroupInfo tracks previous and current member's permissions on a particular Group
33 type GroupInfo struct {
34         Group           arvados.Group
35         PreviousMembers map[string]GroupPermissions
36         CurrentMembers  map[string]GroupPermissions
37 }
38
39 // GetUserID returns the correct user id value depending on the selector
40 func GetUserID(u arvados.User, idSelector string) (string, error) {
41         switch idSelector {
42         case "email":
43                 return u.Email, nil
44         case "username":
45                 return u.Username, nil
46         default:
47                 return "", fmt.Errorf("cannot identify user by %q selector", idSelector)
48         }
49 }
50
51 // UserList implements resourceList interface
52 type UserList struct {
53         arvados.UserList
54 }
55
56 // Len returns the amount of items this list holds
57 func (l UserList) Len() int {
58         return len(l.Items)
59 }
60
61 // GetItems returns the list of items
62 func (l UserList) GetItems() (out []interface{}) {
63         for _, item := range l.Items {
64                 out = append(out, item)
65         }
66         return
67 }
68
69 // GroupList implements resourceList interface
70 type GroupList struct {
71         arvados.GroupList
72 }
73
74 // Len returns the amount of items this list holds
75 func (l GroupList) Len() int {
76         return len(l.Items)
77 }
78
79 // GetItems returns the list of items
80 func (l GroupList) GetItems() (out []interface{}) {
81         for _, item := range l.Items {
82                 out = append(out, item)
83         }
84         return
85 }
86
87 // LinkList implements resourceList interface
88 type LinkList struct {
89         arvados.LinkList
90 }
91
92 // Len returns the amount of items this list holds
93 func (l LinkList) Len() int {
94         return len(l.Items)
95 }
96
97 // GetItems returns the list of items
98 func (l LinkList) GetItems() (out []interface{}) {
99         for _, item := range l.Items {
100                 out = append(out, item)
101         }
102         return
103 }
104
105 func main() {
106         // Parse & validate arguments, set up arvados client.
107         cfg, err := GetConfig()
108         if err != nil {
109                 log.Fatalf("%v", err)
110         }
111
112         if err := doMain(&cfg); err != nil {
113                 log.Fatalf("%v", err)
114         }
115 }
116
117 // ConfigParams holds configuration data for this tool
118 type ConfigParams struct {
119         Path            string
120         UserID          string
121         Verbose         bool
122         ParentGroupUUID string
123         ParentGroupName string
124         SysUserUUID     string
125         Client          *arvados.Client
126 }
127
128 // ParseFlags parses and validates command line arguments
129 func ParseFlags(config *ConfigParams) error {
130         // Acceptable attributes to identify a user on the CSV file
131         userIDOpts := map[string]bool{
132                 "email":    true, // default
133                 "username": true,
134         }
135
136         flags := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
137
138         // Set up usage message
139         flags.Usage = func() {
140                 usageStr := `Synchronize remote groups into Arvados from a CSV format file with 3 columns:
141   * 1st: Group name
142   * 2nd: User identifier
143   * 3rd (Optional): User permission on the group: can_read, can_write or can_manage. (Default: can_write)`
144                 fmt.Fprintf(os.Stderr, "%s\n\n", usageStr)
145                 fmt.Fprintf(os.Stderr, "Usage:\n%s [OPTIONS] <input-file.csv>\n\n", os.Args[0])
146                 fmt.Fprintf(os.Stderr, "Options:\n")
147                 flags.PrintDefaults()
148         }
149
150         // Set up option flags
151         userID := flags.String(
152                 "user-id",
153                 "email",
154                 "Attribute by which every user is identified. Valid values are: email and username.")
155         verbose := flags.Bool(
156                 "verbose",
157                 false,
158                 "Log informational messages. Off by default.")
159         getVersion := flags.Bool(
160                 "version",
161                 false,
162                 "Print version information and exit.")
163         parentGroupUUID := flags.String(
164                 "parent-group-uuid",
165                 "",
166                 "Use given group UUID as a parent for the remote groups. Should be owned by the system user. If not specified, a group named '"+config.ParentGroupName+"' will be used (and created if nonexistant).")
167
168         // Parse args; omit the first arg which is the command name
169         flags.Parse(os.Args[1:])
170
171         // Print version information if requested
172         if *getVersion {
173                 fmt.Printf("%s %s\n", os.Args[0], version)
174                 os.Exit(0)
175         }
176
177         // Input file as a required positional argument
178         if flags.NArg() == 0 {
179                 return fmt.Errorf("please provide a path to an input file")
180         }
181         srcPath := &os.Args[flags.NFlag()+1]
182
183         // Validations
184         if *srcPath == "" {
185                 return fmt.Errorf("input file path invalid")
186         }
187         if !userIDOpts[*userID] {
188                 var options []string
189                 for opt := range userIDOpts {
190                         options = append(options, opt)
191                 }
192                 return fmt.Errorf("user ID must be one of: %s", strings.Join(options, ", "))
193         }
194
195         config.Path = *srcPath
196         config.ParentGroupUUID = *parentGroupUUID
197         config.UserID = *userID
198         config.Verbose = *verbose
199
200         return nil
201 }
202
203 // SetParentGroup finds/create parent group of all remote groups
204 func SetParentGroup(cfg *ConfigParams) error {
205         var parentGroup arvados.Group
206         if cfg.ParentGroupUUID == "" {
207                 // UUID not provided, search for preexisting parent group
208                 var gl GroupList
209                 params := arvados.ResourceListParams{
210                         Filters: []arvados.Filter{{
211                                 Attr:     "name",
212                                 Operator: "=",
213                                 Operand:  cfg.ParentGroupName,
214                         }, {
215                                 Attr:     "owner_uuid",
216                                 Operator: "=",
217                                 Operand:  cfg.SysUserUUID,
218                         }},
219                 }
220                 if err := cfg.Client.RequestAndDecode(&gl, "GET", "/arvados/v1/groups", nil, params); err != nil {
221                         return fmt.Errorf("error searching for parent group: %s", err)
222                 }
223                 if len(gl.Items) == 0 {
224                         // Default parent group does not exist, create it.
225                         if cfg.Verbose {
226                                 log.Println("Default parent group not found, creating...")
227                         }
228                         groupData := map[string]string{
229                                 "name":       cfg.ParentGroupName,
230                                 "owner_uuid": cfg.SysUserUUID,
231                         }
232                         if err := CreateGroup(cfg, &parentGroup, groupData); err != nil {
233                                 return fmt.Errorf("error creating system user owned group named %q: %s", groupData["name"], err)
234                         }
235                 } else if len(gl.Items) == 1 {
236                         // Default parent group found.
237                         parentGroup = gl.Items[0]
238                 } else {
239                         // This should never happen, as there's an unique index for
240                         // (owner_uuid, name) on groups.
241                         return fmt.Errorf("bug: found %d groups owned by system user and named %q", len(gl.Items), cfg.ParentGroupName)
242                 }
243                 cfg.ParentGroupUUID = parentGroup.UUID
244         } else {
245                 // UUID provided. Check if exists and if it's owned by system user
246                 if err := GetGroup(cfg, &parentGroup, cfg.ParentGroupUUID); err != nil {
247                         return fmt.Errorf("error searching for parent group with UUID %q: %s", cfg.ParentGroupUUID, err)
248                 }
249                 if parentGroup.OwnerUUID != cfg.SysUserUUID {
250                         return fmt.Errorf("parent group %q (%s) must be owned by system user", parentGroup.Name, cfg.ParentGroupUUID)
251                 }
252         }
253         return nil
254 }
255
256 // GetConfig sets up a ConfigParams struct
257 func GetConfig() (config ConfigParams, err error) {
258         config.ParentGroupName = "Externally synchronized groups"
259
260         // Command arguments
261         err = ParseFlags(&config)
262         if err != nil {
263                 return config, err
264         }
265
266         // Arvados Client setup
267         config.Client = arvados.NewClientFromEnv()
268
269         // Check current user permissions & get System user's UUID
270         u, err := config.Client.CurrentUser()
271         if err != nil {
272                 return config, fmt.Errorf("error getting the current user: %s", err)
273         }
274         if !u.IsActive || !u.IsAdmin {
275                 return config, fmt.Errorf("current user (%s) is not an active admin user", u.UUID)
276         }
277         config.SysUserUUID = u.UUID[:12] + "000000000000000"
278
279         // Set up remote groups' parent
280         if err = SetParentGroup(&config); err != nil {
281                 return config, err
282         }
283
284         return config, nil
285 }
286
287 func doMain(cfg *ConfigParams) error {
288         // Try opening the input file early, just in case there's a problem.
289         f, err := os.Open(cfg.Path)
290         if err != nil {
291                 return fmt.Errorf("%s", err)
292         }
293         defer f.Close()
294
295         log.Printf("%s %s started. Using %q as users id and parent group UUID %q", os.Args[0], version, cfg.UserID, cfg.ParentGroupUUID)
296
297         // Get the complete user list to minimize API Server requests
298         allUsers := make(map[string]arvados.User)
299         userIDToUUID := make(map[string]string) // Index by email or username
300         results, err := GetAll(cfg.Client, "users", arvados.ResourceListParams{}, &UserList{})
301         if err != nil {
302                 return fmt.Errorf("error getting user list: %s", err)
303         }
304         log.Printf("Found %d users", len(results))
305         for _, item := range results {
306                 u := item.(arvados.User)
307                 allUsers[u.UUID] = u
308                 uID, err := GetUserID(u, cfg.UserID)
309                 if err != nil {
310                         return err
311                 }
312                 userIDToUUID[uID] = u.UUID
313                 if cfg.Verbose {
314                         log.Printf("Seen user %q (%s)", u.Username, u.UUID)
315                 }
316         }
317
318         // Get remote groups and their members
319         remoteGroups, groupNameToUUID, err := GetRemoteGroups(cfg, allUsers)
320         if err != nil {
321                 return err
322         }
323         log.Printf("Found %d remote groups", len(remoteGroups))
324         if cfg.Verbose {
325                 for groupUUID := range remoteGroups {
326                         log.Printf("- Group %q: %d users", remoteGroups[groupUUID].Group.Name, len(remoteGroups[groupUUID].PreviousMembers))
327                 }
328         }
329
330         membershipsRemoved := 0
331
332         // Read the CSV file
333         groupsCreated, membershipsAdded, membershipsSkipped, err := ProcessFile(cfg, f, userIDToUUID, groupNameToUUID, remoteGroups, allUsers)
334         if err != nil {
335                 return err
336         }
337
338         // Remove previous members not listed on this run
339         for groupUUID := range remoteGroups {
340                 gi := remoteGroups[groupUUID]
341                 evictedMemberPerms := subtract(gi.PreviousMembers, gi.CurrentMembers)
342                 groupName := gi.Group.Name
343                 if len(evictedMemberPerms) > 0 {
344                         log.Printf("Removing permissions from %d users on group %q", len(evictedMemberPerms), groupName)
345                 }
346                 for member := range evictedMemberPerms {
347                         var perms []string
348                         completeMembershipRemoval := false
349                         if _, ok := gi.CurrentMembers[member]; !ok {
350                                 completeMembershipRemoval = true
351                                 membershipsRemoved++
352                         } else {
353                                 // Collect which user->group permission links should be removed
354                                 for p := range evictedMemberPerms[member] {
355                                         if evictedMemberPerms[member][p] {
356                                                 perms = append(perms, p)
357                                         }
358                                 }
359                                 membershipsRemoved += len(perms)
360                         }
361                         if err := RemoveMemberLinksFromGroup(cfg, allUsers[userIDToUUID[member]],
362                                 perms, completeMembershipRemoval, gi.Group); err != nil {
363                                 return err
364                         }
365                 }
366         }
367         log.Printf("Groups created: %d. Memberships added: %d, removed: %d, skipped: %d", groupsCreated, membershipsAdded, membershipsRemoved, membershipsSkipped)
368
369         return nil
370 }
371
372 // ProcessFile reads the CSV file and process every record
373 func ProcessFile(
374         cfg *ConfigParams,
375         f *os.File,
376         userIDToUUID map[string]string,
377         groupNameToUUID map[string]string,
378         remoteGroups map[string]*GroupInfo,
379         allUsers map[string]arvados.User,
380 ) (groupsCreated, membersAdded, membersSkipped int, err error) {
381         lineNo := 0
382         csvReader := csv.NewReader(f)
383         // Allow variable number of fields.
384         csvReader.FieldsPerRecord = -1
385         for {
386                 record, e := csvReader.Read()
387                 if e == io.EOF {
388                         break
389                 }
390                 lineNo++
391                 if e != nil {
392                         err = fmt.Errorf("error parsing %q, line %d", cfg.Path, lineNo)
393                         return
394                 }
395                 // Only allow 2 or 3 fields per record for backwards compatibility.
396                 if len(record) < 2 || len(record) > 3 {
397                         err = fmt.Errorf("error parsing %q, line %d: found %d fields but only 2 or 3 are allowed", cfg.Path, lineNo, len(record))
398                         return
399                 }
400                 groupName := strings.TrimSpace(record[0])
401                 groupMember := strings.TrimSpace(record[1]) // User ID (username or email)
402                 groupPermission := "can_write"
403                 if len(record) == 3 {
404                         groupPermission = strings.ToLower(record[2])
405                 }
406                 if groupName == "" || groupMember == "" || groupPermission == "" {
407                         log.Printf("Warning: CSV record has at least one empty field (%s, %s, %s). Skipping", groupName, groupMember, groupPermission)
408                         membersSkipped++
409                         continue
410                 }
411                 if !(groupPermission == "can_read" || groupPermission == "can_write" || groupPermission == "can_manage") {
412                         log.Printf("Warning: 3rd field should be 'can_read', 'can_write' or 'can_manage'. Found: %q at line %d, skipping.", groupPermission, lineNo)
413                         membersSkipped++
414                         continue
415                 }
416                 if _, found := userIDToUUID[groupMember]; !found {
417                         // User not present on the system, skip.
418                         log.Printf("Warning: there's no user with %s %q on the system, skipping.", cfg.UserID, groupMember)
419                         membersSkipped++
420                         continue
421                 }
422                 if _, found := groupNameToUUID[groupName]; !found {
423                         // Group doesn't exist, create it before continuing
424                         if cfg.Verbose {
425                                 log.Printf("Remote group %q not found, creating...", groupName)
426                         }
427                         var newGroup arvados.Group
428                         groupData := map[string]string{
429                                 "name":        groupName,
430                                 "owner_uuid":  cfg.ParentGroupUUID,
431                                 "group_class": "role",
432                         }
433                         if e := CreateGroup(cfg, &newGroup, groupData); e != nil {
434                                 err = fmt.Errorf("error creating group named %q: %s", groupName, err)
435                                 return
436                         }
437                         // Update cached group data
438                         groupNameToUUID[groupName] = newGroup.UUID
439                         remoteGroups[newGroup.UUID] = &GroupInfo{
440                                 Group:           newGroup,
441                                 PreviousMembers: make(map[string]GroupPermissions),
442                                 CurrentMembers:  make(map[string]GroupPermissions),
443                         }
444                         groupsCreated++
445                 }
446                 // Both group & user exist, check if user is a member
447                 groupUUID := groupNameToUUID[groupName]
448                 gi := remoteGroups[groupUUID]
449                 if !gi.PreviousMembers[groupMember][groupPermission] && !gi.CurrentMembers[groupMember][groupPermission] {
450                         if cfg.Verbose {
451                                 log.Printf("Adding %q to group %q", groupMember, groupName)
452                         }
453                         // User permissionwasn't there, but should be. Avoid duplicating the
454                         // group->user link when necessary.
455                         createG2ULink := true
456                         if _, ok := gi.PreviousMembers[groupMember]; ok {
457                                 createG2ULink = false // User is already member of the group
458                         }
459                         if e := AddMemberToGroup(cfg, allUsers[userIDToUUID[groupMember]], gi.Group, groupPermission, createG2ULink); e != nil {
460                                 err = e
461                                 return
462                         }
463                         membersAdded++
464                 }
465                 if _, ok := gi.CurrentMembers[groupMember]; ok {
466                         gi.CurrentMembers[groupMember][groupPermission] = true
467                 } else {
468                         gi.CurrentMembers[groupMember] = GroupPermissions{groupPermission: true}
469                 }
470
471         }
472         return
473 }
474
475 // GetAll : Adds all objects of type 'resource' to the 'allItems' list
476 func GetAll(c *arvados.Client, res string, params arvados.ResourceListParams, page resourceList) (allItems []interface{}, err error) {
477         // Use the maximum page size the server allows
478         limit := 1<<31 - 1
479         params.Limit = &limit
480         params.Offset = 0
481         params.Order = "uuid"
482         for {
483                 if err = GetResourceList(c, &page, res, params); err != nil {
484                         return allItems, err
485                 }
486                 // Have we finished paging?
487                 if page.Len() == 0 {
488                         break
489                 }
490                 for _, i := range page.GetItems() {
491                         allItems = append(allItems, i)
492                 }
493                 params.Offset += page.Len()
494         }
495         return allItems, nil
496 }
497
498 func subtract(setA map[string]GroupPermissions, setB map[string]GroupPermissions) map[string]GroupPermissions {
499         result := make(map[string]GroupPermissions)
500         for element := range setA {
501                 if _, ok := setB[element]; !ok {
502                         result[element] = setA[element]
503                 } else {
504                         for perm := range setA[element] {
505                                 if _, ok := setB[element][perm]; !ok {
506                                         result[element] = GroupPermissions{perm: true}
507                                 }
508                         }
509                 }
510         }
511         return result
512 }
513
514 func jsonReader(rscName string, ob interface{}) io.Reader {
515         j, err := json.Marshal(ob)
516         if err != nil {
517                 panic(err)
518         }
519         v := url.Values{}
520         v[rscName] = []string{string(j)}
521         return bytes.NewBufferString(v.Encode())
522 }
523
524 // GetRemoteGroups fetches all remote groups with their members
525 func GetRemoteGroups(cfg *ConfigParams, allUsers map[string]arvados.User) (remoteGroups map[string]*GroupInfo, groupNameToUUID map[string]string, err error) {
526         remoteGroups = make(map[string]*GroupInfo)
527         groupNameToUUID = make(map[string]string) // Index by group name
528
529         params := arvados.ResourceListParams{
530                 Filters: []arvados.Filter{{
531                         Attr:     "owner_uuid",
532                         Operator: "=",
533                         Operand:  cfg.ParentGroupUUID,
534                 }},
535         }
536         results, err := GetAll(cfg.Client, "groups", params, &GroupList{})
537         if err != nil {
538                 return remoteGroups, groupNameToUUID, fmt.Errorf("error getting remote groups: %s", err)
539         }
540         for _, item := range results {
541                 group := item.(arvados.Group)
542                 // Group -> User filter
543                 g2uFilter := arvados.ResourceListParams{
544                         Filters: []arvados.Filter{{
545                                 Attr:     "owner_uuid",
546                                 Operator: "=",
547                                 Operand:  cfg.SysUserUUID,
548                         }, {
549                                 Attr:     "link_class",
550                                 Operator: "=",
551                                 Operand:  "permission",
552                         }, {
553                                 Attr:     "name",
554                                 Operator: "=",
555                                 Operand:  "can_read",
556                         }, {
557                                 Attr:     "tail_uuid",
558                                 Operator: "=",
559                                 Operand:  group.UUID,
560                         }, {
561                                 Attr:     "head_uuid",
562                                 Operator: "is_a",
563                                 Operand:  "arvados#user",
564                         }},
565                 }
566                 // User -> Group filter
567                 u2gFilter := arvados.ResourceListParams{
568                         Filters: []arvados.Filter{{
569                                 Attr:     "owner_uuid",
570                                 Operator: "=",
571                                 Operand:  cfg.SysUserUUID,
572                         }, {
573                                 Attr:     "link_class",
574                                 Operator: "=",
575                                 Operand:  "permission",
576                         }, {
577                                 Attr:     "name",
578                                 Operator: "in",
579                                 Operand:  []string{"can_read", "can_write", "can_manage"},
580                         }, {
581                                 Attr:     "head_uuid",
582                                 Operator: "=",
583                                 Operand:  group.UUID,
584                         }, {
585                                 Attr:     "tail_uuid",
586                                 Operator: "is_a",
587                                 Operand:  "arvados#user",
588                         }},
589                 }
590                 g2uLinks, err := GetAll(cfg.Client, "links", g2uFilter, &LinkList{})
591                 if err != nil {
592                         return remoteGroups, groupNameToUUID, fmt.Errorf("error getting group->user 'can_read' links for group %q: %s", group.Name, err)
593                 }
594                 u2gLinks, err := GetAll(cfg.Client, "links", u2gFilter, &LinkList{})
595                 if err != nil {
596                         return remoteGroups, groupNameToUUID, fmt.Errorf("error getting user->group links for group %q: %s", group.Name, err)
597                 }
598                 // Build a list of user ids (email or username) belonging to this group.
599                 membersSet := make(map[string]GroupPermissions)
600                 u2gLinkSet := make(map[string]GroupPermissions)
601                 for _, l := range u2gLinks {
602                         link := l.(arvados.Link)
603                         // Also save the member's group access level.
604                         if _, ok := u2gLinkSet[link.TailUUID]; ok {
605                                 u2gLinkSet[link.TailUUID][link.Name] = true
606                         } else {
607                                 u2gLinkSet[link.TailUUID] = GroupPermissions{link.Name: true}
608                         }
609                 }
610                 for _, item := range g2uLinks {
611                         link := item.(arvados.Link)
612                         // We may have received an old link pointing to a removed account.
613                         if _, found := allUsers[link.HeadUUID]; !found {
614                                 continue
615                         }
616                         // The matching User -> Group link may not exist if the link
617                         // creation failed on a previous run. If that's the case, don't
618                         // include this account on the "previous members" list.
619                         if _, found := u2gLinkSet[link.HeadUUID]; !found {
620                                 continue
621                         }
622                         memberID, err := GetUserID(allUsers[link.HeadUUID], cfg.UserID)
623                         if err != nil {
624                                 return remoteGroups, groupNameToUUID, err
625                         }
626                         membersSet[memberID] = u2gLinkSet[link.HeadUUID]
627                 }
628                 remoteGroups[group.UUID] = &GroupInfo{
629                         Group:           group,
630                         PreviousMembers: membersSet,
631                         CurrentMembers:  make(map[string]GroupPermissions),
632                 }
633                 groupNameToUUID[group.Name] = group.UUID
634         }
635         return remoteGroups, groupNameToUUID, nil
636 }
637
638 // RemoveMemberLinksFromGroup remove all links related to the membership
639 func RemoveMemberLinksFromGroup(cfg *ConfigParams, user arvados.User, linkNames []string, completeRemoval bool, group arvados.Group) error {
640         if cfg.Verbose {
641                 log.Printf("Getting group membership links for user %q (%s) on group %q (%s)", user.Username, user.UUID, group.Name, group.UUID)
642         }
643         var links []interface{}
644         var filters [][]arvados.Filter
645         if completeRemoval {
646                 // Search for all group<->user links (both ways)
647                 filters = [][]arvados.Filter{
648                         // Group -> User
649                         {{
650                                 Attr:     "link_class",
651                                 Operator: "=",
652                                 Operand:  "permission",
653                         }, {
654                                 Attr:     "tail_uuid",
655                                 Operator: "=",
656                                 Operand:  group.UUID,
657                         }, {
658                                 Attr:     "head_uuid",
659                                 Operator: "=",
660                                 Operand:  user.UUID,
661                         }},
662                         // Group <- User
663                         {{
664                                 Attr:     "link_class",
665                                 Operator: "=",
666                                 Operand:  "permission",
667                         }, {
668                                 Attr:     "tail_uuid",
669                                 Operator: "=",
670                                 Operand:  user.UUID,
671                         }, {
672                                 Attr:     "head_uuid",
673                                 Operator: "=",
674                                 Operand:  group.UUID,
675                         }},
676                 }
677         } else {
678                 // Search only for the requested Group <- User permission links
679                 filters = [][]arvados.Filter{
680                         {{
681                                 Attr:     "link_class",
682                                 Operator: "=",
683                                 Operand:  "permission",
684                         }, {
685                                 Attr:     "tail_uuid",
686                                 Operator: "=",
687                                 Operand:  user.UUID,
688                         }, {
689                                 Attr:     "head_uuid",
690                                 Operator: "=",
691                                 Operand:  group.UUID,
692                         }, {
693                                 Attr:     "name",
694                                 Operator: "in",
695                                 Operand:  linkNames,
696                         }},
697                 }
698         }
699
700         for _, filterset := range filters {
701                 l, err := GetAll(cfg.Client, "links", arvados.ResourceListParams{Filters: filterset}, &LinkList{})
702                 if err != nil {
703                         userID, _ := GetUserID(user, cfg.UserID)
704                         return fmt.Errorf("error getting links needed to remove user %q from group %q: %s", userID, group.Name, err)
705                 }
706                 for _, link := range l {
707                         links = append(links, link)
708                 }
709         }
710         for _, item := range links {
711                 link := item.(arvados.Link)
712                 userID, _ := GetUserID(user, cfg.UserID)
713                 if cfg.Verbose {
714                         log.Printf("Removing %q permission link for %q on group %q", link.Name, userID, group.Name)
715                 }
716                 if err := DeleteLink(cfg, link.UUID); err != nil {
717                         return fmt.Errorf("error removing user %q from group %q: %s", userID, group.Name, err)
718                 }
719         }
720         return nil
721 }
722
723 // AddMemberToGroup create membership links
724 func AddMemberToGroup(cfg *ConfigParams, user arvados.User, group arvados.Group, perm string, createG2ULink bool) error {
725         var newLink arvados.Link
726         var linkData map[string]string
727         if createG2ULink {
728                 linkData = map[string]string{
729                         "owner_uuid": cfg.SysUserUUID,
730                         "link_class": "permission",
731                         "name":       "can_read",
732                         "tail_uuid":  group.UUID,
733                         "head_uuid":  user.UUID,
734                 }
735                 if err := CreateLink(cfg, &newLink, linkData); err != nil {
736                         userID, _ := GetUserID(user, cfg.UserID)
737                         return fmt.Errorf("error adding group %q -> user %q read permission: %s", group.Name, userID, err)
738                 }
739         }
740         linkData = map[string]string{
741                 "owner_uuid": cfg.SysUserUUID,
742                 "link_class": "permission",
743                 "name":       perm,
744                 "tail_uuid":  user.UUID,
745                 "head_uuid":  group.UUID,
746         }
747         if err := CreateLink(cfg, &newLink, linkData); err != nil {
748                 userID, _ := GetUserID(user, cfg.UserID)
749                 return fmt.Errorf("error adding user %q -> group %q %s permission: %s", userID, group.Name, perm, err)
750         }
751         return nil
752 }
753
754 // CreateGroup creates a group with groupData parameters, assigns it to dst
755 func CreateGroup(cfg *ConfigParams, dst *arvados.Group, groupData map[string]string) error {
756         return cfg.Client.RequestAndDecode(dst, "POST", "/arvados/v1/groups", jsonReader("group", groupData), nil)
757 }
758
759 // GetGroup fetches a group by its UUID
760 func GetGroup(cfg *ConfigParams, dst *arvados.Group, groupUUID string) error {
761         return cfg.Client.RequestAndDecode(&dst, "GET", "/arvados/v1/groups/"+groupUUID, nil, nil)
762 }
763
764 // CreateLink creates a link with linkData parameters, assigns it to dst
765 func CreateLink(cfg *ConfigParams, dst *arvados.Link, linkData map[string]string) error {
766         return cfg.Client.RequestAndDecode(dst, "POST", "/arvados/v1/links", jsonReader("link", linkData), nil)
767 }
768
769 // DeleteLink deletes a link by its UUID
770 func DeleteLink(cfg *ConfigParams, linkUUID string) error {
771         if linkUUID == "" {
772                 return fmt.Errorf("cannot delete link with invalid UUID: %q", linkUUID)
773         }
774         return cfg.Client.RequestAndDecode(&arvados.Link{}, "DELETE", "/arvados/v1/links/"+linkUUID, nil, nil)
775 }
776
777 // GetResourceList fetches res list using params
778 func GetResourceList(c *arvados.Client, dst *resourceList, res string, params interface{}) error {
779         return c.RequestAndDecode(dst, "GET", "/arvados/v1/"+res, nil, params)
780 }