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 wasn't a member, but should be.
 454                         if e := AddMemberToGroup(cfg, allUsers[userIDToUUID[groupMember]], gi.Group, groupPermission); e != nil {
 455                                 err = e
 456                                 return
 457                         }
 458                         membersAdded++
 459                 }
 460                 if _, ok := gi.CurrentMembers[groupMember]; ok {
 461                         gi.CurrentMembers[groupMember][groupPermission] = true
 462                 } else {
 463                         gi.CurrentMembers[groupMember] = GroupPermissions{groupPermission: true}
 464                 }
 465
 466         }
 467         return
 468 }
 469
 470 // GetAll : Adds all objects of type 'resource' to the 'allItems' list
 471 func GetAll(c *arvados.Client, res string, params arvados.ResourceListParams, page resourceList) (allItems []interface{}, err error) {
 472         // Use the maximum page size the server allows
 473         limit := 1<<31 - 1
 474         params.Limit = &limit
 475         params.Offset = 0
 476         params.Order = "uuid"
 477         for {
 478                 if err = GetResourceList(c, &page, res, params); err != nil {
 479                         return allItems, err
 480                 }
 481                 // Have we finished paging?
 482                 if page.Len() == 0 {
 483                         break
 484                 }
 485                 for _, i := range page.GetItems() {
 486                         allItems = append(allItems, i)
 487                 }
 488                 params.Offset += page.Len()
 489         }
 490         return allItems, nil
 491 }
 492
 493 func subtract(setA map[string]GroupPermissions, setB map[string]GroupPermissions) map[string]GroupPermissions {
 494         result := make(map[string]GroupPermissions)
 495         for element := range setA {
 496                 if _, ok := setB[element]; !ok {
 497                         result[element] = setA[element]
 498                 } else {
 499                         for perm := range setA[element] {
 500                                 if _, ok := setB[element][perm]; !ok {
 501                                         result[element][perm] = true
 502                                 }
 503                         }
 504                 }
 505         }
 506         return result
 507 }
 508
 509 func jsonReader(rscName string, ob interface{}) io.Reader {
 510         j, err := json.Marshal(ob)
 511         if err != nil {
 512                 panic(err)
 513         }
 514         v := url.Values{}
 515         v[rscName] = []string{string(j)}
 516         return bytes.NewBufferString(v.Encode())
 517 }
 518
 519 // GetRemoteGroups fetches all remote groups with their members
 520 func GetRemoteGroups(cfg *ConfigParams, allUsers map[string]arvados.User) (remoteGroups map[string]*GroupInfo, groupNameToUUID map[string]string, err error) {
 521         remoteGroups = make(map[string]*GroupInfo)
 522         groupNameToUUID = make(map[string]string) // Index by group name
 523
 524         params := arvados.ResourceListParams{
 525                 Filters: []arvados.Filter{{
 526                         Attr:     "owner_uuid",
 527                         Operator: "=",
 528                         Operand:  cfg.ParentGroupUUID,
 529                 }},
 530         }
 531         results, err := GetAll(cfg.Client, "groups", params, &GroupList{})
 532         if err != nil {
 533                 return remoteGroups, groupNameToUUID, fmt.Errorf("error getting remote groups: %s", err)
 534         }
 535         for _, item := range results {
 536                 group := item.(arvados.Group)
 537                 // Group -> User filter
 538                 g2uFilter := arvados.ResourceListParams{
 539                         Filters: []arvados.Filter{{
 540                                 Attr:     "owner_uuid",
 541                                 Operator: "=",
 542                                 Operand:  cfg.SysUserUUID,
 543                         }, {
 544                                 Attr:     "link_class",
 545                                 Operator: "=",
 546                                 Operand:  "permission",
 547                         }, {
 548                                 Attr:     "name",
 549                                 Operator: "=",
 550                                 Operand:  "can_read",
 551                         }, {
 552                                 Attr:     "tail_uuid",
 553                                 Operator: "=",
 554                                 Operand:  group.UUID,
 555                         }, {
 556                                 Attr:     "head_uuid",
 557                                 Operator: "is_a",
 558                                 Operand:  "arvados#user",
 559                         }},
 560                 }
 561                 // User -> Group filter
 562                 u2gFilter := arvados.ResourceListParams{
 563                         Filters: []arvados.Filter{{
 564                                 Attr:     "owner_uuid",
 565                                 Operator: "=",
 566                                 Operand:  cfg.SysUserUUID,
 567                         }, {
 568                                 Attr:     "link_class",
 569                                 Operator: "=",
 570                                 Operand:  "permission",
 571                         }, {
 572                                 Attr:     "name",
 573                                 Operator: "in",
 574                                 Operand:  []string{"can_read", "can_write", "can_manage"},
 575                         }, {
 576                                 Attr:     "head_uuid",
 577                                 Operator: "=",
 578                                 Operand:  group.UUID,
 579                         }, {
 580                                 Attr:     "tail_uuid",
 581                                 Operator: "is_a",
 582                                 Operand:  "arvados#user",
 583                         }},
 584                 }
 585                 g2uLinks, err := GetAll(cfg.Client, "links", g2uFilter, &LinkList{})
 586                 if err != nil {
 587                         return remoteGroups, groupNameToUUID, fmt.Errorf("error getting group->user 'can_read' links for group %q: %s", group.Name, err)
 588                 }
 589                 u2gLinks, err := GetAll(cfg.Client, "links", u2gFilter, &LinkList{})
 590                 if err != nil {
 591                         return remoteGroups, groupNameToUUID, fmt.Errorf("error getting user->group links for group %q: %s", group.Name, err)
 592                 }
 593                 // Build a list of user ids (email or username) belonging to this group.
 594                 membersSet := make(map[string]GroupPermissions)
 595                 u2gLinkSet := make(map[string]GroupPermissions)
 596                 for _, l := range u2gLinks {
 597                         link := l.(arvados.Link)
 598                         // Also save the member's group access level.
 599                         if _, ok := u2gLinkSet[link.TailUUID]; ok {
 600                                 u2gLinkSet[link.TailUUID][link.Name] = true
 601                         } else {
 602                                 u2gLinkSet[link.TailUUID] = GroupPermissions{link.Name: true}
 603                         }
 604                 }
 605                 for _, item := range g2uLinks {
 606                         link := item.(arvados.Link)
 607                         // We may have received an old link pointing to a removed account.
 608                         if _, found := allUsers[link.HeadUUID]; !found {
 609                                 continue
 610                         }
 611                         // The matching User -> Group link may not exist if the link
 612                         // creation failed on a previous run. If that's the case, don't
 613                         // include this account on the "previous members" list.
 614                         if _, found := u2gLinkSet[link.HeadUUID]; !found {
 615                                 continue
 616                         }
 617                         memberID, err := GetUserID(allUsers[link.HeadUUID], cfg.UserID)
 618                         if err != nil {
 619                                 return remoteGroups, groupNameToUUID, err
 620                         }
 621                         membersSet[memberID] = u2gLinkSet[link.HeadUUID]
 622                 }
 623                 remoteGroups[group.UUID] = &GroupInfo{
 624                         Group:           group,
 625                         PreviousMembers: membersSet,
 626                         CurrentMembers:  make(map[string]GroupPermissions),
 627                 }
 628                 groupNameToUUID[group.Name] = group.UUID
 629         }
 630         return remoteGroups, groupNameToUUID, nil
 631 }
 632
 633 // RemoveMemberLinksFromGroup remove all links related to the membership
 634 func RemoveMemberLinksFromGroup(cfg *ConfigParams, user arvados.User, linkNames []string, completeRemoval bool, group arvados.Group) error {
 635         if cfg.Verbose {
 636                 log.Printf("Getting group membership links for user %q (%s) on group %q (%s)", user.Username, user.UUID, group.Name, group.UUID)
 637         }
 638         var links []interface{}
 639         var filters [][]arvados.Filter
 640         if completeRemoval {
 641                 // Search for all group<->user links (both ways)
 642                 filters = [][]arvados.Filter{
 643                         // Group -> User
 644                         {{
 645                                 Attr:     "link_class",
 646                                 Operator: "=",
 647                                 Operand:  "permission",
 648                         }, {
 649                                 Attr:     "tail_uuid",
 650                                 Operator: "=",
 651                                 Operand:  group.UUID,
 652                         }, {
 653                                 Attr:     "head_uuid",
 654                                 Operator: "=",
 655                                 Operand:  user.UUID,
 656                         }},
 657                         // Group <- User
 658                         {{
 659                                 Attr:     "link_class",
 660                                 Operator: "=",
 661                                 Operand:  "permission",
 662                         }, {
 663                                 Attr:     "tail_uuid",
 664                                 Operator: "=",
 665                                 Operand:  user.UUID,
 666                         }, {
 667                                 Attr:     "head_uuid",
 668                                 Operator: "=",
 669                                 Operand:  group.UUID,
 670                         }},
 671                 }
 672         } else {
 673                 // Search only for the requested Group <- User permission links
 674                 filters = [][]arvados.Filter{
 675                         {{
 676                                 Attr:     "link_class",
 677                                 Operator: "=",
 678                                 Operand:  "permission",
 679                         }, {
 680                                 Attr:     "tail_uuid",
 681                                 Operator: "=",
 682                                 Operand:  user.UUID,
 683                         }, {
 684                                 Attr:     "head_uuid",
 685                                 Operator: "=",
 686                                 Operand:  group.UUID,
 687                         }, {
 688                                 Attr:     "name",
 689                                 Operator: "in",
 690                                 Operand:  linkNames,
 691                         }},
 692                 }
 693         }
 694
 695         for _, filterset := range filters {
 696                 l, err := GetAll(cfg.Client, "links", arvados.ResourceListParams{Filters: filterset}, &LinkList{})
 697                 if err != nil {
 698                         userID, _ := GetUserID(user, cfg.UserID)
 699                         return fmt.Errorf("error getting links needed to remove user %q from group %q: %s", userID, group.Name, err)
 700                 }
 701                 for _, link := range l {
 702                         links = append(links, link)
 703                 }
 704         }
 705         for _, item := range links {
 706                 link := item.(arvados.Link)
 707                 userID, _ := GetUserID(user, cfg.UserID)
 708                 if cfg.Verbose {
 709                         log.Printf("Removing %q permission link for %q on group %q", link.Name, userID, group.Name)
 710                 }
 711                 if err := DeleteLink(cfg, link.UUID); err != nil {
 712                         return fmt.Errorf("error removing user %q from group %q: %s", userID, group.Name, err)
 713                 }
 714         }
 715         return nil
 716 }
 717
 718 // AddMemberToGroup create membership links
 719 func AddMemberToGroup(cfg *ConfigParams, user arvados.User, group arvados.Group, perm string) error {
 720         var newLink arvados.Link
 721         linkData := map[string]string{
 722                 "owner_uuid": cfg.SysUserUUID,
 723                 "link_class": "permission",
 724                 "name":       "can_read",
 725                 "tail_uuid":  group.UUID,
 726                 "head_uuid":  user.UUID,
 727         }
 728         if err := CreateLink(cfg, &newLink, linkData); err != nil {
 729                 userID, _ := GetUserID(user, cfg.UserID)
 730                 return fmt.Errorf("error adding group %q -> user %q read permission: %s", group.Name, userID, err)
 731         }
 732         linkData = map[string]string{
 733                 "owner_uuid": cfg.SysUserUUID,
 734                 "link_class": "permission",
 735                 "name":       perm,
 736                 "tail_uuid":  user.UUID,
 737                 "head_uuid":  group.UUID,
 738         }
 739         if err := CreateLink(cfg, &newLink, linkData); err != nil {
 740                 userID, _ := GetUserID(user, cfg.UserID)
 741                 return fmt.Errorf("error adding user %q -> group %q %s permission: %s", userID, group.Name, perm, err)
 742         }
 743         return nil
 744 }
 745
 746 // CreateGroup creates a group with groupData parameters, assigns it to dst
 747 func CreateGroup(cfg *ConfigParams, dst *arvados.Group, groupData map[string]string) error {
 748         return cfg.Client.RequestAndDecode(dst, "POST", "/arvados/v1/groups", jsonReader("group", groupData), nil)
 749 }
 750
 751 // GetGroup fetches a group by its UUID
 752 func GetGroup(cfg *ConfigParams, dst *arvados.Group, groupUUID string) error {
 753         return cfg.Client.RequestAndDecode(&dst, "GET", "/arvados/v1/groups/"+groupUUID, nil, nil)
 754 }
 755
 756 // CreateLink creates a link with linkData parameters, assigns it to dst
 757 func CreateLink(cfg *ConfigParams, dst *arvados.Link, linkData map[string]string) error {
 758         return cfg.Client.RequestAndDecode(dst, "POST", "/arvados/v1/links", jsonReader("link", linkData), nil)
 759 }
 760
 761 // DeleteLink deletes a link by its UUID
 762 func DeleteLink(cfg *ConfigParams, linkUUID string) error {
 763         if linkUUID == "" {
 764                 return fmt.Errorf("cannot delete link with invalid UUID: %q", linkUUID)
 765         }
 766         return cfg.Client.RequestAndDecode(&arvados.Link{}, "DELETE", "/arvados/v1/links/"+linkUUID, nil, nil)
 767 }
 768
 769 // GetResourceList fetches res list using params
 770 func GetResourceList(c *arvados.Client, dst *resourceList, res string, params interface{}) error {
 771         return c.RequestAndDecode(dst, "GET", "/arvados/v1/"+res, nil, params)
 772 }