def iter_users(self, in_group=None):
users = {}
try:
if in_group:
u_query = umapi_client.UsersQuery(self.connection,
in_group=in_group)
else:
u_query = umapi_client.UsersQuery(self.connection)
for u in u_query:
email = u['email']
if not (email in users):
users[email] = u
yield u
except umapi_client.UnavailableError as e:
raise AssertionException("Error contacting UMAPI server: %s" % e)
def test_list_user_groups(config):
conn, params = config
groups = umapi_client.UserGroupsQuery(connection=conn)
group_count = 0
for group in groups:
name = group.get("name")
admin_name = group.get("adminGroupName")
member_count = group.get("userCount", 0)
admin_count = int(group.get("adminCount", "-1"))
logging.info("Group %s has %d members.", name, member_count)
if admin_name:
logging.info("Group %s has admin group %s with %d members.", name,
admin_name, admin_count)
# logging.info("Adding test user as admin.")
# user = umapi_client.UserAction(id_type=params["test_user"]["type"],
# email=params["test_user"]["email"],
# username=params["test_user"]["username"])
# user.add_to_groups([admin_name])
# assert (0, 1, 1) == conn.execute_single(user, immediate=True)
users = umapi_client.UsersQuery(connection=conn,
in_group=admin_name)
logging.info("Admin group %s has: %s", admin_name,
users.all_results())
assert member_count >= 0
group_count += 1
logging.info("Found %d groups.", group_count)
groups.reload()
group_count_2 = len(groups.all_results())
assert group_count == group_count_2
def iter_users(self):
users = {}
for u in umapi_client.UsersQuery(self.connection):
email = u['email']
if not (email in users):
users[email] = u
yield u
def iter_users(self):
users = {}
try:
for u in umapi_client.UsersQuery(self.connection):
email = u['email']
if not (email in users):
users[email] = u
yield u
except umapi_client.UnavailableError as e:
raise AssertionException("Error contacting UMAPI server: %s" % e)
def test_list_users(config):
conn, _ = config
users = umapi_client.UsersQuery(connection=conn, in_domain="")
user_count = 0
for user in users:
email = user.get("email", "")
if re.match(r".*@adobe.com$", str(email).lower()):
assert str(user["type"]) == "adobeID"
user_count += 1
if user_count >= 600:
logging.info("Quitting enumeration after 600 users.")
break
logging.info("Found %d users.", user_count)
def load_umapi_users(self, identity_type):
try:
u_query = umapi_client.UsersQuery(self.connection)
umapi_users = u_query.all_results()
if not identity_type == 'all':
umapi_users = list(filter(lambda usr: usr['type'] == identity_type, umapi_users))
self.umapi_users = umapi_users
for user in umapi_users:
# Generate unique user key because Username/Email is a bad unique identifier
user_key = self.generate_user_key(user['type'], user['username'], user['domain'])
self.user_by_usr_key[user_key] = self.convert_user(user)
except umapi_client.UnavailableError as e:
raise AssertionException("Error contacting UMAPI server: %s" % e)
def iter_users(self, in_group=None):
users = {}
total_count = 0
page_count = 0
page_size = 0
page_number = 0
try:
u_query = umapi_client.UsersQuery(self.connection, in_group=in_group)
for i, u in enumerate(u_query):
total_count, page_count, page_size, page_number = u_query.stats()
email = u['email']
if not (email in users):
users[email] = u
yield u
if (i + 1) % page_size == 0:
self.logger.progress(len(users), total_count)
self.logger.progress(total_count, total_count)
except umapi_client.UnavailableError as e:
raise AssertionException("Error contacting UMAPI server: %s" % e)
def scan_umapi(log: logging.Logger, options: Any, output_folder: Path) -> None:
"""
Call Adobe umapi and serialize results to compressed xml document
:param log:
:param options:
:param output_folder:
:return:
"""
scanned_groups = 0
scanned_users = 0
org_id = config['org_id']
# noinspection SpellCheckingInspection
ext = ".scaa"
output_file = output_folder.joinpath(options.uuid + ext)
start_time = time.time()
doc = Document()
xml = doc.createElement('octoscan')
xml.setAttribute("uuid", options.uuid)
xml.setAttribute("timestamp",
datetime.utcnow().replace(microsecond=0).isoformat())
xml.setAttribute("build", octoscan_build)
doc.appendChild(xml)
octoscan_config = doc.createElement('octoscan_config')
if len(options.tag) > 0:
append_info_element(doc, octoscan_config, 'tag', 'S', options.tag)
append_info_element(doc, octoscan_config, 'OutputFolder', 'S',
str(output_folder))
xml.appendChild(octoscan_config)
meta = doc.createElement('meta')
append_info_element(doc, meta, 'org_id', 'S', org_id)
append_info_element(doc, meta, 'tech_acct_id', 'S', config['tech_acct_id'])
xml.appendChild(meta)
conn = None
try:
conn = umapi_client.Connection(org_id=org_id, auth_dict=config)
except Exception as e:
log.exception(e)
if not conn:
log.error("Failed to connect to Adobe cloud")
groups = doc.createElement('groups')
umapi_groups = umapi_client.GroupsQuery(conn)
for umapi_group in umapi_groups:
g = doc.createElement('group')
g.setAttribute('name', umapi_group['groupName'])
append_dict(doc, g, umapi_group)
scanned_groups += 1
groups.appendChild(g)
xml.appendChild(groups)
users = doc.createElement('users')
umapi_users = umapi_client.UsersQuery(conn)
for umapi_user in umapi_users:
u = doc.createElement('user')
u.setAttribute('name', umapi_user['username'])
append_dict(doc, u, umapi_user)
scanned_users += 1
users.appendChild(u)
xml.appendChild(users)
end_time = time.time()
performance = doc.createElement('octoscan_performance')
append_info_element(doc, performance, 'seconds', 'I',
str(int(end_time - start_time)))
xml.appendChild(performance)
with gzip.open(output_file, 'w') as f_out:
f_out.write(doc.toprettyxml(indent="\t").encode('utf-8'))
print(output_file)
log.info(
f"Adobe umapi {scanned_users} users {scanned_groups} groups scanned output to {output_file}"
)
