# Licensed to the Apache Software Foundation (ASF) under one

# or more contributor license agreements. See the NOTICE file

# distributed with this work for additional information

# regarding copyright ownership. The ASF licenses this file

# to you under the Apache License, Version 2.0 (the

# "License"); you may not use this file except in compliance

# with the License. You may obtain a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing,

# software distributed under the License is distributed on an

# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

# KIND, either express or implied. See the License for the

# specific language governing permissions and limitations

# under the License.

import sys

import logging

from logging.handlers import RotatingFileHandler

import argparse

import time

import requests

import json

# Creates two organizations each with two apps each with three collections each with 100 entities

# Caller must provide a "slug" string which will be used as a prefix for all names

#

# For example, if the slug is mytest then:

#

# Orgs will be named mytest_org0 and mytest_org1

# Org admins will be named mytest_org0_admin and mytest_org1_admin (both with password test)

#

# Apps will be named mytest_org0_app0, mytest_org0_app1 and so on

# Collections will be named mytest_org0_app0_col0 and so on

# Entities will be named mytest_org0_app0_col0_entity and so on

#

# All entities in collection 0 will be connected to entities in collection 1.

# All entities in collection 1 will be connected to entities in collection 2.

def parse_args():

parser = argparse.ArgumentParser(description="Usergrid Test Data Creation Tool")

parser.add_argument("--endpoint",

help="The endpoint to use for making API requests.",

type=str,

default="http://localhost:8080")

parser.add_argument("--user",

help="Superuser credentials used to authenticate with Usergrid <user:pass>",

type=str,

required=True)

parser.add_argument("--slug",

help="Unique string to be used to name organization, applications and other things create",

type=str,

required=True)

my_args = parser.parse_args(sys.argv[1:])

arg_vars = vars(my_args)

creds = arg_vars["user"].split(":")

if len(creds) != 2:

print("Credentials not properly specified. Must be '--user <user:pass>'. Exiting...")

exit_on_error()

else:

arg_vars["user"] = creds[0]

arg_vars["pass"] = creds[1]

return arg_vars

class Creator:

def __init__(self):

self.args = parse_args()

self.endpoint = self.args["endpoint"]

self.logger = init_logging(self.__class__.__name__)

self.admin_user = self.args["user"]

self.admin_pass = self.args["pass"]

self.slug = self.args["slug"]

def run(self):

self.logger.info("Initializing...")

if not self.is_endpoint_available():

exit_on_error("Endpoint is not available, aborting")

for orgIndex in range(2):

orgName = self.slug + "_org" + str(orgIndex)

orgUser = orgName + "_admin"

orgEmail = orgUser + "@example.com"

url = self.endpoint + "/management/orgs"

body = json.dumps({"username":orgUser, "email":orgEmail, "password":"test", "organization":orgName })

r = requests.post(url=url, data=body, auth=(self.admin_user, self.admin_pass))

if ( r.status_code >= 400 ):

print "Error creating organization " + orgName + ": " + r.text

return

print "Created org " + orgName

url = self.endpoint + "/management/token"

body = json.dumps({"grant_type":"password","username":orgUser,"password":"test"})

r = requests.post(url=url, data=body)

if ( r.status_code != 200 ):

print "Error logging into organization " + orgName + ": " + r.text

return

accessToken = r.json()["access_token"]

for appIndex in range(2):

appName = orgName + "_app" + str(appIndex)

url = self.endpoint + "/management/orgs/" + orgName + "/apps?access_token=" + accessToken

body = json.dumps({"name":appName})

r = requests.post(url=url, data=body, auth=(self.admin_user, self.admin_pass))

if ( r.status_code >= 400 ):

print "Error creating application" + appName + ": " + r.text

return

print " Created app: " + orgName + "/" + appName

appUrl = self.endpoint + "/" + orgName + "/" + appName

time.sleep(2)

for userIndex in range(2):

userName = appName + "_user" + str(userIndex)

email = userName + "@example.com"

url = appUrl + "/users?access_token=" + accessToken

body = json.dumps({"name":userName, "username":userName, "email":email, "password":"test"})

r = requests.post(url=url, data=body)

if ( r.status_code >= 400 ):

print "Error creating user " + userName + ": " + r.text

return

for colIndex in range(3):

colName = appName + "_col" + str(colIndex)

print " Creating collection: " + colName

for entityIndex in range(100):

entityName = colName + "_entity" + str(entityIndex)

url = appUrl + "/" + colName + "s?access_token=" + accessToken

body = json.dumps({"name":entityName})

r = requests.post(url=url, data=body)

if ( r.status_code >= 400 ):

print "Error creating entity" + userName + ": " + r.text

retur

# connect entities in collection 0 to collection 1

for entityIndex in range(100):

sourceCollection = appName + "_col0s"

sourceName = appName + "_col0_entity" + str(entityIndex)

targetName = appName + "_col1_entity" + str(entityIndex)

targetType = appName + "_col1"

url = appUrl + "/" + sourceCollection + "/" + sourceName + "/has/" + targetType + "/" + targetName

r = requests.post(url=url + "?access_token=" + accessToken)

r = requests.post(url=url + "?access_token=" + accessToken)

r = requests.post(url=url + "?access_token=" + accessToken)

if ( r.status_code >= 400 ):

print "Error connecting entity " + sourceName + " to " + targetName + ": " + r.text

print "url is: " + url

return

# connect entities in collection 1 to collection 2

for entityIndex in range(100):

sourceCollection = appName + "_col1s"

sourceName = appName + "_col1_entity" + str(entityIndex)

targetName = appName + "_col2_entity" + str(entityIndex)

targetType = appName + "_col2"

url = appUrl + "/" + sourceCollection + "/" + sourceName + "/has/" + targetType + "/" + targetName

r = requests.post(url=url + "?access_token=" + accessToken)

r = requests.post(url=url + "?access_token=" + accessToken)

r = requests.post(url=url + "?access_token=" + accessToken)

if ( r.status_code >= 400 ):

print "Error connecting entity " + sourceName + " to " + targetName + ": " + r.text

print "url is: " + url

return

def is_endpoint_available(self):

try:

r = requests.get(url=self.endpoint+"/status")

if r.status_code == 200:

return True

except requests.exceptions.RequestException as e:

self.logger.error("Endpoint is unavailable, %s", str(e))

return False

def exit_on_error(e=""):

print ("Exiting script due to error: " + str(e))

sys.exit(1)

def init_logging(name):

logger = logging.getLogger(name)

log_file_name = "./create-test-data.log"

log_formatter = logging.Formatter(fmt="%(asctime)s [%(name)s] %(levelname)s %(message)s",

datefmt="%Y-%m-%d %H:%M:%S")

rotating_file = logging.handlers.RotatingFileHandler(filename=log_file_name,

mode="a",

maxBytes=104857600,

backupCount=10)

rotating_file.setFormatter(log_formatter)

rotating_file.setLevel(logging.INFO)

logger.addHandler(rotating_file)

logger.setLevel(logging.INFO)

stdout_logger = logging.StreamHandler(sys.stdout)

stdout_logger.setFormatter(log_formatter)

stdout_logger.setLevel(logging.INFO)

logger.addHandler(stdout_logger)

return logger

if __name__ == "__main__":

creator = Creator()

creator.run()