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