| #!/usr/bin/env python |
| # Copyright 2015 Amazon.com, Inc. or its affiliates. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"). You |
| # may not use this file except in compliance with the License. A copy of |
| # the License is located at |
| # |
| # http: |
| # |
| # or in the "license" file accompanying this file. This file 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. |
| """Driver for client scripts. |
|
|
| How it Works |
| ============ |
|
|
| This script is part of the infrastructure used for resource leak tests. |
| At a high level, we're trying to verify that specific types of operations |
| don't leak memory. For example: |
|
|
| |
| |
| |
|
|
| In order to do this, these tests are written to utilize two separate |
| processes: a driver and a runner. The driver sends commands to the |
| runner which performs the actual commands. While the runner is |
| running commands the driver can record various attributes about |
| the runner process. So far this is just memory usage. |
|
|
| There's a BaseClientDriverTest test that implements the driver part |
| of the tests. These should read like normal functional/integration tests. |
|
|
| This script (cmd-runner) implements the runner. It listens for commands |
| from the driver and runs the commands. |
|
|
| The driver and runner communicate via a basic text protocol. Commands |
| are line separated with arguments separated by spaces. Commands |
| are sent to the runner via stdin. |
|
|
| On success, the runner response through stdout with "OK". |
|
|
| Here's an example:: |
|
|
| +--------+ +-------+ |
| | Driver | |Runner | |
| +--------+ +-------+ |
|
|
| create_client s3 |
| --------------------------------------------> |
| OK |
| <------------------------------------------- |
|
|
| make_aws_request 100 ec2 describe_instances |
| --------------------------------------------> |
| OK |
| <------------------------------------------- |
|
|
| stream_s3_upload bucket key /tmp/foo.txt |
| --------------------------------------------> |
| OK |
| <------------------------------------------- |
|
|
| exit |
| --------------------------------------------> |
| OK |
| <------------------------------------------- |
|
|
| """ |
| import botocore.session |
| import sys |
|
|
|
|
| class CommandRunner(object): |
| DEFAULT_REGION = 'us-west-2' |
|
|
| def __init__(self): |
| self._session = botocore.session.get_session() |
| self._clients = [] |
| self._waiters = [] |
| self._paginators = [] |
|
|
| def run(self): |
| while True: |
| line = sys.stdin.readline() |
| parts = line.strip().split() |
| if not parts: |
| break |
| elif parts[0] == 'exit': |
| sys.stdout.write('OK\n') |
| sys.stdout.flush() |
| break |
| else: |
| getattr(self, '_do_%s' % parts[0])(parts[1:]) |
| sys.stdout.write('OK\n') |
| sys.stdout.flush() |
|
|
| def _do_create_client(self, args): |
| # The args provided by the user map directly to the args |
| # passed to create_client. At the least you need |
| # to provide the service name. |
| self._clients.append(self._session.create_client(*args)) |
|
|
| def _do_create_multiple_clients(self, args): |
| # Args: |
| # * num_clients - Number of clients to create in a loop |
| # * client_args - Variable number of args to pass to create_client |
| num_clients = args[0] |
| client_args = args[1:] |
| for _ in range(int(num_clients)): |
| self._clients.append(self._session.create_client(*client_args)) |
|
|
| def _do_free_clients(self, args): |
| # Frees the memory associated with all clients. |
| self._clients = [] |
|
|
| def _do_create_waiter(self, args): |
| # Args: |
| # [0] client name used in its instantiation |
| # [1] waiter name used in its instantiation |
| client = self._create_client(args[0]) |
| self._waiters.append(client.get_waiter(args[1])) |
|
|
| def _do_create_multiple_waiters(self, args): |
| # Args: |
| # [0] num_waiters - Number of clients to create in a loop |
| # [1] client name used in its instantiation |
| # [2] waiter name used in its instantiation |
| num_waiters = args[0] |
| client = self._create_client(args[1]) |
| for _ in range(int(num_waiters)): |
| self._waiters.append(client.get_waiter(args[2])) |
|
|
| def _do_free_waiters(self, args): |
| # Frees the memory associated with all of the waiters. |
| self._waiters = [] |
|
|
| def _do_create_paginator(self, args): |
| # Args: |
| # [0] client name used in its instantiation |
| # [1] paginator name used in its instantiation |
| client = self._create_client(args[0]) |
| self._paginators.append(client.get_paginator(args[1])) |
|
|
| def _do_create_multiple_paginators(self, args): |
| # Args: |
| # [0] num_paginators - Number of paginators to create in a loop |
| # [1] client name used in its instantiation |
| # [2] paginator name used in its instantiation |
| num_paginators = args[0] |
| client = self._create_client(args[1]) |
| for _ in range(int(num_paginators)): |
| self._paginators.append(client.get_paginator(args[2])) |
|
|
| def _do_free_paginators(self, args): |
| # Frees the memory associated with all of the waiters. |
| self._paginators = [] |
|
|
| def _do_make_aws_request(self, args): |
| # Create a client and make a number of AWS requests. |
| # Args: |
| # * num_requests - The number of requests to create in a loop |
| # * service_name - The name of the AWS service |
| # * operation_name - The name of the service, snake_cased |
| # * oepration_args - Variable args, kwargs to pass to the API call, |
| # in the format Kwarg1:Val1 Kwarg2:Val2 |
| num_requests = int(args[0]) |
| service_name = args[1] |
| operation_name = args[2] |
| kwargs = dict([v.split(':', 1) for v in args[3:]]) |
| client = self._create_client(service_name) |
| method = getattr(client, operation_name) |
| for _ in range(num_requests): |
| method(**kwargs) |
|
|
| def _do_stream_s3_upload(self, args): |
| # Stream an upload to S3 from a local file. |
| # This does *not* create an S3 bucket. You need to create this |
| # before running this command. You will also need to create |
| # the local file to upload before calling this command. |
| # Args: |
| # * bucket - The name of the S3 bucket |
| # * key - The name of the S3 key |
| # * filename - The name of the local filename to upload |
| bucket, key, local_filename = args |
| client = self._create_client('s3') |
| with open(local_filename, 'rb') as f: |
| client.put_object(Bucket=bucket, Key=key, Body=f) |
|
|
| def _do_stream_s3_download(self, args): |
| # Stream a download to S3 from a local file. |
| # Before calling this command you'll need to create the S3 bucket |
| # as well as the S3 object. Also, the directory where the |
| # file will be downloaded must already exist. |
| # Args: |
| # * bucket - The name of the S3 bucket |
| # * key - The name of the S3 key |
| # * filename - The local filename where the object will be downloaded |
| bucket, key, local_filename = args |
| client = self._create_client('s3') |
| response = client.get_object(Bucket=bucket, Key=key) |
| body_stream = response['Body'] |
| with open(local_filename, 'wb') as f: |
| for chunk in iter(lambda: body_stream.read(64 * 1024), b''): |
| f.write(chunk) |
|
|
| def _create_client(self, service_name): |
| # Create a client using the provided service name. |
| # It will also inject a region name of self.DEFAULT_REGION. |
| return self._session.create_client(service_name, |
| region_name=self.DEFAULT_REGION) |
|
|
|
|
| def run(): |
| CommandRunner().run() |
|
|
|
|
| run() |
|
|
