lib/controller/federation/generated.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package federation
   6
   7 import (
   8         "context"
   9         "sort"
  10         "sync"
  11         "sync/atomic"
  12
  13         "git.arvados.org/arvados.git/sdk/go/arvados"
  14 )
  15
  16 //
  17 // -- this file is auto-generated -- do not edit -- edit list.go and run "go generate" instead --
  18 //
  19
  20 func (conn *Conn) generated_AuthorizedKeyList(ctx context.Context, options arvados.ListOptions) (arvados.AuthorizedKeyList, error) {
  21         var mtx sync.Mutex
  22         var merged arvados.AuthorizedKeyList
  23         var needSort atomic.Value
  24         needSort.Store(false)
  25         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
  26                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
  27                 cl, err := backend.AuthorizedKeyList(ctx, options)
  28                 if err != nil {
  29                         return nil, err
  30                 }
  31                 mtx.Lock()
  32                 defer mtx.Unlock()
  33                 if len(merged.Items) == 0 {
  34                         merged = cl
  35                 } else if len(cl.Items) > 0 {
  36                         merged.Items = append(merged.Items, cl.Items...)
  37                         needSort.Store(true)
  38                 }
  39                 uuids := make([]string, 0, len(cl.Items))
  40                 for _, item := range cl.Items {
  41                         uuids = append(uuids, item.UUID)
  42                 }
  43                 return uuids, nil
  44         })
  45         if needSort.Load().(bool) {
  46                 // Apply the default/implied order, "modified_at desc"
  47                 sort.Slice(merged.Items, func(i, j int) bool {
  48                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
  49                         return mj.Before(mi)
  50                 })
  51         }
  52         if merged.Items == nil {
  53                 // Return empty results as [], not null
  54                 // (https://github.com/golang/go/issues/27589 might be
  55                 // a better solution in the future)
  56                 merged.Items = []arvados.AuthorizedKey{}
  57         }
  58         return merged, err
  59 }
  60
  61 func (conn *Conn) generated_ContainerList(ctx context.Context, options arvados.ListOptions) (arvados.ContainerList, error) {
  62         var mtx sync.Mutex
  63         var merged arvados.ContainerList
  64         var needSort atomic.Value
  65         needSort.Store(false)
  66         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
  67                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
  68                 cl, err := backend.ContainerList(ctx, options)
  69                 if err != nil {
  70                         return nil, err
  71                 }
  72                 mtx.Lock()
  73                 defer mtx.Unlock()
  74                 if len(merged.Items) == 0 {
  75                         merged = cl
  76                 } else if len(cl.Items) > 0 {
  77                         merged.Items = append(merged.Items, cl.Items...)
  78                         needSort.Store(true)
  79                 }
  80                 uuids := make([]string, 0, len(cl.Items))
  81                 for _, item := range cl.Items {
  82                         uuids = append(uuids, item.UUID)
  83                 }
  84                 return uuids, nil
  85         })
  86         if needSort.Load().(bool) {
  87                 // Apply the default/implied order, "modified_at desc"
  88                 sort.Slice(merged.Items, func(i, j int) bool {
  89                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
  90                         return mj.Before(mi)
  91                 })
  92         }
  93         if merged.Items == nil {
  94                 // Return empty results as [], not null
  95                 // (https://github.com/golang/go/issues/27589 might be
  96                 // a better solution in the future)
  97                 merged.Items = []arvados.Container{}
  98         }
  99         return merged, err
 100 }
 101
 102 func (conn *Conn) generated_ContainerRequestList(ctx context.Context, options arvados.ListOptions) (arvados.ContainerRequestList, error) {
 103         var mtx sync.Mutex
 104         var merged arvados.ContainerRequestList
 105         var needSort atomic.Value
 106         needSort.Store(false)
 107         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
 108                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
 109                 cl, err := backend.ContainerRequestList(ctx, options)
 110                 if err != nil {
 111                         return nil, err
 112                 }
 113                 mtx.Lock()
 114                 defer mtx.Unlock()
 115                 if len(merged.Items) == 0 {
 116                         merged = cl
 117                 } else if len(cl.Items) > 0 {
 118                         merged.Items = append(merged.Items, cl.Items...)
 119                         needSort.Store(true)
 120                 }
 121                 uuids := make([]string, 0, len(cl.Items))
 122                 for _, item := range cl.Items {
 123                         uuids = append(uuids, item.UUID)
 124                 }
 125                 return uuids, nil
 126         })
 127         if needSort.Load().(bool) {
 128                 // Apply the default/implied order, "modified_at desc"
 129                 sort.Slice(merged.Items, func(i, j int) bool {
 130                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
 131                         return mj.Before(mi)
 132                 })
 133         }
 134         if merged.Items == nil {
 135                 // Return empty results as [], not null
 136                 // (https://github.com/golang/go/issues/27589 might be
 137                 // a better solution in the future)
 138                 merged.Items = []arvados.ContainerRequest{}
 139         }
 140         return merged, err
 141 }
 142
 143 func (conn *Conn) generated_GroupList(ctx context.Context, options arvados.ListOptions) (arvados.GroupList, error) {
 144         var mtx sync.Mutex
 145         var merged arvados.GroupList
 146         var needSort atomic.Value
 147         needSort.Store(false)
 148         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
 149                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
 150                 cl, err := backend.GroupList(ctx, options)
 151                 if err != nil {
 152                         return nil, err
 153                 }
 154                 mtx.Lock()
 155                 defer mtx.Unlock()
 156                 if len(merged.Items) == 0 {
 157                         merged = cl
 158                 } else if len(cl.Items) > 0 {
 159                         merged.Items = append(merged.Items, cl.Items...)
 160                         needSort.Store(true)
 161                 }
 162                 uuids := make([]string, 0, len(cl.Items))
 163                 for _, item := range cl.Items {
 164                         uuids = append(uuids, item.UUID)
 165                 }
 166                 return uuids, nil
 167         })
 168         if needSort.Load().(bool) {
 169                 // Apply the default/implied order, "modified_at desc"
 170                 sort.Slice(merged.Items, func(i, j int) bool {
 171                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
 172                         return mj.Before(mi)
 173                 })
 174         }
 175         if merged.Items == nil {
 176                 // Return empty results as [], not null
 177                 // (https://github.com/golang/go/issues/27589 might be
 178                 // a better solution in the future)
 179                 merged.Items = []arvados.Group{}
 180         }
 181         return merged, err
 182 }
 183
 184 func (conn *Conn) generated_UserList(ctx context.Context, options arvados.ListOptions) (arvados.UserList, error) {
 185         var mtx sync.Mutex
 186         var merged arvados.UserList
 187         var needSort atomic.Value
 188         needSort.Store(false)
 189         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
 190                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
 191                 cl, err := backend.UserList(ctx, options)
 192                 if err != nil {
 193                         return nil, err
 194                 }
 195                 mtx.Lock()
 196                 defer mtx.Unlock()
 197                 if len(merged.Items) == 0 {
 198                         merged = cl
 199                 } else if len(cl.Items) > 0 {
 200                         merged.Items = append(merged.Items, cl.Items...)
 201                         needSort.Store(true)
 202                 }
 203                 uuids := make([]string, 0, len(cl.Items))
 204                 for _, item := range cl.Items {
 205                         uuids = append(uuids, item.UUID)
 206                 }
 207                 return uuids, nil
 208         })
 209         if needSort.Load().(bool) {
 210                 // Apply the default/implied order, "modified_at desc"
 211                 sort.Slice(merged.Items, func(i, j int) bool {
 212                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
 213                         return mj.Before(mi)
 214                 })
 215         }
 216         if merged.Items == nil {
 217                 // Return empty results as [], not null
 218                 // (https://github.com/golang/go/issues/27589 might be
 219                 // a better solution in the future)
 220                 merged.Items = []arvados.User{}
 221         }
 222         return merged, err
 223 }
 224
 225 func (conn *Conn) generated_LinkList(ctx context.Context, options arvados.ListOptions) (arvados.LinkList, error) {
 226         var mtx sync.Mutex
 227         var merged arvados.LinkList
 228         var needSort atomic.Value
 229         needSort.Store(false)
 230         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
 231                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
 232                 cl, err := backend.LinkList(ctx, options)
 233                 if err != nil {
 234                         return nil, err
 235                 }
 236                 mtx.Lock()
 237                 defer mtx.Unlock()
 238                 if len(merged.Items) == 0 {
 239                         merged = cl
 240                 } else if len(cl.Items) > 0 {
 241                         merged.Items = append(merged.Items, cl.Items...)
 242                         needSort.Store(true)
 243                 }
 244                 uuids := make([]string, 0, len(cl.Items))
 245                 for _, item := range cl.Items {
 246                         uuids = append(uuids, item.UUID)
 247                 }
 248                 return uuids, nil
 249         })
 250         if needSort.Load().(bool) {
 251                 // Apply the default/implied order, "modified_at desc"
 252                 sort.Slice(merged.Items, func(i, j int) bool {
 253                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
 254                         return mj.Before(mi)
 255                 })
 256         }
 257         if merged.Items == nil {
 258                 // Return empty results as [], not null
 259                 // (https://github.com/golang/go/issues/27589 might be
 260                 // a better solution in the future)
 261                 merged.Items = []arvados.Link{}
 262         }
 263         return merged, err
 264 }
 265
 266 func (conn *Conn) generated_LogList(ctx context.Context, options arvados.ListOptions) (arvados.LogList, error) {
 267         var mtx sync.Mutex
 268         var merged arvados.LogList
 269         var needSort atomic.Value
 270         needSort.Store(false)
 271         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
 272                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
 273                 cl, err := backend.LogList(ctx, options)
 274                 if err != nil {
 275                         return nil, err
 276                 }
 277                 mtx.Lock()
 278                 defer mtx.Unlock()
 279                 if len(merged.Items) == 0 {
 280                         merged = cl
 281                 } else if len(cl.Items) > 0 {
 282                         merged.Items = append(merged.Items, cl.Items...)
 283                         needSort.Store(true)
 284                 }
 285                 uuids := make([]string, 0, len(cl.Items))
 286                 for _, item := range cl.Items {
 287                         uuids = append(uuids, item.UUID)
 288                 }
 289                 return uuids, nil
 290         })
 291         if needSort.Load().(bool) {
 292                 // Apply the default/implied order, "modified_at desc"
 293                 sort.Slice(merged.Items, func(i, j int) bool {
 294                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
 295                         return mj.Before(mi)
 296                 })
 297         }
 298         if merged.Items == nil {
 299                 // Return empty results as [], not null
 300                 // (https://github.com/golang/go/issues/27589 might be
 301                 // a better solution in the future)
 302                 merged.Items = []arvados.Log{}
 303         }
 304         return merged, err
 305 }
 306
 307 func (conn *Conn) generated_APIClientAuthorizationList(ctx context.Context, options arvados.ListOptions) (arvados.APIClientAuthorizationList, error) {
 308         var mtx sync.Mutex
 309         var merged arvados.APIClientAuthorizationList
 310         var needSort atomic.Value
 311         needSort.Store(false)
 312         err := conn.splitListRequest(ctx, options, func(ctx context.Context, _ string, backend arvados.API, options arvados.ListOptions) ([]string, error) {
 313                 options.ForwardedFor = conn.cluster.ClusterID + "-" + options.ForwardedFor
 314                 cl, err := backend.APIClientAuthorizationList(ctx, options)
 315                 if err != nil {
 316                         return nil, err
 317                 }
 318                 mtx.Lock()
 319                 defer mtx.Unlock()
 320                 if len(merged.Items) == 0 {
 321                         merged = cl
 322                 } else if len(cl.Items) > 0 {
 323                         merged.Items = append(merged.Items, cl.Items...)
 324                         needSort.Store(true)
 325                 }
 326                 uuids := make([]string, 0, len(cl.Items))
 327                 for _, item := range cl.Items {
 328                         uuids = append(uuids, item.UUID)
 329                 }
 330                 return uuids, nil
 331         })
 332         if needSort.Load().(bool) {
 333                 // Apply the default/implied order, "modified_at desc"
 334                 sort.Slice(merged.Items, func(i, j int) bool {
 335                         mi, mj := merged.Items[i].ModifiedAt, merged.Items[j].ModifiedAt
 336                         return mj.Before(mi)
 337                 })
 338         }
 339         if merged.Items == nil {
 340                 // Return empty results as [], not null
 341                 // (https://github.com/golang/go/issues/27589 might be
 342                 // a better solution in the future)
 343                 merged.Items = []arvados.APIClientAuthorization{}
 344         }
 345         return merged, err
 346 }