sdk/python/tests/fed-migrate/create_users.py

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: Apache-2.0
   4
   5 import arvados
   6 import json
   7 import sys
   8
   9 j = json.load(open(sys.argv[1]))
  10
  11 apiA = arvados.api(host=j["arvados_api_hosts"][0], token=j["superuser_tokens"][0], insecure=True)
  12 apiB = arvados.api(host=j["arvados_api_hosts"][1], token=j["superuser_tokens"][1], insecure=True)
  13 apiC = arvados.api(host=j["arvados_api_hosts"][2], token=j["superuser_tokens"][2], insecure=True)
  14
  15 def maketoken(newtok):
  16     return 'v2/' + newtok["uuid"] + '/' + newtok["api_token"]
  17
  18 def get_user_data(case_nr, is_active=True):
  19     return {
  20         "email": "case{}@test".format(case_nr),
  21         "first_name": "Case{}".format(case_nr),
  22         "last_name": "Testuser",
  23         "is_active": is_active
  24     }
  25
  26 # case 1
  27 # user only exists on cluster A
  28 apiA.users().create(body={"user": get_user_data(case_nr=1)}).execute()
  29
  30 # case 2
  31 # user exists on cluster A and has remotes on B and C
  32 case2 = apiA.users().create(body={"user": get_user_data(case_nr=2)}).execute()
  33 newtok = apiA.api_client_authorizations().create(body={
  34     "api_client_authorization": {'owner_uuid': case2["uuid"]}}).execute()
  35 arvados.api(host=j["arvados_api_hosts"][1], token=maketoken(newtok), insecure=True).users().current().execute()
  36 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtok), insecure=True).users().current().execute()
  37
  38 # case 3
  39 # user only exists on cluster B
  40 case3 = apiB.users().create(body={"user": get_user_data(case_nr=3)}).execute()
  41
  42 # case 4
  43 # user only exists on cluster B and has remotes on A and C
  44 case4 = apiB.users().create(body={"user": get_user_data(case_nr=4)}).execute()
  45 newtok = apiB.api_client_authorizations().create(body={
  46     "api_client_authorization": {'owner_uuid': case4["uuid"]}}).execute()
  47 arvados.api(host=j["arvados_api_hosts"][0], token=maketoken(newtok), insecure=True).users().current().execute()
  48 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtok), insecure=True).users().current().execute()
  49
  50
  51 # case 5
  52 # user exists on both cluster A and B
  53 case5 = apiA.users().create(body={"user": get_user_data(case_nr=5)}).execute()
  54 case5 = apiB.users().create(body={"user": get_user_data(case_nr=5)}).execute()
  55
  56 # case 6
  57 # user exists on both cluster A and B, with remotes on A, B and C
  58 case6_A = apiA.users().create(body={"user": get_user_data(case_nr=6)}).execute()
  59 newtokA = apiA.api_client_authorizations().create(body={
  60     "api_client_authorization": {'owner_uuid': case6_A["uuid"]}}).execute()
  61 arvados.api(host=j["arvados_api_hosts"][1], token=maketoken(newtokA), insecure=True).users().current().execute()
  62 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtokA), insecure=True).users().current().execute()
  63
  64 case6_B = apiB.users().create(body={"user": get_user_data(case_nr=6)}).execute()
  65 newtokB = apiB.api_client_authorizations().create(body={
  66     "api_client_authorization": {'owner_uuid': case6_B["uuid"]}}).execute()
  67 arvados.api(host=j["arvados_api_hosts"][0], token=maketoken(newtokB), insecure=True).users().current().execute()
  68 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtokB), insecure=True).users().current().execute()
  69
  70 # case 7
  71 # user exists on both cluster B and A, with remotes on A, B and C
  72 case7_B = apiB.users().create(body={"user": get_user_data(case_nr=7)}).execute()
  73 newtokB = apiB.api_client_authorizations().create(body={
  74     "api_client_authorization": {'owner_uuid': case7_B["uuid"]}}).execute()
  75 arvados.api(host=j["arvados_api_hosts"][0], token=maketoken(newtokB), insecure=True).users().current().execute()
  76 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtokB), insecure=True).users().current().execute()
  77
  78 case7_A = apiA.users().create(body={"user": get_user_data(case_nr=7)}).execute()
  79 newtokA = apiA.api_client_authorizations().create(body={
  80     "api_client_authorization": {'owner_uuid': case7_A["uuid"]}}).execute()
  81 arvados.api(host=j["arvados_api_hosts"][1], token=maketoken(newtokA), insecure=True).users().current().execute()
  82 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtokA), insecure=True).users().current().execute()
  83
  84 # case 8
  85 # user exists on both cluster B and C, with remotes on A, B and C
  86 case8_B = apiB.users().create(body={"user": get_user_data(case_nr=8)}).execute()
  87 newtokB = apiB.api_client_authorizations().create(body={
  88     "api_client_authorization": {'owner_uuid': case8_B["uuid"]}}).execute()
  89 arvados.api(host=j["arvados_api_hosts"][0], token=maketoken(newtokB), insecure=True).users().current().execute()
  90 arvados.api(host=j["arvados_api_hosts"][2], token=maketoken(newtokB), insecure=True).users().current().execute()
  91
  92 case8_C = apiC.users().create(body={"user": get_user_data(case_nr=8)}).execute()
  93 newtokC = apiC.api_client_authorizations().create(body={
  94     "api_client_authorization": {'owner_uuid': case8_C["uuid"]}}).execute()
  95 arvados.api(host=j["arvados_api_hosts"][0], token=maketoken(newtokC), insecure=True).users().current().execute()
  96 arvados.api(host=j["arvados_api_hosts"][1], token=maketoken(newtokC), insecure=True).users().current().execute()
  97
  98 # case 9
  99 # user only exists on cluster B, but is inactive
 100 case9 = apiB.users().create(body={"user": get_user_data(case_nr=9, is_active=False)}).execute()