tools/sync-users/sync-users.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         "strconv"
  18         "strings"
  19
  20         "git.arvados.org/arvados.git/lib/cmd"
  21         "git.arvados.org/arvados.git/sdk/go/arvados"
  22 )
  23
  24 var version = "dev"
  25
  26 type resourceList interface {
  27         Len() int
  28         GetItems() []interface{}
  29 }
  30
  31 // UserList implements resourceList interface
  32 type UserList struct {
  33         arvados.UserList
  34 }
  35
  36 // Len returns the amount of items this list holds
  37 func (l UserList) Len() int {
  38         return len(l.Items)
  39 }
  40
  41 // GetItems returns the list of items
  42 func (l UserList) GetItems() (out []interface{}) {
  43         for _, item := range l.Items {
  44                 out = append(out, item)
  45         }
  46         return
  47 }
  48
  49 func main() {
  50         cfg, err := GetConfig()
  51         if err != nil {
  52                 log.Fatalf("%v", err)
  53         }
  54
  55         if err := doMain(&cfg); err != nil {
  56                 log.Fatalf("%v", err)
  57         }
  58 }
  59
  60 type ConfigParams struct {
  61         Client             *arvados.Client
  62         ClusterID          string
  63         CurrentUser        arvados.User
  64         DeactivateUnlisted bool
  65         Path               string
  66         SysUserUUID        string
  67         AnonUserUUID       string
  68         Verbose            bool
  69 }
  70
  71 func ParseFlags(cfg *ConfigParams) error {
  72         flags := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
  73         flags.Usage = func() {
  74                 usageStr := `Synchronize remote users into Arvados from a CSV format file with 5 columns:
  75   * 1st: E-mail address
  76   * 2nd: First name
  77   * 3rd: Last name
  78   * 4th: Active status (0 or 1)
  79   * 5th: Admin status (0 or 1)`
  80                 fmt.Fprintf(flags.Output(), "%s\n\n", usageStr)
  81                 fmt.Fprintf(flags.Output(), "Usage:\n%s [OPTIONS] <input-file.csv>\n\n", os.Args[0])
  82                 fmt.Fprintf(flags.Output(), "Options:\n")
  83                 flags.PrintDefaults()
  84         }
  85
  86         deactivateUnlisted := flags.Bool(
  87                 "deactivate-unlisted",
  88                 false,
  89                 "Deactivate users that are not in the input file.")
  90         verbose := flags.Bool(
  91                 "verbose",
  92                 false,
  93                 "Log informational messages. Off by default.")
  94         getVersion := flags.Bool(
  95                 "version",
  96                 false,
  97                 "Print version information and exit.")
  98
  99         if ok, code := cmd.ParseFlags(flags, os.Args[0], os.Args[1:], "input-file.csv", os.Stderr); !ok {
 100                 os.Exit(code)
 101         } else if *getVersion {
 102                 fmt.Printf("%s %s\n", os.Args[0], version)
 103                 os.Exit(0)
 104         }
 105
 106         // Input file as a required positional argument
 107         if flags.NArg() == 0 {
 108                 return fmt.Errorf("please provide a path to an input file")
 109         }
 110         srcPath := &os.Args[flags.NFlag()+1]
 111
 112         // Validations
 113         if *srcPath == "" {
 114                 return fmt.Errorf("input file path invalid")
 115         }
 116
 117         cfg.DeactivateUnlisted = *deactivateUnlisted
 118         cfg.Path = *srcPath
 119         cfg.Verbose = *verbose
 120
 121         return nil
 122 }
 123
 124 // GetConfig sets up a ConfigParams struct
 125 func GetConfig() (cfg ConfigParams, err error) {
 126         err = ParseFlags(&cfg)
 127         if err != nil {
 128                 return
 129         }
 130
 131         cfg.Client = arvados.NewClientFromEnv()
 132
 133         // Check current user permissions
 134         u, err := cfg.Client.CurrentUser()
 135         if err != nil {
 136                 return cfg, fmt.Errorf("error getting the current user: %s", err)
 137         }
 138         if !u.IsAdmin {
 139                 return cfg, fmt.Errorf("current user %q is not an admin user", u.UUID)
 140         }
 141         if cfg.Verbose {
 142                 log.Printf("Running as admin user %q (%s)", u.Email, u.UUID)
 143         }
 144         cfg.CurrentUser = u
 145
 146         var ac struct {
 147                 ClusterID string
 148                 Login     struct {
 149                         LoginCluster string
 150                 }
 151         }
 152         err = cfg.Client.RequestAndDecode(&ac, "GET", "arvados/v1/config", nil, nil)
 153         if err != nil {
 154                 return cfg, fmt.Errorf("error getting the exported config: %s", err)
 155         }
 156         if ac.Login.LoginCluster != "" && ac.Login.LoginCluster != ac.ClusterID {
 157                 return cfg, fmt.Errorf("cannot run on a cluster other than the login cluster")
 158         }
 159         cfg.SysUserUUID = ac.ClusterID + "-tpzed-000000000000000"
 160         cfg.AnonUserUUID = ac.ClusterID + "-tpzed-anonymouspublic"
 161         cfg.ClusterID = ac.ClusterID
 162
 163         return cfg, nil
 164 }
 165
 166 func doMain(cfg *ConfigParams) error {
 167         // Try opening the input file early, just in case there's a problem.
 168         f, err := os.Open(cfg.Path)
 169         if err != nil {
 170                 return fmt.Errorf("error opening input file: %s", err)
 171         }
 172         defer f.Close()
 173
 174         allUsers := make(map[string]arvados.User)
 175         processedUsers := make(map[string]bool)
 176         results, err := GetAll(cfg.Client, "users", arvados.ResourceListParams{}, &UserList{})
 177         if err != nil {
 178                 return fmt.Errorf("error getting all users: %s", err)
 179         }
 180         log.Printf("Found %d users in cluster %q", len(results), cfg.ClusterID)
 181         for _, item := range results {
 182                 u := item.(arvados.User)
 183                 allUsers[strings.ToLower(u.Email)] = u
 184                 processedUsers[strings.ToLower(u.Email)] = false
 185         }
 186
 187         loadedRecords, err := LoadInputFile(f)
 188         if err != nil {
 189                 return fmt.Errorf("reading input file %q: %s", cfg.Path, err)
 190         }
 191         log.Printf("Loaded %d records from input file", len(loadedRecords))
 192
 193         updatesSucceeded, updatesFailed := 0, 0
 194         for _, record := range loadedRecords {
 195                 if record.Email == cfg.CurrentUser.Email {
 196                         log.Printf("Skipping current user %q from processing", record.Email)
 197                         continue
 198                 }
 199                 if updated, err := ProcessRecord(cfg, record, allUsers); err != nil {
 200                         log.Printf("error processing record %q: %s", record.Email, err)
 201                         updatesFailed++
 202                 } else if updated {
 203                         processedUsers[strings.ToLower(record.Email)] = true
 204                         updatesSucceeded++
 205                 }
 206         }
 207
 208         if cfg.DeactivateUnlisted {
 209                 for email, user := range allUsers {
 210                         switch user.UUID {
 211                         case cfg.SysUserUUID, cfg.AnonUserUUID:
 212                                 if cfg.Verbose {
 213                                         log.Printf("Skipping system user deactivation: %s", user.UUID)
 214                                 }
 215                                 continue
 216                         case cfg.CurrentUser.UUID:
 217                                 if cfg.Verbose {
 218                                         log.Printf("Skipping current user deactivation: %s (%s)", user.Email, user.UUID)
 219                                 }
 220                                 continue
 221                         }
 222                         if !processedUsers[email] && allUsers[email].IsActive {
 223                                 if cfg.Verbose {
 224                                         log.Printf("Deactivating unlisted user %q (%s)", user.Email, user.UUID)
 225                                 }
 226                                 var updatedUser arvados.User
 227                                 if err := UnsetupUser(cfg.Client, user.UUID, &updatedUser); err != nil {
 228                                         log.Printf("error deactivating unlisted user %q: %s", user.UUID, err)
 229                                         updatesFailed++
 230                                 } else {
 231                                         allUsers[email] = updatedUser
 232                                         updatesSucceeded++
 233                                 }
 234                         }
 235                 }
 236         }
 237
 238         log.Printf("Updated %d user(s), failed to update %d user(s)", updatesSucceeded, updatesFailed)
 239
 240         return nil
 241 }
 242
 243 type userRecord struct {
 244         Email     string
 245         FirstName string
 246         LastName  string
 247         Active    bool
 248         Admin     bool
 249 }
 250
 251 // ProcessRecord creates or updates a user based on the given record
 252 func ProcessRecord(cfg *ConfigParams, record userRecord, allUsers map[string]arvados.User) (bool, error) {
 253         if cfg.Verbose {
 254                 log.Printf("Processing record for user %q", record.Email)
 255         }
 256
 257         wantedActiveStatus := strconv.FormatBool(record.Active)
 258         wantedAdminStatus := strconv.FormatBool(record.Admin)
 259         createRequired := false
 260         updateRequired := false
 261         // Check if user exists, set its active & admin status.
 262         var user arvados.User
 263         user, ok := allUsers[record.Email]
 264         if !ok {
 265                 if cfg.Verbose {
 266                         log.Printf("User %q does not exist, creating", record.Email)
 267                 }
 268                 createRequired = true
 269                 err := CreateUser(cfg.Client, &user, map[string]string{
 270                         "email":      record.Email,
 271                         "first_name": record.FirstName,
 272                         "last_name":  record.LastName,
 273                         "is_active":  wantedActiveStatus,
 274                         "is_admin":   wantedAdminStatus,
 275                 })
 276                 if err != nil {
 277                         return false, fmt.Errorf("error creating user %q: %s", record.Email, err)
 278                 }
 279         }
 280         if record.Active != user.IsActive {
 281                 updateRequired = true
 282                 if record.Active {
 283                         if cfg.Verbose {
 284                                 log.Printf("User %q is inactive, activating", record.Email)
 285                         }
 286                         // Here we assume the 'setup' is done elsewhere if needed.
 287                         err := UpdateUser(cfg.Client, user.UUID, &user, map[string]string{
 288                                 "is_active": wantedActiveStatus,
 289                                 "is_admin":  wantedAdminStatus, // Just in case it needs to be changed.
 290                         })
 291                         if err != nil {
 292                                 return false, fmt.Errorf("error updating user %q: %s", record.Email, err)
 293                         }
 294                 } else {
 295                         if cfg.Verbose {
 296                                 log.Printf("User %q is active, deactivating", record.Email)
 297                         }
 298                         err := UnsetupUser(cfg.Client, user.UUID, &user)
 299                         if err != nil {
 300                                 return false, fmt.Errorf("error deactivating user %q: %s", record.Email, err)
 301                         }
 302                 }
 303         }
 304         // Inactive users cannot be admins.
 305         if user.IsActive && record.Admin != user.IsAdmin {
 306                 if cfg.Verbose {
 307                         log.Printf("User %q is active, changing admin status to %v", record.Email, record.Admin)
 308                 }
 309                 updateRequired = true
 310                 err := UpdateUser(cfg.Client, user.UUID, &user, map[string]string{
 311                         "is_admin": wantedAdminStatus,
 312                 })
 313                 if err != nil {
 314                         return false, fmt.Errorf("error updating user %q: %s", record.Email, err)
 315                 }
 316         }
 317         allUsers[record.Email] = user
 318         if createRequired {
 319                 log.Printf("Created user %q", record.Email)
 320         }
 321         if updateRequired {
 322                 log.Printf("Updated user %q", record.Email)
 323         }
 324
 325         return createRequired || updateRequired, nil
 326 }
 327
 328 // LoadInputFile reads the input file and returns a list of user records
 329 func LoadInputFile(f *os.File) (loadedRecords []userRecord, err error) {
 330         lineNo := 0
 331         csvReader := csv.NewReader(f)
 332         loadedRecords = make([]userRecord, 0)
 333
 334         for {
 335                 record, e := csvReader.Read()
 336                 if e == io.EOF {
 337                         break
 338                 }
 339                 lineNo++
 340                 if e != nil {
 341                         err = fmt.Errorf("parsing error at line %d: %s", lineNo, e)
 342                         return
 343                 }
 344                 if len(record) != 5 {
 345                         err = fmt.Errorf("parsing error at line %d: expected 5 fields, found %d", lineNo, len(record))
 346                         return
 347                 }
 348                 email := strings.ToLower(strings.TrimSpace(record[0]))
 349                 firstName := strings.TrimSpace(record[1])
 350                 lastName := strings.TrimSpace(record[2])
 351                 active := strings.TrimSpace(record[3])
 352                 admin := strings.TrimSpace(record[4])
 353                 if email == "" || firstName == "" || lastName == "" || active == "" || admin == "" {
 354                         err = fmt.Errorf("parsing error at line %d: fields cannot be empty", lineNo)
 355                         return
 356                 }
 357                 activeBool, err := strconv.ParseBool(active)
 358                 if err != nil {
 359                         return nil, fmt.Errorf("parsing error at line %d: active status not recognized", lineNo)
 360                 }
 361                 adminBool, err := strconv.ParseBool(admin)
 362                 if err != nil {
 363                         return nil, fmt.Errorf("parsing error at line %d: admin status not recognized", lineNo)
 364                 }
 365                 loadedRecords = append(loadedRecords, userRecord{
 366                         Email:     email,
 367                         FirstName: firstName,
 368                         LastName:  lastName,
 369                         Active:    activeBool,
 370                         Admin:     adminBool,
 371                 })
 372         }
 373         return loadedRecords, nil
 374 }
 375
 376 // GetAll adds all objects of type 'resource' to the 'allItems' list
 377 func GetAll(c *arvados.Client, res string, params arvados.ResourceListParams, page resourceList) (allItems []interface{}, err error) {
 378         // Use the maximum page size the server allows
 379         limit := 1<<31 - 1
 380         params.Limit = &limit
 381         params.Offset = 0
 382         params.Order = "uuid"
 383         for {
 384                 if err = GetResourceList(c, &page, res, params); err != nil {
 385                         return allItems, err
 386                 }
 387                 // Have we finished paging?
 388                 if page.Len() == 0 {
 389                         break
 390                 }
 391                 allItems = append(allItems, page.GetItems()...)
 392                 params.Offset += page.Len()
 393         }
 394         return allItems, nil
 395 }
 396
 397 func jsonReader(rscName string, ob interface{}) io.Reader {
 398         j, err := json.Marshal(ob)
 399         if err != nil {
 400                 panic(err)
 401         }
 402         v := url.Values{}
 403         v[rscName] = []string{string(j)}
 404         return bytes.NewBufferString(v.Encode())
 405 }
 406
 407 // GetResourceList fetches res list using params
 408 func GetResourceList(c *arvados.Client, dst *resourceList, res string, params interface{}) error {
 409         return c.RequestAndDecode(dst, "GET", "/arvados/v1/"+res, nil, params)
 410 }
 411
 412 // CreateUser creates a user with userData parameters, assigns it to dst
 413 func CreateUser(c *arvados.Client, dst *arvados.User, userData map[string]string) error {
 414         return c.RequestAndDecode(dst, "POST", "/arvados/v1/users", jsonReader("user", userData), nil)
 415 }
 416
 417 // UpdateUser updates a user with userData parameters
 418 func UpdateUser(c *arvados.Client, userUUID string, dst *arvados.User, userData map[string]string) error {
 419         return c.RequestAndDecode(&dst, "PUT", "/arvados/v1/users/"+userUUID, jsonReader("user", userData), nil)
 420 }
 421
 422 // UnsetupUser deactivates a user
 423 func UnsetupUser(c *arvados.Client, userUUID string, dst *arvados.User) error {
 424         return c.RequestAndDecode(&dst, "POST", "/arvados/v1/users/"+userUUID+"/unsetup", nil, nil)
 425 }