def client(): url = 'http://localhost:8088/v1-catalog/schemas' catalogs = cattle.from_env(url=url, headers=DEFAULT_HEADERS).list_catalog() wait_for( lambda: len(catalogs) > 0 ) return cattle.from_env(url=url, headers=DEFAULT_HEADERS)
def client(): url = 'http://localhost:8088/v1-catalog/schemas' templates = cattle.from_env(url=url).list_template(catalogId='qa-catalog') wait_for( lambda: len(templates) > 0 ) return cattle.from_env(url=url)
def _get_super_client(request): global _SUPER_CLIENT if _SUPER_CLIENT is not None: return _SUPER_CLIENT l = open('/tmp/cattle-api.lock', 'w') fcntl.flock(l, fcntl.LOCK_EX) client = cattle.from_env(url=cattle_url(), cache=False, access_key='superadmin', secret_key='superadminpass') if _is_valid_super_client(client): _SUPER_CLIENT = client if request is not None: request.addfinalizer( lambda: delete_sim_instances(client)) fcntl.flock(l, fcntl.LOCK_UN) return client super_admin = find_one(client.list_account, name='superadmin') super_admin = activate_resource(client, super_admin) creds = client.list_api_key(_role='superadmin', accountId=super_admin.id) cred = None for i in creds: if i.removed is None: cred = i break if cred is None: cred = client.create_api_key(_role='superadmin', accountId=super_admin.id, publicValue='superadmin', secretValue='superadminpass') client.wait_success(cred) fcntl.flock(l, fcntl.LOCK_UN) client = cattle.from_env(url=cattle_url(), cache=False, access_key=cred.publicValue, secret_key=cred.secretValue) assert _is_valid_super_client(client) _SUPER_CLIENT = client if request is not None: request.addfinalizer( lambda: delete_sim_instances(client)) return client
def controller_client(request): url = 'http://localhost:9501/v1/schemas' c = cattle.from_env(url=url) request.addfinalizer(lambda: cleanup_controller(c)) c = cleanup_controller(c) assert c.list_volume()[0].replicaCount == 0 return c
def make_user_and_client(admin_user_client, name_base='user '): account = admin_user_client.create_account(name=name_base + random_str(), kind="user") admin_user_client.wait_success(account) username = name_base + random_str() password = '******' + random_str() login = admin_user_client.create_password(publicValue=username, secretValue=password, accountId=account.id) admin_user_client.wait_success(login) key = admin_user_client.create_apiKey() admin_user_client.wait_success(key) start_client = from_env(url=cattle_url(), access_key=key.publicValue, secret_key=key.secretValue) token = requests.post(base_url() + 'token', {'code': username + ':' + password}) token = token.json() assert token['type'] != 'error' token = token['jwt'] start_client._auth = LocalAuth(token) start_client.valid() identities = start_client.list_identity() assert len(identities) == 1 assert identities[0].externalId == account.id return start_client, account, username, password
def _admin_client(): access_key = os.environ.get("CATTLE_ACCESS_KEY", 'admin') secret_key = os.environ.get("CATTLE_SECRET_KEY", 'adminpass') return from_env(url=cattle_url(), cache=False, access_key=access_key, secret_key=secret_key)
def create_catalog(name, url, branch=None, headers=DEFAULT_HEADERS): schemas_url = 'http://localhost:8088/v1-catalog/schemas' client = cattle.from_env(url=schemas_url, headers=headers) original_catalogs = client.list_catalog() assert len(original_catalogs) > 0 original_templates = client.list_template() assert len(original_templates) > 0 data = { 'name': name, 'url': url, } if branch: data['branch'] = branch api_url = 'http://localhost:8088/v1-catalog/catalogs' response = requests.post(api_url, data=json.dumps(data), headers=headers) assert response.status_code == 200 resp = response.json() assert resp['name'] == name assert resp['url'] == url if branch: assert resp['branch'] == branch api_url = 'http://localhost:8088/v1-catalog/templates?action=refresh' response = requests.post(api_url, headers=headers) assert response.status_code == 204 templates = client.list_template() catalogs = client.list_catalog() assert len(catalogs) == len(original_catalogs) + 1 assert len(templates) > len(original_templates) return resp
def make_client(admin_user_client, account, username, password): key = admin_user_client.create_apiKey() admin_user_client.wait_success(key) start_client = from_env(url=cattle_url(), access_key=key.publicValue, secret_key=key.secretValue) token = requests.post(base_url() + 'token', { 'code': username + ':' + password }) token = token.json() assert token['type'] != 'error' jwt = token['jwt'] user = token['userIdentity'] assert user['login'] == username start_client._auth = LocalAuth(jwt) start_client.valid() identities = start_client.list_identity() assert len(identities) == 1 assert identities[0].externalId == account.id return start_client
def test_account_delete(super_client, random_str, admin_client): cred = create_user(admin_client, random_str, kind='user') test_user_client = from_env(url=cattle_url(), cache=False, access_key=cred[0], secret_key=cred[1]) user_account = cred[2] sim_context = create_sim_context(super_client, random_str, ip='192.168.11.6', account=user_account) host = super_client.wait_success(sim_context['host']) assert host.state == 'active' assert host.accountId == user_account.id account = test_user_client.wait_success(user_account.deactivate()) account = test_user_client.delete(account) account = test_user_client.wait_success(account) account = test_user_client.wait_success(account.purge()) host = admin_client.wait_success(sim_context["host"]) assert host.state == 'removed'
def create_images(): client = from_env() for name, base in URLS.items(): version, hash, url = get_version(base) if url is not None: save_image(client, name, version, hash, url)
def controller_no_frontend_client(request): url = CONTROLLER_NO_FRONTEND_SCHEMA c = cattle.from_env(url=url) request.addfinalizer(lambda: cleanup_controller(c)) c = cleanup_controller(c) assert c.list_volume()[0].replicaCount == 0 return c
def client_for_project(project): access_key = random_str() secret_key = random_str() admin_client = _admin_client() active_cred = None account = project for cred in account.credentials(): if cred.kind == 'apiKey' and cred.publicValue == access_key: active_cred = cred break if active_cred is None: active_cred = admin_client.create_api_key({ 'accountId': account.id, 'publicValue': access_key, 'secretValue': secret_key }) active_cred = wait_success(admin_client, active_cred) if active_cred.state != 'active': wait_success(admin_client, active_cred.activate()) return from_env(url=cattle_url(), cache=False, access_key=access_key, secret_key=secret_key)
def client_for_project(project): access_key = random_str() secret_key = random_str() admin_client = _admin_client() active_cred = None account = project for cred in account.credentials(): if cred.kind == 'apiKey' and cred.publicValue == access_key\ and cred.secretValue == secret_key: active_cred = cred break if active_cred is None: active_cred = admin_client.create_api_key({ 'accountId': account.id, 'publicValue': access_key, 'secretValue': secret_key }) active_cred = wait_success(admin_client, active_cred) if active_cred.state != 'active': wait_success(admin_client, active_cred.activate()) return cattle.from_env(url=cattle_url(), cache=False, access_key=access_key, secret_key=secret_key)
def make_user_and_client(admin_user_client, name_base="user "): account = admin_user_client.create_account(name=name_base + random_str(), kind="user") admin_user_client.wait_success(account) username = name_base + random_str() password = "******" + random_str() login = admin_user_client.create_password(publicValue=username, secretValue=password, accountId=account.id) admin_user_client.wait_success(login) key = admin_user_client.create_apiKey() admin_user_client.wait_success(key) start_client = from_env(url=cattle_url(), access_key=key.publicValue, secret_key=key.secretValue) token = requests.post(base_url() + "token", {"code": username + ":" + password}) token = token.json() assert token["type"] != "error" token = token["jwt"] start_client._auth = LocalAuth(token) start_client.valid() identities = start_client.list_identity() assert len(identities) == 1 assert identities[0].externalId == account.id return start_client, account, username, password
def client(admin_user_client, request): try: return cattle.from_env(url=os.environ['RANCHER_URL'], access_key=os.environ['RANCHER_ACCESS_KEY'], secret_key=os.environ['RANCHER_SECRET_KEY']) except KeyError: pass try: config = ConfigParser.ConfigParser() config.read(path.join(_base(), '../../tox.ini')) return cattle.from_env(url=config.get('rancher', 'url'), access_key=config.get('rancher', 'access-key'), secret_key=config.get('rancher', 'secret-key')) except ConfigParser.NoOptionError: pass return new_context(admin_user_client, request).client
def setup_data(): client = from_env() registration_url(client) data = first(client.list_data(name=DATA_NAME)) if data is None or data.value != str(DATA_VERSION): defaults(client) if data is None: client.create_data(name=DATA_NAME, value=DATA_VERSION) else: client.update(data, value=DATA_VERSION) print 'Done with data version', DATA_VERSION
def delete_catalog(name, headers=DEFAULT_HEADERS): schemas_url = 'http://localhost:8088/v1-catalog/schemas' client = cattle.from_env(url=schemas_url, headers=headers) original_catalogs = client.list_catalog() assert len(original_catalogs) > 0 original_templates = client.list_template() assert len(original_templates) > 0 url = 'http://localhost:8088/v1-catalog/catalogs/' + name response = requests.delete(url, headers=headers) assert response.status_code == 204 templates = client.list_template() catalogs = client.list_catalog() assert len(catalogs) == len(original_catalogs) - 1 assert len(templates) < len(original_templates)
def create_duplicate_catalog(name, url, branch=None, headers=DEFAULT_HEADERS): schemas_url = 'http://localhost:8088/v1-catalog/schemas' client = cattle.from_env(url=schemas_url, headers=headers) original_catalogs = client.list_catalog() assert len(original_catalogs) > 0 original_templates = client.list_template() assert len(original_templates) > 0 data = { 'name': name, 'url': url, } if branch: data['branch'] = branch api_url = 'http://localhost:8088/v1-catalog/catalogs' response = requests.post(api_url, data=json.dumps(data), headers=headers) assert response.status_code == 422
def make_client(admin_user_client, account, username, password): key = admin_user_client.create_apiKey() admin_user_client.wait_success(key) start_client = from_env(url=cattle_url(), access_key=key.publicValue, secret_key=key.secretValue) token = requests.post(base_url() + 'token', { 'code': username + ':' + password }) token = token.json() assert token['type'] != 'error' jwt = token['jwt'] user = token['userIdentity'] assert user['login'] == username assert token['user'] == username start_client._auth = LocalAuth(jwt) start_client._access_key = None start_client._secret_key = None start_client.reload_schema() start_client.valid() identities = start_client.list_identity() assert len(identities) == 1 assert identities[0].externalId == account.id assert identities[0].login == username projects = start_client.list_project() assert len(projects) == 1 members = projects[0].projectMembers() assert len(members) == 1 member = get_plain_member(members[0]) assert member['externalId'] == identities[0].externalId assert member['externalIdType'] == identities[0].externalIdType assert member['role'] == 'owner' return start_client
def make_client(admin_user_client, account, username, password): key = admin_user_client.create_apiKey() admin_user_client.wait_success(key) start_client = from_env(url=cattle_url(), access_key=key.publicValue, secret_key=key.secretValue) token = requests.post(base_url() + 'token', { 'code': username + ':' + password }) token = token.json() assert token['type'] != 'error' token = token['jwt'] start_client._auth = LocalAuth(token) start_client.valid() identities = start_client.list_identity() assert len(identities) == 1 assert identities[0].externalId == account.id return start_client
def run(count=50000, batch=1, interval=1.000): client = from_env(url=URL) unmanaged_network = client.list_network(uuid='unmanaged')[0] #network = client.list_network(uuid='managed-docker0')[0] remaining = count while remaining > 0: start = time.time() current_batch = min(batch, remaining) try: cs = client.create_container( imageUuid='docker:ibuildthecloud/helloworld', count=current_batch, networkIds=[unmanaged_network.id], #networkIds=[network.id], instanceTriggeredStop='restart', command='sleep 1000000') if cs.type == 'collection': for c in cs: print 'Created', remaining, c.id, c.uuid queue.put(c.id) else: print 'Created', remaining, cs.id, cs.uuid queue.put(cs.id) except Exception, e: print e remaining -= current_batch wait = interval - (time.time() - start) if wait > 0: print 'Sleep', wait time.sleep(wait) else: print 'Fall behind', wait
def make_client(admin_user_client, account, username, password): key = admin_user_client.create_apiKey() admin_user_client.wait_success(key) start_client = from_env(url=cattle_url(), access_key=key.publicValue, secret_key=key.secretValue) token = requests.post(base_url() + "token", {"code": username + ":" + password}) token = token.json() assert token["type"] != "error" jwt = token["jwt"] user = token["userIdentity"] assert user["login"] == username assert token["user"] == username start_client._auth = LocalAuth(jwt) start_client._access_key = None start_client._secret_key = None start_client.reload_schema() start_client.valid() identities = start_client.list_identity() assert len(identities) == 1 assert identities[0].externalId == account.id assert identities[0].login == username projects = start_client.list_project() assert len(projects) == 1 members = projects[0].projectMembers() assert len(members) == 1 member = get_plain_member(members[0]) assert member["externalId"] == identities[0].externalId assert member["externalIdType"] == identities[0].externalIdType assert member["role"] == "owner" return start_client
def run(count=50000, batch=1, interval=1.000): client = from_env(url=URL) unmanaged_network = client.list_network(uuid='unmanaged')[0] #network = client.list_network(uuid='managed-docker0')[0] remaining = count while remaining > 0: start = time.time() current_batch = min(batch, remaining) try: cs = client.create_container(imageUuid='docker:ibuildthecloud/helloworld', count=current_batch, networkIds=[unmanaged_network.id], #networkIds=[network.id], instanceTriggeredStop='restart', command='sleep 1000000') if cs.type == 'collection': for c in cs: print 'Created', remaining, c.id, c.uuid queue.put(c.id) else: print 'Created', remaining, cs.id, cs.uuid queue.put(cs.id) except Exception, e: print e remaining -= current_batch wait = interval - (time.time() - start) if wait > 0: print 'Sleep', wait time.sleep(wait) else: print 'Fall behind', wait
def replica_client2(request): url = 'http://localhost:9505/v1/schemas' c = cattle.from_env(url=url) request.addfinalizer(lambda: cleanup_replica(c)) return cleanup_replica(c)
def fin(): admin_user_client.create_localAuthConfig(enabled=None, username=username, password=password) assert from_env().valid()
url = sys.argv[1] r = requests.get(url) if r.status_code == 200 and r.text.startswith('#!/bin/sh'): print url sys.exit(0) r = requests.get(sys.argv[1]) try: url = r.headers['X-API-Schemas'] except KeyError: url = sys.argv[1] client = from_env(url=url) if not client.valid(): print 'Invalid client' sys.exit(1) if 'POST' not in client.schema.types['registrationToken'].collectionMethods: projects = client.list_project(uuid='adminProject') if len(projects) == 0: print 'Failed to find admin resource group' sys.exit(1) client = from_env(url=projects[0].links['schemas']) if not client.valid(): print 'Invalid client' sys.exit(1)
def fin(): admin_user_client.create_localAuthConfig(enabled=None, username=username, password=password) # Proves auth is off because keys are invalid and would be reject assert from_env(access_key="bad_key", secret_key="bad_key2").valid()
if detail or is_running(pi): for pe in pi.processExecutions(): for x in pe.log.executions: print_pe(x, prefix=' ') def print_pe(pe, prefix=''): print prefix, print_time(pe), 'PROCESS:', pe.name, \ '{}:{}'.format(pe.resourceType, pe.resourceId), pe.exitReason for phe in pe.processHandlerExecutions: print_phe(phe, prefix=prefix + ' ') def print_phe(phe, prefix=''): print prefix, print_time(phe), 'HANDLER:', phe.name for child in phe.children: for pe in child.executions: print_pe(pe, prefix=prefix + ' ') if __name__ == '__main__': import sys client = from_env(headers={'X-API-Project-Id': 'USER'}) if len(sys.argv) == 1: for pi in client.list_process_instance(sort='startTime', order='desc', limit=30): print_pi(pi) else: pi = client.by_id_process_instance(sys.argv[1]) print_pi(pi, detail=True)
def replica_client(request, url): c = cattle.from_env(url=url) request.addfinalizer(lambda: cleanup_replica(c)) return cleanup_replica(c)
def _admin_client(): return cattle.from_env(url=cattle_url(), cache=False, access_key='admin', secret_key='adminpass')
def _client_for_user(name, accounts): return cattle.from_env(url=cattle_url(), cache=False, access_key=accounts[name][0], secret_key=accounts[name][1])
# Discovery Token token = requests.get("https://discovery.etcd.io/new").text userdata = """#cloud-config coreos: units: - name: etcd.service command: start - name: fleet.service command: start etcd: discovery: %s addr: $private_ipv4:4001 peer-addr: $private_ipv4:7001""" % token client = cattle.from_env() cred = client.list_ssh_key(uuid='defaultSshKey')[0] image = client.list_image(uuid_like='coreos-stable-%')[0] for i in range(3): c = client.create_virtual_machine(imageId=image.id, name='CoreOS {0}'.format(i+1), credentialIds=[cred.id], userdata=userdata, memoryMb=512) print 'Created Name: {}, ID: {}, Image: {}'.format(c.name, c.id, c.image().name)
def _client_for_user(name, accounts): return cattle.from_env(access_key=accounts[name][0], secret_key=accounts[name][1])
def _admin_client(): return cattle.from_env(access_key='admin', secrect_key='adminpass')
def api_client(access_key, secret_key, project_id=None): return cattle.from_env(url=cattle_url(project_id), cache=False, access_key=access_key, secret_key=secret_key)
def api_client(access_key, secret_key): return cattle.from_env(url=cattle_url(), cache=False, access_key=access_key, secret_key=secret_key)
if detail or is_running(pi): for pe in pi.processExecutions(): for x in pe.log.executions: print_pe(x, prefix=' ') def print_pe(pe, prefix=''): print prefix, print_time(pe), 'PROCESS:', pe.name, \ '{}:{}'.format(pe.resourceType, pe.resourceId), pe.exitReason for phe in pe.processHandlerExecutions: print_phe(phe, prefix=prefix + ' ') def print_phe(phe, prefix=''): print prefix, print_time(phe), 'HANDLER:', phe.name for child in phe.children: for pe in child.executions: print_pe(pe, prefix=prefix + ' ') if __name__ == '__main__': import sys client = from_env() if len(sys.argv) == 1: for pi in client.list_process_instance(sort='startTime', order='desc', limit=30): print_pi(pi) else: pi = client.by_id_process_instance(sys.argv[1]) print_pi(pi, detail=True)
from multiprocessing import Queue, Process #from Queue import Queue #from threading import Thread as Process from cattle import from_env import time URL = 'http://mgmt1:8080/v1/schemas' queue = Queue() client = from_env(url=URL) start = time.time() def progress(): done_count = 0 error_count = 0 while True: id = queue.get() if id is None: break c = client.by_id_container(id) c = client.wait_transitioning(c, timeout=10000) if c.state == 'running': print (c.firstRunningTS - c.createdTS)/1000, c.id, c.hosts()[0].name done_count += 1 else: error_count += 1 print time.time(), 'Done:', done_count, 'Error:',\
def client(): url = 'http://localhost:8088/v1-catalog/schemas' return cattle.from_env(url=url)
def fin(): admin_user_client.create_localAuthConfig(enabled=None, username=username, password=password) # Proves auth is off because keys are invalid and would be reject assert from_env(access_key='bad_key', secret_key='bad_key2').valid()
def admin_client(): from_env(url=URL) assert client.valid() return client
def client(): client = from_env(url=URL) assert client.valid() return client
def __init__(self, volume): url = 'http://localhost:9414/v1/schemas' c = cattle.from_env(url=url) dev = c.list_volume()[0] assert dev.name == volume self.dev = dev
def client(request): url = 'http://localhost:9502/v1/schemas' c = cattle.from_env(url=url) request.addfinalizer(lambda: cleanup(c)) return cleanup(c)