tests: updated load tests CLIs

rhodecode/tests/load/pages.txt

@@ -0,0 +1,2 b''
+big/CPython
+big/CPython/commits

rhodecode/tests/load/time_urls.py

@@ -1,69 +1,73 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import timeit
+import logging
+import click
 
-server = "localhost:5000"
+log = logging.getLogger(__name__)
+
 
-pages = [
-    "cpython",
-    "cpython/annotate/74236c8bf064188516b32bf95016971227ec72a9/Makefile.pre.in",
-    "cpython/changelog",
-    "cpython/changeset/e0f681f4ade3af52915d5f32daac97ada580d71a",
-    "cpython/compare/tag@v3.4.1rc1...tag@v3.4.1?target_repo=cpython",
-    "cpython/files/tip/",
-    "cpython/files/74236c8bf064188516b32bf95016971227ec72a9/Grammar",
-    "",
-    "git",
-    "git/annotate/6c4ab27f2378ce67940b4496365043119d7ffff2/gitk-git/.gitignore",
-    "git/changelog",
-    "git/changeset/d299e9e550c1bf8640907fdba1f03cc585ee71df",
-    "git/compare/rev@1200...rev@1300?target_repo=git",
-    "git/files/tip/",
-    "git/files/6c4ab27f2378ce67940b4496365043119d7ffff2/.gitignore"
-]
[e-mail]()
[e-mail]('--server', help='Server url to connect to. e.g http://rc.local.com', required=True)
[e-mail]('--pages', help='load pages to visit from a file', required=True, type=click.File())
[e-mail]('--repeat', help='number of times to repeat', default=10, type=int)
+def main(server, repeat, pages):
+
+    print("Repeating each URL %d times\n" % repeat)
+    pages = pages.readlines()
+
+    for page_url in pages:
+
+        url = "%s/%s" % (server, page_url.strip())
+        print(url)
+
+        stmt = "requests.get('%s', timeout=120)" % url
+        t = timeit.Timer(stmt=stmt, setup="import requests")
 
-svn_pages = [
-    "svn-apache",
-    "svn-apache/annotate/672129/cocoon/trunk/README.txt",
-    "svn-apache/changelog",
-    "svn-apache/changeset/1164362",
-    "svn-apache/compare/rev@1164350...rev@1164360?target_repo=svn-apache",
-    "svn-apache/compare/rev@1164300...rev@1164360?target_repo=svn-apache",
-    "svn-apache/files/tip/",
-    "svn-apache/files/1164363/cocoon/trunk/README.txt",
-]
+        result = t.repeat(repeat=repeat, number=1)
+        print("  %.3f (min) - %.3f (max) - %.3f (avg)\n" %
+              (min(result), max(result), sum(result) / len(result)))
+
 
-# Uncomment to check also svn performance
-# pages = pages + svn_pages
+if __name__ == '__main__':
+    main()
+
+
+
+
+
+
+
 
-repeat = 10
+
+
 
-print("Repeating each URL x%d\n" % repeat)
-for page in pages:
-    url = "http://%s/%s" % (server, page)
-    print(url)
+
+
+
 
-    stmt = "urllib2.urlopen('%s', timeout=120)" % url
-    t = timeit.Timer(stmt=stmt, setup="import urllib2")
+
+
+
 
-    result = t.repeat(repeat=repeat, number=1)
-    print("\t%.3f (min) - %.3f (max) - %.3f (avg)\n" %
-          (min(result), max(result), sum(result)/len(result)))
+
+
+

rhodecode/tests/load/vcs_performance.py

@@ -1,305 +1,306 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 VCS Performance measurement tool
 
 Usage:
 
 - Check that required vcs keys can be found in ~/.hgrc and ~/.netrc
 
 - Start a local instance of RhodeCode Enterprise
 
 - Launch the script:
 
     TMPDIR=/tmp python vcs_performance.py \
         --host=http://vm:5000 \
         --api-key=55c4a33688577da24183dcac5fde4dddfdbf18dc \
         --commits=10 --repositories=100 --log-level=info
 """
 
 import argparse
 import functools
 import logging
 import os
 import shutil
 import subprocess32
 import tempfile
 import time
 from itertools import chain
 
 from api import RCApi, ApiError
 
 
 log = logging.getLogger(__name__)
 
 
 def timed(f):
     """Decorator that returns the time it took to execute the function."""
     @functools.wraps(f)
     def wrapped_f(*args, **kwargs):
         start_time = time.time()
         try:
             f(*args, **kwargs)
         finally:
             return time.time() - start_time
 
     return wrapped_f
 
 
 def mean(container):
     """Return the mean of the container."""
     if not container:
         return -1.0
     return sum(container) / len(container)
 
 
 class Config(object):
     args = None
 
     def __init__(self):
         parser = argparse.ArgumentParser(description='Runs VCS load tests')
         parser.add_argument(
             '--host', dest='host', action='store', required=True,
             help='RhodeCode Enterprise host')
         parser.add_argument(
             '--api-key', dest='api_key', action='store', required=True,
             help='API Key')
         parser.add_argument(
             '--file-size', dest='file_size', action='store', required=False,
             default=1, type=int, help='File size in MB')
         parser.add_argument(
             '--repositories', dest='repositories', action='store',
             required=False, default=1, type=int,
             help='Number of repositories')
         parser.add_argument(
             '--commits', dest='commits', action='store', required=False,
             default=1, type=int, help='Number of commits')
         parser.add_argument(
             '--log-level', dest='log_level', action='store', required=False,
             default='error', help='Logging level')
         self.args = parser.parse_args()
 
     def __getattr__(self, attr):
         return getattr(self.args, attr)
 
 
 class Repository(object):
     FILE_NAME_TEMPLATE = "test_{:09d}.bin"
 
     def __init__(self, name, base_path, api):
         self.name = name
         self.path = os.path.join(base_path, name)
         self.api = api
+        self.url = None
 
     def create(self):
         self._create_filesystem_repo(self.path)
         try:
-            self.url = self.api.create_repo(
-                self.name, self.TYPE, 'Performance tests')
+            self.url = self.api.create_repo(self.name, self.TYPE, 'Performance tests')
         except ApiError as e:
             log.error('api: {}'.format(e))
 
     def delete(self):
         self._delete_filesystem_repo()
         try:
             self.api.delete_repo(self.name)
         except ApiError as e:
             log.error('api: {}'.format(e))
 
     def create_commits(self, number, file_size):
         for i in xrange(number):
             file_name = self.FILE_NAME_TEMPLATE.format(i)
-            log.debug("Create commit {}".format(file_name))
+            log.debug("Create commit[{}] {}".format(self.name, file_name))
             self._create_file(file_name, file_size)
             self._create_commit(file_name)
 
     @timed
     def push(self):
         raise NotImplementedError()
 
     @timed
     def clone(self, destination_path):
         raise NotImplementedError()
 
     @timed
     def pull(self):
         raise NotImplementedError()
 
     def _run(self, *args):
         command = [self.BASE_COMMAND] + list(args)
         process = subprocess32.Popen(
             command, stdout=subprocess32.PIPE, stderr=subprocess32.PIPE)
         return process.communicate()
 
     def _create_file(self, name, size):
         file_name = os.path.join(self.path, name)
         with open(file_name, 'wb') as f:
             f.write(os.urandom(1024))
 
     def _delete_filesystem_repo(self):
         shutil.rmtree(self.path)
 
     def _create_filesystem_repo(self, path):
         raise NotImplementedError()
 
     def _create_commit(self, file_name):
         raise NotImplementedError()
 
 
 class GitRepository(Repository):
     TYPE = 'git'
     BASE_COMMAND = 'git'
 
     @timed
     def push(self):
         os.chdir(self.path)
         self._run('push', '--set-upstream', self.url, 'master')
 
     @timed
     def clone(self, destination_path):
         self._run('clone', self.url, os.path.join(destination_path, self.name))
 
     @timed
     def pull(self, destination_path):
         path = os.path.join(destination_path, self.name)
         self._create_filesystem_repo(path)
         os.chdir(path)
         self._run('remote', 'add', 'origin', self.url)
         self._run('pull', 'origin', 'master')
 
     def _create_filesystem_repo(self, path):
         self._run('init', path)
 
     def _create_commit(self, file_name):
         os.chdir(self.path)
         self._run('add', file_name)
         self._run('commit', file_name, '-m', '"Add {}"'.format(file_name))
 
 
 class HgRepository(Repository):
     TYPE = 'hg'
     BASE_COMMAND = 'hg'
 
     @timed
     def push(self):
         os.chdir(self.path)
         self._run('push', self.url)
 
     @timed
     def clone(self, destination_path):
         self._run('clone', self.url, os.path.join(destination_path, self.name))
 
     @timed
     def pull(self, destination_path):
         path = os.path.join(destination_path, self.name)
         self._create_filesystem_repo(path)
         os.chdir(path)
         self._run('pull', '-r', 'tip', self.url)
 
     def _create_filesystem_repo(self, path):
         self._run('init', path)
 
     def _create_commit(self, file_name):
         os.chdir(self.path)
         self._run('add', file_name)
         self._run('commit', file_name, '-m', '"Add {}"'.format(file_name))
 
 
 class Benchmark(object):
     REPO_CLASSES = {
         'git': GitRepository,
         'hg': HgRepository
     }
     REPO_NAME = '{}_performance_{:03d}'
 
     def __init__(self, config):
         self.api = RCApi(api_key=config.api_key, rc_endpoint=config.host)
         self.source_path = tempfile.mkdtemp(suffix='vcsperformance')
 
         self.config = config
         self.git_repos = []
         self.hg_repos = []
 
         self._set_log_level()
 
     def start(self):
         self._create_repos()
         repos = {
             'git': self.git_repos,
             'hg': self.hg_repos
         }
 
         clone_destination_path = tempfile.mkdtemp(suffix='clone')
         pull_destination_path = tempfile.mkdtemp(suffix='pull')
         operations = [
             ('push', ),
             ('clone', clone_destination_path),
             ('pull', pull_destination_path)
         ]
 
         for operation in operations:
             for type_ in repos:
                 times = self._measure(repos[type_], *operation)
-                print("Mean {} {} time: {:.3f} sec.".format(
-                    type_, operation[0], mean(times)))
+                print("Mean[of {}] {:5s} {:5s} time: {:.3f} sec.".format(
+                    len(times), type_, operation[0], mean(times)))
 
     def cleanup(self):
         log.info("Cleaning up...")
         for repo in chain(self.git_repos, self.hg_repos):
             repo.delete()
 
     def _measure(self, repos, operation, *args):
         times = []
         for repo in repos:
             method = getattr(repo, operation)
             times.append(method(*args))
         return times
 
     def _create_repos(self):
         log.info("Creating repositories...")
         for i in xrange(self.config.repositories):
             self.git_repos.append(self._create_repo('git', i))
             self.hg_repos.append(self._create_repo('hg', i))
 
     def _create_repo(self, type_, id_):
         RepoClass = self.REPO_CLASSES[type_]
         repo = RepoClass(
             self.REPO_NAME.format(type_, id_), self.source_path, self.api)
         repo.create()
         repo.create_commits(self.config.commits, self.config.file_size)
         return repo
 
     def _set_log_level(self):
         try:
             log_level = getattr(logging, config.log_level.upper())
         except:
             log_level = logging.ERROR
         handler = logging.StreamHandler()
         log.addHandler(handler)
         log.setLevel(log_level)
 
+
 if __name__ == '__main__':
     config = Config()
     benchmark = Benchmark(config)
     try:
         benchmark.start()
     finally:
         benchmark.cleanup()