class App(object):
def __init__(self, flask_app):
super(App, self).__init__()
self.flask_app = flask_app
self.loopback = FlaskLoopback(self.flask_app)
self.hostname = str(uuid1())
self.url = URLObject("http://{0}".format(self.hostname))
def activate(self):
self.loopback.activate_address((self.hostname, 80))
def deactivate(self):
self.loopback.deactivate_address((self.hostname, 80))
def get_page(self, page_size, page, path=None):
if path is None:
path = "objects"
response = requests.get(self.url.add_path(path).set_query_param("page", str(page)).set_query_param("page_size", str(page_size)))
response.raise_for_status()
data = response.json()
assert data["metadata"]["page"] == page
assert data["metadata"]["page_size"] == page_size
return data["result"]
def get_all_paged(self, page_size, path=None):
return list(itertools.chain.from_iterable(self.get_page(page_size, page, path=path) for page in range(1, int(self.num_objects / page_size) + 5)))
class App(object):
def __init__(self, flask_app):
super(App, self).__init__()
self.flask_app = flask_app
self.loopback = FlaskLoopback(self.flask_app)
self.hostname = str(uuid1())
self.url = URLObject("http://{0}".format(self.hostname))
def activate(self):
self.loopback.activate_address((self.hostname, 80))
def deactivate(self):
self.loopback.deactivate_address((self.hostname, 80))
def get_page(self, page_size, page, path=None):
if path is None:
path = "objects"
response = requests.get(
self.url.add_path(path).set_query_param("page",
str(page)).set_query_param(
"page_size",
str(page_size)))
response.raise_for_status()
data = response.json()
assert data["metadata"]["page"] == page
assert data["metadata"]["page_size"] == page_size
return data["result"]
def get_all_paged(self, page_size, path=None):
return list(
itertools.chain.from_iterable(
self.get_page(page_size, page, path=path)
for page in range(1,
int(self.num_objects / page_size) + 5)))
def main(verbose, quiet):
from _benchmark_queries import queries
with logbook.NullHandler(), logbook.StreamHandler(sys.stderr, level=logbook.CRITICAL-verbose+quiet, bubble=False):
loopback = FlaskLoopback(create_app())
loopback.activate_address((_root_address, 80))
num_attempts = 5
for obj, query in queries:
times = []
has_error = False
print(obj, '|', click.style(query, fg='cyan'), '--')
for i in range(num_attempts):
start_time = time.time()
resp = requests.get(_root_url.add_path('/rest').add_path(obj).add_query_param('search', query).add_query_param('page_size', 25))
end_time = time.time()
if resp.status_code == requests.codes.internal_server_error:
print('\t', click.style('Timeout', fg='red'))
has_error=True
break
else:
resp.raise_for_status()
times.append(end_time - start_time)
if not has_error:
print('\t', len(resp.json()[obj]), 'results --', '(Out of {}) Best: {:.03}s Avg: {:.03}s Worst: {:.03}s'.format(num_attempts, min(times), sum(times) / len(times), max(times)))
class Webapp(object):
def __init__(self, app):
super(Webapp, self).__init__()
self.app = app
self.loopback = FlaskLoopback(self.app)
self.hostname = str(uuid4())
self.url = URL('http://{0}'.format(self.hostname))
def activate(self):
self.loopback.activate_address((self.hostname, 80))
def deactivate(self):
self.loopback.deactivate_address((self.hostname, 80))
def _request(self, method, path, *args, **kwargs):
raw_response = kwargs.pop("raw_response", False)
if path.startswith("/"):
path = path[1:]
assert not path.startswith("/")
returned = requests.request(
method, "http://{0}/{1}".format(self.hostname, path), *args, **kwargs)
if raw_response:
return returned
returned.raise_for_status()
return returned.json()
class Webapp(object):
def __init__(self, app):
super(Webapp, self).__init__()
self.app = app
self.loopback = FlaskLoopback(self.app)
self.hostname = str(uuid4())
self.url = URL('http://{0}'.format(self.hostname))
def activate(self):
self.loopback.activate_address((self.hostname, 80))
def deactivate(self):
self.loopback.deactivate_address((self.hostname, 80))
def _request(self, method, path, *args, **kwargs):
raw_response = kwargs.pop("raw_response", False)
if path.startswith("/"):
path = path[1:]
assert not path.startswith("/")
returned = requests.request(
method, "http://{0}/{1}".format(self.hostname, path), *args,
**kwargs)
if raw_response:
return returned
returned.raise_for_status()
return returned.json()
def mailboxer_url(request, db_engine):
loopback = FlaskLoopback(create_app())
hostname = str(uuid.uuid1())
loopback.activate_address((hostname, 80))
@request.addfinalizer
def close():
loopback.deactivate_address((hostname, 80))
return URL("http://{0}".format(hostname))
def url(request, flask_app):
address = str(uuid1())
returned = URL('http://{0}'.format(address))
webapp = FlaskLoopback(flask_app)
webapp.activate_address((address, 80))
@request.addfinalizer
def finalize(): # pylint: disable=unused-variable
webapp.deactivate_address((address, 80))
return returned
def mailboxer_url(request, db_engine):
loopback = FlaskLoopback(create_app())
hostname = str(uuid.uuid1())
loopback.activate_address((hostname, 80))
@request.addfinalizer
def close():
loopback.deactivate_address((hostname, 80))
return URL("http://{0}".format(hostname))
def activate(self):
self.app = build_app(use_cached=True)
self.app.config["SECRET_KEY"] = "testing_key"
self.app.config["TESTING"] = True
self.loopback = FlaskLoopback(self.app)
self.loopback.activate_address((self.hostname, 80))
def app():
returned = Flask(__name__)
@returned.route("/echo", methods=["post"])
def echo(): # pylint: disable=unused-variable
return jsonify({"result": True})
@returned.route("/request_vars")
def get_request_vars(): # pylint: disable=unused-variable
return jsonify(
dict((name, getattr(request, name)) for name in ["host"]))
@returned.route("/set_cookie")
def set_cookie(): # pylint: disable=unused-variable
returned = jsonify({})
returned.set_cookie(_COOKIE_NAME, value=_COOKIE_VALUE)
return returned
@returned.route("/assert_no_cookies")
def assert_no_cookies(): # pylint: disable=unused-variable
assert not request.cookies
return jsonify({"result": "ok"})
@returned.route("/assert_cookies")
def assert_cookies(): # pylint: disable=unused-variable
assert request.cookies[_COOKIE_NAME] == _COOKIE_VALUE
return jsonify({})
@returned.route("/set_cookie_on_after_request")
def set_cookie_on_after_request(): # pylint: disable=unused-variable
g.cookies.append((_COOKIE_NAME, _COOKIE_VALUE))
return jsonify({})
@returned.route("/stream_upload", methods=["POST"])
def stream_upload(): # pylint: disable=unused-variable
return hashlib.sha512(request.stream.read()).hexdigest()
@returned.route("/compressed")
def compressed(): # pylint: disable=unused-variable
orig = "uncompressed!".encode("utf-8")
return Response(gzip_compress(orig),
headers={"Content-Encoding": "gzip"})
@returned.before_request
def before(): # pylint: disable=unused-variable
g.cookies = []
@returned.after_request
def after_request(response): # pylint: disable=unused-variable
cookies = getattr(g, "cookies", [])
while cookies:
response.set_cookie(*cookies.pop())
return response
return FlaskLoopback(returned)
def __init__(self, flask_app):
super(App, self).__init__()
self.flask_app = flask_app
self.loopback = FlaskLoopback(self.flask_app)
self.hostname = str(uuid1())
self.url = URLObject("http://{0}".format(self.hostname))
def __init__(self, flask_app):
super(App, self).__init__()
self.flask_app = flask_app
self.loopback = FlaskLoopback(self.flask_app)
self.hostname = str(uuid1())
self.url = URLObject("http://{0}".format(self.hostname))
from bba_config import SECRET_KEY
from bbadmintool import BbAdminTool
app = Flask(__name__, static_url_path='/static')
app.config.from_object('bba_config')
app.secret_key = SECRET_KEY
db = SQLAlchemy(app)
bb = BbAdminTool(app)
login_manager = LoginManager()
login_manager.init_app(app)
cors = CORS(app, allow_headers=[Authorization])
loopback = FlaskLoopback(app)
from views import *
from models import *
api_manager = APIManager(
app,
flask_sqlalchemy_db=db,
preprocessors=dict(
# GET=[auth_func], GET_SINGLE=[auth_func], GET_MANY=[auth_func],
POST=[auth_func],
POST_SINGLE=[auth_func],
POST_MANY=[auth_func],
PATCH=[auth_func],
PATCH_SINGLE=[auth_func],
PATCH_MANY=[auth_func],
def scotty(api_call_logger):
app = Flask(__name__)
url = "http://mock-scotty"
@app.route("/combadge")
def combadge_file():
api_call_logger.log_call(flask.request)
combadge_version = flask.request.values.get("combadge_version")
fixtures_folder = os.path.join(os.path.dirname(__file__), "fixtures")
if combadge_version == "v1":
file_name = "combadge.py"
elif combadge_version == "v2":
file_name = "combadge"
else:
raise ValueError(
"Unknown combadge version {combadge_version}".format(
combadge_version=combadge_version))
return send_file(os.path.join(fixtures_folder, file_name))
@app.route("/beams", methods=["POST"])
def beams():
api_call_logger.log_call(flask.request)
json = flask.request.json
date = datetime.datetime(year=2020, month=2, day=27).isoformat() + "Z"
return jsonify({
"beam": {
"id": 666,
"start": date,
"size": 0,
"host": json["beam"].get("host"),
"comment": json["beam"].get("comment"),
"directory": json["beam"].get("directory"),
"initiator": json["beam"].get("user"),
"error": None,
"combadge_contacted": False,
"pending_deletion": False,
"completed": False,
"deleted": False,
"pins": [],
"tags": [],
"associated_issues": [],
"purge_time": 0,
}
})
beam_count = 2
all_beams = [{
"id":
i,
"start":
datetime.datetime(year=2020, month=2, day=27).isoformat() + "Z",
"size":
0,
"host":
"host{}".format(i),
"comment":
"comment{}".format(i),
"directory":
"directory{}".format(i),
"initiator":
"user{}".format(i),
"error":
None,
"combadge_contacted":
False,
"pending_deletion":
False,
"completed":
False,
"deleted":
False,
"pins": [],
"tags": [],
"associated_issues": [],
"purge_time":
0,
} for i in range(beam_count)]
@app.route("/beams")
def beams_index():
api_call_logger.log_call(request)
page = int(request.values.get("page", 1))
return jsonify({
"beams": all_beams[page - 1:page],
"meta": {
"total_pages": beam_count,
},
})
@app.route("/beams/<int:beam>")
def single_beam(beam):
return jsonify({
"beam": all_beams[beam],
})
@app.route("/info")
def info():
return jsonify({
"transporter": "mock-transporter",
"version": "0.0.0",
})
with FlaskLoopback(app).on(("mock-scotty", 80)):
yield Scotty(url)
def __init__(self, app):
super(Webapp, self).__init__()
self.app = app
self.loopback = FlaskLoopback(self.app)
self.hostname = str(uuid4())
self.url = URL('http://{0}'.format(self.hostname))
def __init__(self, app):
super(Webapp, self).__init__()
self.app = app
self.loopback = FlaskLoopback(self.app)
self.hostname = str(uuid4())
self.url = URL('http://{0}'.format(self.hostname))
class Webapp(object):
def __init__(self):
super(Webapp, self).__init__()
self.hostname = str(uuid.uuid1())
def __enter__(self):
self.activate()
return self
def __exit__(self, *args):
self.deactivate()
def activate(self):
self.app = build_app(use_cached=True)
self.app.config["SECRET_KEY"] = "testing_key"
self.app.config["TESTING"] = True
self.loopback = FlaskLoopback(self.app)
self.loopback.activate_address((self.hostname, 80))
def deactivate(self):
self.loopback.deactivate_address((self.hostname, 80))
def request(self, method, path, *args, **kwargs):
"""Performs a request against the server app
All arguments are similar to requests' ``request``, except for a few
exceptions listed below
:keyword raw_response: if ``True``, returns the raw response object and avoids checking for success
:keyword data_json: if provided, sends the value provided serialized to JSON, and sets the content type to be json accordingly
"""
if not isinstance(path, str):
path = str(path)
raw_response = kwargs.pop("raw_response", False)
data_json = kwargs.pop('data_json', NOTHING)
if data_json is not NOTHING:
if 'data' in kwargs:
raise RuntimeError('`data` is not supported when combined with `data_json`')
kwargs['data'] = json.dumps(data_json)
headers = kwargs['headers'] = dict(kwargs.get('headers', ()))
if not any(k.lower() == 'content-type' for k in headers):
headers['Content-type'] = 'application/json'
if path.startswith("/"):
path = path[1:]
assert not path.startswith("/")
returned = requests.request(method, f"http://{self.hostname}/{path}", *args, **kwargs)
if raw_response:
return returned
returned.raise_for_status()
return returned.json()
def get(self, *args, **kwargs):
"""Shortcut for self.request('get', ...)
"""
return self.request("get", *args, **kwargs)
def post(self, *args, **kwargs):
"""Shortcut for self.request('post', ...)
"""
return self.request("post", *args, **kwargs)
def delete(self, *args, **kwargs):
"""Shortcut for self.request('delete', ...)
"""
return self.request("delete", *args, **kwargs)
def put(self, *args, **kwargs):
"""Shortcut for self.request('put', ...)
"""
return self.request("put", *args, **kwargs)
