diff --git a/.circleci/config.yml b/.circleci/config.yml index 094a747f..7bef6c68 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -54,7 +54,7 @@ jobs: itests: &itests <<: *defaults_itests - parallelism: 1 + parallelism: 2 steps: - attach_workspace: at: /tmp/workspace diff --git a/Dockerfile b/Dockerfile index c2b838d3..e5ae990c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -34,8 +34,9 @@ COPY . . ARG is_ci ENV CI=$is_ci -# Run tests and make the binary -RUN make test && make build +# Run tests (if in CI build) then make the binary +RUN test -z "$CI" || make test +RUN make build # Package binary & certs in a scratch container FROM scratch diff --git a/Gopkg.lock b/Gopkg.lock index 892e59c2..5e913ff3 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -40,7 +40,7 @@ revision = "31546f21ba3471c8418511045aca77bff52af506" [[projects]] - digest = "1:9b9e13cdf36aadc59f25c0a77f89f0093f9c1003d6337b739651f8b7ad92145c" + digest = "1:3d46e78a871fb3ee291dc26904a789a436c60adcdab4138ed88f237731d0d359" name = "github.com/aws/aws-sdk-go" packages = [ "aws", @@ -65,14 +65,19 @@ "internal/sdkuri", "internal/shareddefaults", "private/protocol", + "private/protocol/eventstream", + "private/protocol/eventstream/eventstreamapi", "private/protocol/json/jsonutil", "private/protocol/jsonrpc", "private/protocol/query", "private/protocol/query/queryutil", "private/protocol/rest", + "private/protocol/restxml", "private/protocol/xml/xmlutil", "service/kinesis", "service/kinesis/kinesisiface", + "service/s3", + "service/s3/s3iface", "service/sts", ] pruneopts = "UT" @@ -112,9 +117,12 @@ version = "v1.38.2" [[projects]] - digest = "1:b60efdeb75d3c0ceed88783ac2495256aba3491a537d0f31401202579fd62a94" + digest = "1:a507e8646bf3775af6f7e7b2a62a5e67d1c6a8f00754f87e66b96181b7f3d747" name = "github.com/golang/mock" - packages = ["gomock"] + packages = [ + "gomock", + "mockgen/model", + ] pruneopts = "UT" revision = "51421b967af1f557f93a59e0057aaf15ca02e29c" version = "v1.2.0" @@ -253,8 +261,10 @@ analyzer-version = 1 input-imports = [ "github.com/DataDog/datadog-go/statsd", + "github.com/NeowayLabs/wabbit", "github.com/NeowayLabs/wabbit/amqp", "github.com/NeowayLabs/wabbit/amqptest", + "github.com/NeowayLabs/wabbit/amqptest/server", "github.com/Nextdoor/parselogical", "github.com/aws/aws-sdk-go/aws", "github.com/aws/aws-sdk-go/aws/credentials", @@ -262,9 +272,12 @@ "github.com/aws/aws-sdk-go/aws/session", "github.com/aws/aws-sdk-go/service/kinesis", "github.com/aws/aws-sdk-go/service/kinesis/kinesisiface", + "github.com/aws/aws-sdk-go/service/s3", + "github.com/aws/aws-sdk-go/service/s3/s3iface", "github.com/cenkalti/backoff", "github.com/cevaris/ordered_map", "github.com/golang/mock/gomock", + "github.com/golang/mock/mockgen/model", "github.com/google/go-cmp/cmp", "github.com/jackc/pgx", "github.com/pkg/errors", diff --git a/Makefile b/Makefile index 7a7aeb42..e06eacaa 100644 --- a/Makefile +++ b/Makefile @@ -47,6 +47,11 @@ build: vendor generate mkdir -p target CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$(GO_LDFLAGS)" -o target/pg-bifrost github.com/Nextdoor/pg-bifrost.git/main +build_mac: vendor generate + @echo "Creating GO binary" + mkdir -p target + CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -o target/pg-bifrost github.com/Nextdoor/pg-bifrost.git/main + # Standard settings that will be used later DOCKER := $(shell which docker) diff --git a/README.md b/README.md index 7c2f7ed5..e85622b6 100644 --- a/README.md +++ b/README.md @@ -156,6 +156,10 @@ To dump a memory profile, you send pg-bifrost a `SIGUSR2` signal and the `pprof` In rare scenarios to investigate WAL standby acknowledgement issues to postgres (e.g., thrashing on duplicate data, a missing transaction, etc.) the ledger (the progress tracker's data structure to keep track of received and acknowledged transactions and their WAL messages) can be dumped to STDOUT by sending a `SIGIO` signal to pg-bifrost. +### Transport Specific + +**S3**: [docs/transport/s3.md](docs/transport/s3.md) + ## Development ### Bugs diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 00000000..e81b1480 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,10 @@ +# This docker-compose can be used to bring up a basic postgres container for manual testing +version: '3' +services: + postgres: + container_name: postgres + build: itests/containers/postgres + environment: + - POSTGRES_PASSWORD=pgbifrost + ports: + - 5432:5432 diff --git a/docs/transport/s3.md b/docs/transport/s3.md new file mode 100644 index 00000000..066fef31 --- /dev/null +++ b/docs/transport/s3.md @@ -0,0 +1,28 @@ +# transport: s3 + +The S3 transporter puts logical WAL messages as *gzipped* objects in an S3 bucket partitioned by year, month and day in increasing order of time. This time is at the time of the PUT request creation, and *not* when the data was written to Postgres nor read from the pg-bifrost client. + +## Key Construction + +The basic construction of an S3 key for this transporter is defined as: +``` +/////_.gz +``` + +### Example + +For a given configuration: +``` +BIFROST_S3_BUCKET=test_bucket +BIFROST_S3_KEY_SPACE=test_files +``` + +A batch written at `2000:01:02 12:03:04` with the WAL record ID of the first record of `1336674354448` will be put at: +``` +test_bucket/test_files/2000/01/02/2000_01_32_12_03_04_1336674354448.gz +``` + +You may also omit `BIFROST_S3_KEY_SPACE` which will result in an object being put at: +```$xslt +test_bucket/2000/01/02/2000_01_32_12_03_04_1336674354448.gz +``` diff --git a/itests/common.bash b/itests/common.bash index 61e9b896..fd69e6ee 100644 --- a/itests/common.bash +++ b/itests/common.bash @@ -48,11 +48,19 @@ _startup() { log "Running docker-compose build" TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose build - log "Running docker-compose up" - TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose up -d + log "Starting docker-compose data-poller dependencies" + TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose up -d start-data-poller-dependencies + sleep 2 + + log "Starting docker-compose bifrost dependencies" + TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose up -d start-bifrost-dependencies + sleep 2 + + log "Starting docker-compose bifrost" + TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose up -d bifrost log "Checking that containers are running..." - sleep 5 + sleep 2 _check_container postgres _check_container localstack @@ -257,8 +265,8 @@ teardown() { # Print current state of the ledger for debugging TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose kill -s IO bifrost # dump ledger to stdout - sleep 5 TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose logs bifrost + TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose logs data-poller log "Running docker-compose down" TEST_NAME=$BATS_TEST_DESCRIPTION docker-compose down diff --git a/itests/containers/data-poller/app/poller-kinesis.py b/itests/containers/data-poller/app/poller-kinesis.py index e5d64900..376d14da 100644 --- a/itests/containers/data-poller/app/poller-kinesis.py +++ b/itests/containers/data-poller/app/poller-kinesis.py @@ -16,10 +16,10 @@ OUT_FILE = os.getenv('OUT_FILE', '/output/test') STREAM_NAME = os.getenv('STREAM_NAME', 'itests') ENDPOINT_URL = os.getenv('ENDPOINT_URL', 'http://localstack:4568') -WAIT_TIME = int(os.getenv('WAIT_TIME', '90')) -EXPECTED_COUNT = int(os.getenv('EXPECTED_COUNT', '1')) AWS_REGION = os.getenv('AWS_REGION', 'us-east-1') -SHARD_COUNT = int(os.getenv('SHARD_COUNT', '1')) +EXPECTED_COUNT = int(os.getenv('EXPECTED_COUNT', '1')) +WAIT_TIME = int(os.getenv('KINESIS_POLLER_WAIT_TIME', '90')) +SHARD_COUNT = int(os.getenv('KINESIS_POLLER_SHARD_COUNT', '1')) client = boto3.client('kinesis', endpoint_url=ENDPOINT_URL, diff --git a/itests/containers/data-poller/app/poller-s3.py b/itests/containers/data-poller/app/poller-s3.py new file mode 100644 index 00000000..dd5e17a6 --- /dev/null +++ b/itests/containers/data-poller/app/poller-s3.py @@ -0,0 +1,157 @@ +""" +This script obtains records from Kinesis and writes them to a local file as +as defined by OUT_FILE. It will exit when no additional files have been read for WAIT_TIME. +""" + +import os +import sys +import time + +import boto3 +from botocore import exceptions +from gzip import GzipFile +from io import BytesIO +from retry import retry + +# Variables +OUT_FILE = os.getenv('OUT_FILE', '/output/test') +BUCKET_NAME = os.getenv('BUCKET_NAME', 'itests') +CREATE_BUCKET = bool(os.getenv('CREATE_BUCKET', '1')) +ENDPOINT_URL = os.getenv('ENDPOINT_URL', 'http://localstack:4572') +AWS_REGION = os.getenv('AWS_REGION', 'us-east-1') +EXPECTED_COUNT = int(os.getenv('EXPECTED_COUNT', '1')) # expect number of records (only used for logging) +INITIAL_WAIT_TIME = int(os.getenv('S3_POLLER_INITIAL_WAIT_TIME', '90')) # time to wait for initial list of keys +WAIT_TIME = int(os.getenv('S3_POLLER_WAIT_TIME', '10')) # incremental time to wait for new keys if none have been seen +MAP_KEYS_TO_OUTPUT_FILES = bool(os.getenv('S3_POLLER_MAP_KEYS_TO_OUTPUT_FILES', '')) # whether to create a single output file + +client = boto3.client('s3', + endpoint_url=ENDPOINT_URL, + region_name=AWS_REGION) + +# Create a bucket +@retry(exceptions.EndpointConnectionError, tries=10, delay=.5) +def _create_bucket(name): + print("Trying to create bucket {}".format(name)) + return client.create_bucket( + Bucket=name) + + +@retry(ValueError, tries=10, delay=.5) +def _get_all_s3_keys(bucket): + """Get a list of all keys in an S3 bucket.""" + keys = [] + + resp = client.list_objects(Bucket=bucket) + + file_list = resp['Contents'] + + for s3_key in file_list: + keys.append(s3_key['Key']) + + return keys + + +if CREATE_BUCKET: + # Create the bucket + print("Creating a bucket") + try: + _create_bucket(BUCKET_NAME) + except exceptions.EndpointConnectionError: + print("Unable to contact endpoint at {}".format(ENDPOINT_URL)) + exit(1) + except exceptions.ClientError as e: + if e.response['Error']['Code'] != 'ResourceInUseException': + raise e + + +# get initial set of keys with a deadline of INITIAL_WAIT_TIME +all_keys = [] +timeout_for_first_keys = time.time() + INITIAL_WAIT_TIME + +while True: + if time.time() > timeout_for_first_keys: + print("No data received to poller. Exiting.") + exit(1) + + print("Getting initial keys list...") + sys.stdout.flush() + try: + all_keys = _get_all_s3_keys(BUCKET_NAME) + break + except KeyError: + time.sleep(1) + pass + +all_keys.sort() + +key_i = 0 +total = 0 + +print("Records expected: {}".format(EXPECTED_COUNT)) + +# Start the moving deadline and iterate over new keys +moving_deadline = time.time() + WAIT_TIME + + +while time.time() <= moving_deadline: + if key_i >= len(all_keys): + # our pointer is past the length of the keys we have seen, so we wait for more... + print("Waiting for more keys...") + sys.stdout.flush() + time.sleep(1) + + remote_keys = _get_all_s3_keys(BUCKET_NAME) + if len(remote_keys) > len(all_keys): + # if there are new keys, update our all_keys list and process + all_keys = list(set(all_keys + remote_keys)) + all_keys.sort() + + # update deadline as if we had new keys + moving_deadline = time.time() + WAIT_TIME + else: + # else, look back around + continue + + record_count = 0 + + # get object data + resp = client.get_object( + Bucket=BUCKET_NAME, + Key=all_keys[key_i], + ) + + bytestream = BytesIO(resp['Body'].read()) + got_text = GzipFile(None, 'rb', fileobj=bytestream).read().decode('utf-8') + records = got_text.split('\n') + + # filter out any empty lines + records = filter(None, records) + + sys.stdout.flush() + + # By default we only create a single file no matter how many S3 keys we have + _file_num = 0 + + if MAP_KEYS_TO_OUTPUT_FILES: + _file_num = key_i + + with open(OUT_FILE + "." + str(_file_num), "a") as fp: + for record in records: + fp.write(record) + fp.write('\n') + + fp.flush() + record_count += len(records) + + # update pointer in keys read + key_i += 1 + + total += record_count + print("total so far: {}".format(total)) + + if record_count == 0: + time.sleep(1) + sys.stdout.flush() + +print("Records read {}".format(total)) +sys.stdout.flush() diff --git a/itests/containers/defaults.env b/itests/containers/defaults.env index 5f25eb06..23f4a650 100644 --- a/itests/containers/defaults.env +++ b/itests/containers/defaults.env @@ -5,7 +5,6 @@ KINESIS_ERROR_PROBABILITY=0.0 PGHOST=postgres PGPASSWORD=pgbifrost CREATE_SLOT=true -BIFROST_KINESIS_STREAM=itests AWS_ACCESS_KEY_ID=DUMMYACCESSKEYID AWS_SECRET_ACCESS_KEY=DUMMYSECRETACCESSKEY AWS_REGION=us-east-1 diff --git a/itests/contexts/kinesis.env b/itests/contexts/kinesis.env index 81273ab1..c014a256 100644 --- a/itests/contexts/kinesis.env +++ b/itests/contexts/kinesis.env @@ -1,3 +1,6 @@ TRANSPORT_SINK=kinesis + LOCALSTACK_PORT=4568 ENDPOINT=http://localstack:4568 + +BIFROST_KINESIS_STREAM=itests diff --git a/itests/contexts/s3.env b/itests/contexts/s3.env new file mode 100644 index 00000000..f60a4e13 --- /dev/null +++ b/itests/contexts/s3.env @@ -0,0 +1,7 @@ +TRANSPORT_SINK=s3 + +LOCALSTACK_PORT=4572 +ENDPOINT=http://localstack:4572 +CREATE_BUCKET=1 + +BIFROST_S3_BUCKET=itests diff --git a/itests/docker-compose.yml b/itests/docker-compose.yml index bc1d8f38..f908260d 100644 --- a/itests/docker-compose.yml +++ b/itests/docker-compose.yml @@ -4,51 +4,73 @@ services: container_name: postgres build: containers/postgres volumes: - - "./tests/${TEST_NAME}/input:/input" + - "./tests/${TEST_NAME}/input:/input" environment: - - POSTGRES_PASSWORD=pgbifrost + - POSTGRES_PASSWORD=pgbifrost networks: - - net + - net localstack: container_name: localstack image: localstack/localstack:0.8.7 env_file: - - "./containers/defaults.env" - - "./tests/${TEST_NAME}/envfile.env" + - "./containers/defaults.env" + - "./tests/${TEST_NAME}/envfile.env" environment: - - SERVICES=${TRANSPORT_SINK} + - SERVICES=${TRANSPORT_SINK} ports: - - ${LOCALSTACK_PORT}:${LOCALSTACK_PORT} + - ${LOCALSTACK_PORT}:${LOCALSTACK_PORT} restart: always networks: - - net + - net - bifrost: - container_name: bifrost - image: pg-bifrost:latest + # data-poller needs localstack to be initialized to be able to call the local AWS service + # This container is intended to be started first by the caller and then data-poller + start-data-poller-dependencies: + image: alpine:3.8 + depends_on: + - localstack + command: sleep 300 + + data-poller: + container_name: data-poller + build: containers/data-poller + depends_on: + - start-data-poller-dependencies env_file: - - "./containers/defaults.env" - - "./tests/${TEST_NAME}/envfile.env" - - "./contexts/${TRANSPORT_SINK}.env" + - "./containers/defaults.env" + - "./tests/${TEST_NAME}/envfile.env" + - "./contexts/${TRANSPORT_SINK}.env" networks: net: aliases: - - localstack - - postgres - command: /pg-bifrost replicate ${TRANSPORT_SINK} + - localstack - data-poller: - container_name: data-poller - build: containers/data-poller + # bifrost needs postgres to be up, and for data-poller to have created sinks (e.g, s3 bucket, kinesis stream, etc) + # This container is intended to be started first by the caller and then bifrost + start-bifrost-dependencies: + image: alpine:3.8 + depends_on: + - postgres + - localstack + - data-poller + command: sleep 300 + + bifrost: + container_name: bifrost + image: pg-bifrost:latest + depends_on: + - start-bifrost-dependencies env_file: - - "./containers/defaults.env" - - "./tests/${TEST_NAME}/envfile.env" - - "./contexts/${TRANSPORT_SINK}.env" + - "./containers/defaults.env" + - "./tests/${TEST_NAME}/envfile.env" + - "./contexts/${TRANSPORT_SINK}.env" networks: net: aliases: - - localstack + - localstack + - postgres + command: /pg-bifrost replicate ${TRANSPORT_SINK} networks: net: diff --git a/itests/itests_runner.sh b/itests/itests_runner.sh index e680e92d..2f0aa306 100755 --- a/itests/itests_runner.sh +++ b/itests/itests_runner.sh @@ -14,33 +14,68 @@ # See the License for the specific language governing permissions and # limitations under the License. +set -e + +# Used to manually run itests against a single transport sink +ITESTS_TRANSPORT_SINK=${ITESTS_TRANSPORT_SINK:-} + get_testfiles() { _transport_sink=$1 if [ "$CI" == "true" ]; then _base_testfiles=$(cd tests/base && circleci tests glob "*" | circleci tests split --split-by=timings | sed -e 's/^/base\//') - _specific_testfiles=$(cd tests/${_transport_sink} && circleci tests glob "*" | circleci tests split --split-by=timings | sed -e "s/^/${_transport_sink}\//") + if [ -d "tests/${_transport_sink}" ]; then + _specific_testfiles=$(cd tests/${_transport_sink} && circleci tests glob "*" | circleci tests split --split-by=timings | sed -e "s/^/${_transport_sink}\//") + fi else _base_testfiles=$(cd tests/base && ls -d */ | sed 's#/##' | sed -e 's/^/base\//') - _specific_testfiles=$(cd tests/${_transport_sink} && ls -d */ | sed 's#/##' | sed -e "s/^/${_transport_sink}\//") + if [ -d "tests/${_transport_sink}" ]; then + _specific_testfiles=$(cd tests/${_transport_sink} && ls -d */ | sed 's#/##' | sed -e "s/^/${_transport_sink}\//") + fi fi echo "${_base_testfiles} ${_specific_testfiles}" } -# Kinesis -set -a ; . contexts/kinesis.env ; set +a +run_itests_on_transport_sink() { + _file=$1 + + # Source the transport sink's context + set -a ; . $_file ; set +a + + # Setup docker images & get test cases + TEST_NAME=base/test_basic docker-compose -f docker-compose.yml build + TESTFILES=$(get_testfiles $TRANSPORT_SINK) -TEST_NAME=base/test_basic docker-compose -f docker-compose.yml build -TESTFILES=$(get_testfiles $TRANSPORT_SINK) + # Start itests + echo '' ; echo '################################' + echo "Starting ${TRANSPORT_SINK} itests:" + echo '################################' ; echo '' -echo "TESTFILES:" -echo $TESTFILES | tr ' ' '\n' + echo "TESTFILES:" + echo $TESTFILES | tr ' ' '\n' ; echo '' -for TEST in $TESTFILES -do - echo "running test $TEST" - ./integration_tests.bats -r tests -f "$TEST" -done + for TEST in $TESTFILES + do + echo "running test $TEST" + ./integration_tests.bats -r tests -f "$TEST" + done + + echo '' ; echo '################################' + echo "${TRANSPORT_SINK} itests successful in this slice!" + echo '################################' ; echo '' + + echo "Cleaning up containers, volumes and environment variables..." + TEST_NAME=base/test_basic docker-compose -f docker-compose.yml rm -f -s -v + unset $(cat $_file | awk -F= '{print $1}' | xargs) +} -unset $(cat contexts/kinesis.env | awk -F= '{print $1}' | xargs) +# Start the itests +if [ ! -z "${ITESTS_TRANSPORT_SINK}" ] ; then + run_itests_on_transport_sink "contexts/${ITESTS_TRANSPORT_SINK}.env" +else + # Iterate through our transport sink contexts (e.g., kinesis, s3, etc.) + for file in ./contexts/*; do + run_itests_on_transport_sink $file + done +fi diff --git a/itests/tests/kinesis/test_table_partitioning/envfile.env b/itests/tests/base/test_table_partitioning/envfile.env similarity index 75% rename from itests/tests/kinesis/test_table_partitioning/envfile.env rename to itests/tests/base/test_table_partitioning/envfile.env index 4d97ede4..1b116863 100644 --- a/itests/tests/kinesis/test_table_partitioning/envfile.env +++ b/itests/tests/base/test_table_partitioning/envfile.env @@ -1,5 +1,5 @@ KINESIS_ERROR_PROBABILITY=0.5 EXPECTED_COUNT=2089 -SHARD_COUNT=2 +KINESIS_POLLER_SHARD_COUNT=2 WORKERS=4 PARTITION_METHOD=tablename diff --git a/itests/tests/kinesis/test_table_partitioning/golden/test.0 b/itests/tests/base/test_table_partitioning/golden/test.0 similarity index 100% rename from itests/tests/kinesis/test_table_partitioning/golden/test.0 rename to itests/tests/base/test_table_partitioning/golden/test.0 diff --git a/itests/tests/kinesis/test_table_partitioning/golden/test.1 b/itests/tests/base/test_table_partitioning/golden/test.1 similarity index 100% rename from itests/tests/kinesis/test_table_partitioning/golden/test.1 rename to itests/tests/base/test_table_partitioning/golden/test.1 diff --git a/itests/tests/kinesis/test_table_partitioning/input/001.sql b/itests/tests/base/test_table_partitioning/input/001.sql similarity index 100% rename from itests/tests/kinesis/test_table_partitioning/input/001.sql rename to itests/tests/base/test_table_partitioning/input/001.sql diff --git a/itests/tests/kinesis/test_table_partitioning/test.bats b/itests/tests/base/test_table_partitioning/test.bats similarity index 100% rename from itests/tests/kinesis/test_table_partitioning/test.bats rename to itests/tests/base/test_table_partitioning/test.bats diff --git a/itests/tests/kinesis/test_multi_worker_high_kinesis_errors/envfile.env b/itests/tests/kinesis/test_multi_worker_high_kinesis_errors/envfile.env index 537ee432..fc7d2c56 100644 --- a/itests/tests/kinesis/test_multi_worker_high_kinesis_errors/envfile.env +++ b/itests/tests/kinesis/test_multi_worker_high_kinesis_errors/envfile.env @@ -2,6 +2,6 @@ KINESIS_ERROR_PROBABILITY=0.5 BATCH_QUEUE_DEPTH=2 EXPECTED_COUNT=10000 WORKERS=4 -WAIT_TIME=120 +KINESIS_POLLER_WAIT_TIME=120 MEMPROFILE=/perf/mem.pprof CPUPROFILE=/perf/cpu.pprof \ No newline at end of file diff --git a/itests/tests/kinesis/test_strict_order_shared/envfile.env b/itests/tests/kinesis/test_strict_order_shared/envfile.env index d3d9fdf4..eac2a1a5 100644 --- a/itests/tests/kinesis/test_strict_order_shared/envfile.env +++ b/itests/tests/kinesis/test_strict_order_shared/envfile.env @@ -1,5 +1,5 @@ EXPECTED_COUNT=10000 -SHARD_COUNT=2 +KINESIS_POLLER_SHARD_COUNT=2 WORKERS=2 PARTITION_METHOD=transaction-bucket BATCHER_ROUTING_METHOD=partition diff --git a/itests/tests/base/test_txn_shard_partition/envfile.env b/itests/tests/kinesis/test_txn_shard_partition/envfile.env similarity index 76% rename from itests/tests/base/test_txn_shard_partition/envfile.env rename to itests/tests/kinesis/test_txn_shard_partition/envfile.env index c5133be4..3d6e6a48 100644 --- a/itests/tests/base/test_txn_shard_partition/envfile.env +++ b/itests/tests/kinesis/test_txn_shard_partition/envfile.env @@ -1,5 +1,5 @@ EXPECTED_COUNT=21 -SHARD_COUNT=2 +KINESIS_POLLER_SHARD_COUNT=2 WORKERS=3 PARTITION_METHOD=transaction BATCHER_ROUTING_METHOD=round-robin diff --git a/itests/tests/base/test_txn_shard_partition/golden/test.0 b/itests/tests/kinesis/test_txn_shard_partition/golden/test.0 similarity index 100% rename from itests/tests/base/test_txn_shard_partition/golden/test.0 rename to itests/tests/kinesis/test_txn_shard_partition/golden/test.0 diff --git a/itests/tests/base/test_txn_shard_partition/golden/test.1 b/itests/tests/kinesis/test_txn_shard_partition/golden/test.1 similarity index 100% rename from itests/tests/base/test_txn_shard_partition/golden/test.1 rename to itests/tests/kinesis/test_txn_shard_partition/golden/test.1 diff --git a/itests/tests/base/test_txn_shard_partition/input/001.sql b/itests/tests/kinesis/test_txn_shard_partition/input/001.sql similarity index 100% rename from itests/tests/base/test_txn_shard_partition/input/001.sql rename to itests/tests/kinesis/test_txn_shard_partition/input/001.sql diff --git a/itests/tests/base/test_txn_shard_partition/test.bats b/itests/tests/kinesis/test_txn_shard_partition/test.bats similarity index 100% rename from itests/tests/base/test_txn_shard_partition/test.bats rename to itests/tests/kinesis/test_txn_shard_partition/test.bats diff --git a/main/main.go b/main/main.go index ca00ef26..5c0108d3 100644 --- a/main/main.go +++ b/main/main.go @@ -19,9 +19,6 @@ package main import ( "errors" "fmt" - "github.com/Nextdoor/pg-bifrost.git/app/config" - "github.com/Nextdoor/pg-bifrost.git/partitioner" - "github.com/Nextdoor/pg-bifrost.git/transport/batcher" "os" "os/signal" "reflect" @@ -31,10 +28,15 @@ import ( "syscall" "time" + "github.com/Nextdoor/pg-bifrost.git/app/config" + "github.com/Nextdoor/pg-bifrost.git/partitioner" + "github.com/Nextdoor/pg-bifrost.git/transport/batcher" + "github.com/Nextdoor/pg-bifrost.git/app" "github.com/Nextdoor/pg-bifrost.git/transport" "github.com/Nextdoor/pg-bifrost.git/transport/transporters/kinesis" "github.com/Nextdoor/pg-bifrost.git/transport/transporters/rabbitmq" + "github.com/Nextdoor/pg-bifrost.git/transport/transporters/s3" "github.com/Nextdoor/pg-bifrost.git/utils" "github.com/Nextdoor/pg-bifrost.git/shutdown" @@ -465,6 +467,16 @@ func main() { kinesisCmd.Before = altsrc.InitInputSourceWithContext(kinesis.Flags, altsrc.NewYamlSourceFromFlagFunc("config")) kinesisCmd.Flags = kinesis.Flags + // Also set up s3 subcommands flags from file + s3Cmd := cli.Command{ + Name: "s3", + Usage: "replicate to s3", + Action: replicateAction, + } + + s3Cmd.Before = altsrc.InitInputSourceWithContext(s3.Flags, altsrc.NewYamlSourceFromFlagFunc("config")) + s3Cmd.Flags = s3.Flags + // Also set up rabbitmq subcommands flags from file rabbitmqCmd := cli.Command{ Name: "rabbitmq", @@ -591,6 +603,7 @@ func main() { Action: replicateAction, }, kinesisCmd, + s3Cmd, rabbitmqCmd, }, }, diff --git a/replication/client/conn/mocks/mock_client.go b/replication/client/conn/mocks/mock_client.go index 333c3caa..45d2c62b 100644 --- a/replication/client/conn/mocks/mock_client.go +++ b/replication/client/conn/mocks/mock_client.go @@ -36,7 +36,6 @@ func (m *MockConn) EXPECT() *MockConnMockRecorder { // Close mocks base method func (m *MockConn) Close() error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -44,13 +43,11 @@ func (m *MockConn) Close() error { // Close indicates an expected call of Close func (mr *MockConnMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConn)(nil).Close)) } // CreateReplicationSlot mocks base method func (m *MockConn) CreateReplicationSlot(arg0, arg1 string) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateReplicationSlot", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -58,13 +55,11 @@ func (m *MockConn) CreateReplicationSlot(arg0, arg1 string) error { // CreateReplicationSlot indicates an expected call of CreateReplicationSlot func (mr *MockConnMockRecorder) CreateReplicationSlot(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplicationSlot", reflect.TypeOf((*MockConn)(nil).CreateReplicationSlot), arg0, arg1) } // DropReplicationSlot mocks base method func (m *MockConn) DropReplicationSlot(arg0 string) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DropReplicationSlot", arg0) ret0, _ := ret[0].(error) return ret0 @@ -72,13 +67,11 @@ func (m *MockConn) DropReplicationSlot(arg0 string) error { // DropReplicationSlot indicates an expected call of DropReplicationSlot func (mr *MockConnMockRecorder) DropReplicationSlot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropReplicationSlot", reflect.TypeOf((*MockConn)(nil).DropReplicationSlot), arg0) } // IsAlive mocks base method func (m *MockConn) IsAlive() bool { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsAlive") ret0, _ := ret[0].(bool) return ret0 @@ -86,13 +79,11 @@ func (m *MockConn) IsAlive() bool { // IsAlive indicates an expected call of IsAlive func (mr *MockConnMockRecorder) IsAlive() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAlive", reflect.TypeOf((*MockConn)(nil).IsAlive)) } // SendStandbyStatus mocks base method func (m *MockConn) SendStandbyStatus(arg0 *pgx.StandbyStatus) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendStandbyStatus", arg0) ret0, _ := ret[0].(error) return ret0 @@ -100,13 +91,11 @@ func (m *MockConn) SendStandbyStatus(arg0 *pgx.StandbyStatus) error { // SendStandbyStatus indicates an expected call of SendStandbyStatus func (mr *MockConnMockRecorder) SendStandbyStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendStandbyStatus", reflect.TypeOf((*MockConn)(nil).SendStandbyStatus), arg0) } // StartReplication mocks base method func (m *MockConn) StartReplication(arg0 string, arg1 uint64, arg2 int64, arg3 ...string) error { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) @@ -118,14 +107,12 @@ func (m *MockConn) StartReplication(arg0 string, arg1 uint64, arg2 int64, arg3 . // StartReplication indicates an expected call of StartReplication func (mr *MockConnMockRecorder) StartReplication(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartReplication", reflect.TypeOf((*MockConn)(nil).StartReplication), varargs...) } // WaitForReplicationMessage mocks base method func (m *MockConn) WaitForReplicationMessage(arg0 context.Context) (*pgx.ReplicationMessage, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WaitForReplicationMessage", arg0) ret0, _ := ret[0].(*pgx.ReplicationMessage) ret1, _ := ret[1].(error) @@ -134,6 +121,5 @@ func (m *MockConn) WaitForReplicationMessage(arg0 context.Context) (*pgx.Replica // WaitForReplicationMessage indicates an expected call of WaitForReplicationMessage func (mr *MockConnMockRecorder) WaitForReplicationMessage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForReplicationMessage", reflect.TypeOf((*MockConn)(nil).WaitForReplicationMessage), arg0) } diff --git a/replication/client/conn/mocks/mock_manager.go b/replication/client/conn/mocks/mock_manager.go index a80376d4..5913f90e 100644 --- a/replication/client/conn/mocks/mock_manager.go +++ b/replication/client/conn/mocks/mock_manager.go @@ -35,19 +35,16 @@ func (m *MockManagerInterface) EXPECT() *MockManagerInterfaceMockRecorder { // Close mocks base method func (m *MockManagerInterface) Close() { - m.ctrl.T.Helper() m.ctrl.Call(m, "Close") } // Close indicates an expected call of Close func (mr *MockManagerInterfaceMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockManagerInterface)(nil).Close)) } // GetConn mocks base method func (m *MockManagerInterface) GetConn() (conn.Conn, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetConn") ret0, _ := ret[0].(conn.Conn) ret1, _ := ret[1].(error) @@ -56,6 +53,5 @@ func (m *MockManagerInterface) GetConn() (conn.Conn, error) { // GetConn indicates an expected call of GetConn func (mr *MockManagerInterfaceMockRecorder) GetConn() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConn", reflect.TypeOf((*MockManagerInterface)(nil).GetConn)) } diff --git a/transport/factory/factory.go b/transport/factory/factory.go index b97c750d..0058f1dc 100644 --- a/transport/factory/factory.go +++ b/transport/factory/factory.go @@ -2,6 +2,8 @@ package factory import ( "github.com/Nextdoor/pg-bifrost.git/transport/progress" + "github.com/Nextdoor/pg-bifrost.git/transport/transporters/s3" + "os" "github.com/Nextdoor/pg-bifrost.git/marshaller" @@ -14,8 +16,8 @@ import ( "github.com/Nextdoor/pg-bifrost.git/shutdown" "github.com/Nextdoor/pg-bifrost.git/stats" "github.com/Nextdoor/pg-bifrost.git/transport/batch" - "github.com/sirupsen/logrus" "github.com/cevaris/ordered_map" + "github.com/sirupsen/logrus" ) var ( @@ -53,6 +55,8 @@ func NewTransport(shutdownHandler shutdown.ShutdownHandler, batchFactory = batch.NewGenericBatchFactory(1) case transport.KINESIS: batchFactory = kinesis.NewBatchFactory(transportConfig) + case transport.S3: + batchFactory = s3.NewBatchFactory(transportConfig) case transport.RABBITMQ: batchFactory = rabbitmq.NewBatchFactory(transportConfig) default: @@ -84,6 +88,8 @@ func NewTransport(shutdownHandler shutdown.ShutdownHandler, t = stdout.New(shutdownHandler, txnsWritten, statsChan, workers, transportInputChans) case transport.KINESIS: t = kinesis.New(shutdownHandler, txnsWritten, statsChan, workers, transportInputChans, transportConfig) + case transport.S3: + t = s3.New(shutdownHandler, txnsWritten, statsChan, workers, transportInputChans, transportConfig) case transport.RABBITMQ: t = rabbitmq.New(shutdownHandler, txnsWritten, statsChan, workers, transportInputChans, transportConfig) default: diff --git a/transport/interfaces.go b/transport/interfaces.go index d867cb1c..6a4e1570 100644 --- a/transport/interfaces.go +++ b/transport/interfaces.go @@ -26,6 +26,7 @@ type TransportType string const ( STDOUT TransportType = "stdout" KINESIS TransportType = "kinesis" + S3 TransportType = "s3" RABBITMQ TransportType = "rabbitmq" ) diff --git a/transport/mocks/mock_batch.go b/transport/mocks/mock_batch.go index 1a26dc0b..f0ce5971 100644 --- a/transport/mocks/mock_batch.go +++ b/transport/mocks/mock_batch.go @@ -37,7 +37,6 @@ func (m *MockBatch) EXPECT() *MockBatchMockRecorder { // Add mocks base method func (m *MockBatch) Add(arg0 *marshaller.MarshalledMessage) (bool, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Add", arg0) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) @@ -46,13 +45,11 @@ func (m *MockBatch) Add(arg0 *marshaller.MarshalledMessage) (bool, error) { // Add indicates an expected call of Add func (mr *MockBatchMockRecorder) Add(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockBatch)(nil).Add), arg0) } // Close mocks base method func (m *MockBatch) Close() (bool, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) @@ -61,13 +58,11 @@ func (m *MockBatch) Close() (bool, error) { // Close indicates an expected call of Close func (mr *MockBatchMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockBatch)(nil).Close)) } // CreateTime mocks base method func (m *MockBatch) CreateTime() int64 { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTime") ret0, _ := ret[0].(int64) return ret0 @@ -75,13 +70,11 @@ func (m *MockBatch) CreateTime() int64 { // CreateTime indicates an expected call of CreateTime func (mr *MockBatchMockRecorder) CreateTime() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTime", reflect.TypeOf((*MockBatch)(nil).CreateTime)) } // GetPartitionKey mocks base method func (m *MockBatch) GetPartitionKey() string { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPartitionKey") ret0, _ := ret[0].(string) return ret0 @@ -89,13 +82,11 @@ func (m *MockBatch) GetPartitionKey() string { // GetPartitionKey indicates an expected call of GetPartitionKey func (mr *MockBatchMockRecorder) GetPartitionKey() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPartitionKey", reflect.TypeOf((*MockBatch)(nil).GetPartitionKey)) } // GetPayload mocks base method func (m *MockBatch) GetPayload() interface{} { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPayload") ret0, _ := ret[0].(interface{}) return ret0 @@ -103,13 +94,11 @@ func (m *MockBatch) GetPayload() interface{} { // GetPayload indicates an expected call of GetPayload func (mr *MockBatchMockRecorder) GetPayload() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPayload", reflect.TypeOf((*MockBatch)(nil).GetPayload)) } // GetPayloadByteSize mocks base method func (m *MockBatch) GetPayloadByteSize() int64 { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPayloadByteSize") ret0, _ := ret[0].(int64) return ret0 @@ -117,13 +106,11 @@ func (m *MockBatch) GetPayloadByteSize() int64 { // GetPayloadByteSize indicates an expected call of GetPayloadByteSize func (mr *MockBatchMockRecorder) GetPayloadByteSize() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPayloadByteSize", reflect.TypeOf((*MockBatch)(nil).GetPayloadByteSize)) } // GetTransactions mocks base method func (m *MockBatch) GetTransactions() *ordered_map.OrderedMap { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTransactions") ret0, _ := ret[0].(*ordered_map.OrderedMap) return ret0 @@ -131,13 +118,11 @@ func (m *MockBatch) GetTransactions() *ordered_map.OrderedMap { // GetTransactions indicates an expected call of GetTransactions func (mr *MockBatchMockRecorder) GetTransactions() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactions", reflect.TypeOf((*MockBatch)(nil).GetTransactions)) } // IsEmpty mocks base method func (m *MockBatch) IsEmpty() bool { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsEmpty") ret0, _ := ret[0].(bool) return ret0 @@ -145,13 +130,11 @@ func (m *MockBatch) IsEmpty() bool { // IsEmpty indicates an expected call of IsEmpty func (mr *MockBatchMockRecorder) IsEmpty() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEmpty", reflect.TypeOf((*MockBatch)(nil).IsEmpty)) } // IsFull mocks base method func (m *MockBatch) IsFull() bool { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsFull") ret0, _ := ret[0].(bool) return ret0 @@ -159,13 +142,11 @@ func (m *MockBatch) IsFull() bool { // IsFull indicates an expected call of IsFull func (mr *MockBatchMockRecorder) IsFull() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsFull", reflect.TypeOf((*MockBatch)(nil).IsFull)) } // ModifyTime mocks base method func (m *MockBatch) ModifyTime() int64 { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ModifyTime") ret0, _ := ret[0].(int64) return ret0 @@ -173,13 +154,11 @@ func (m *MockBatch) ModifyTime() int64 { // ModifyTime indicates an expected call of ModifyTime func (mr *MockBatchMockRecorder) ModifyTime() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTime", reflect.TypeOf((*MockBatch)(nil).ModifyTime)) } // NumMessages mocks base method func (m *MockBatch) NumMessages() int { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NumMessages") ret0, _ := ret[0].(int) return ret0 @@ -187,7 +166,6 @@ func (m *MockBatch) NumMessages() int { // NumMessages indicates an expected call of NumMessages func (mr *MockBatchMockRecorder) NumMessages() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumMessages", reflect.TypeOf((*MockBatch)(nil).NumMessages)) } @@ -216,7 +194,6 @@ func (m *MockBatchFactory) EXPECT() *MockBatchFactoryMockRecorder { // NewBatch mocks base method func (m *MockBatchFactory) NewBatch(arg0 string) transport.Batch { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NewBatch", arg0) ret0, _ := ret[0].(transport.Batch) return ret0 @@ -224,6 +201,5 @@ func (m *MockBatchFactory) NewBatch(arg0 string) transport.Batch { // NewBatch indicates an expected call of NewBatch func (mr *MockBatchFactoryMockRecorder) NewBatch(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBatch", reflect.TypeOf((*MockBatchFactory)(nil).NewBatch), arg0) } diff --git a/transport/transporters/kinesis/transporter/mocks/mock_kinesis.go b/transport/transporters/kinesis/transporter/mocks/mock_kinesis.go index 17a26b51..838a4044 100644 --- a/transport/transporters/kinesis/transporter/mocks/mock_kinesis.go +++ b/transport/transporters/kinesis/transporter/mocks/mock_kinesis.go @@ -37,7 +37,6 @@ func (m *MockKinesisAPI) EXPECT() *MockKinesisAPIMockRecorder { // AddTagsToStream mocks base method func (m *MockKinesisAPI) AddTagsToStream(arg0 *kinesis.AddTagsToStreamInput) (*kinesis.AddTagsToStreamOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddTagsToStream", arg0) ret0, _ := ret[0].(*kinesis.AddTagsToStreamOutput) ret1, _ := ret[1].(error) @@ -46,13 +45,11 @@ func (m *MockKinesisAPI) AddTagsToStream(arg0 *kinesis.AddTagsToStreamInput) (*k // AddTagsToStream indicates an expected call of AddTagsToStream func (mr *MockKinesisAPIMockRecorder) AddTagsToStream(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToStream", reflect.TypeOf((*MockKinesisAPI)(nil).AddTagsToStream), arg0) } // AddTagsToStreamRequest mocks base method func (m *MockKinesisAPI) AddTagsToStreamRequest(arg0 *kinesis.AddTagsToStreamInput) (*request.Request, *kinesis.AddTagsToStreamOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddTagsToStreamRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.AddTagsToStreamOutput) @@ -61,13 +58,11 @@ func (m *MockKinesisAPI) AddTagsToStreamRequest(arg0 *kinesis.AddTagsToStreamInp // AddTagsToStreamRequest indicates an expected call of AddTagsToStreamRequest func (mr *MockKinesisAPIMockRecorder) AddTagsToStreamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToStreamRequest", reflect.TypeOf((*MockKinesisAPI)(nil).AddTagsToStreamRequest), arg0) } // AddTagsToStreamWithContext mocks base method func (m *MockKinesisAPI) AddTagsToStreamWithContext(arg0 aws.Context, arg1 *kinesis.AddTagsToStreamInput, arg2 ...request.Option) (*kinesis.AddTagsToStreamOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -80,14 +75,12 @@ func (m *MockKinesisAPI) AddTagsToStreamWithContext(arg0 aws.Context, arg1 *kine // AddTagsToStreamWithContext indicates an expected call of AddTagsToStreamWithContext func (mr *MockKinesisAPIMockRecorder) AddTagsToStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToStreamWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).AddTagsToStreamWithContext), varargs...) } // CreateStream mocks base method func (m *MockKinesisAPI) CreateStream(arg0 *kinesis.CreateStreamInput) (*kinesis.CreateStreamOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateStream", arg0) ret0, _ := ret[0].(*kinesis.CreateStreamOutput) ret1, _ := ret[1].(error) @@ -96,13 +89,11 @@ func (m *MockKinesisAPI) CreateStream(arg0 *kinesis.CreateStreamInput) (*kinesis // CreateStream indicates an expected call of CreateStream func (mr *MockKinesisAPIMockRecorder) CreateStream(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStream", reflect.TypeOf((*MockKinesisAPI)(nil).CreateStream), arg0) } // CreateStreamRequest mocks base method func (m *MockKinesisAPI) CreateStreamRequest(arg0 *kinesis.CreateStreamInput) (*request.Request, *kinesis.CreateStreamOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateStreamRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.CreateStreamOutput) @@ -111,13 +102,11 @@ func (m *MockKinesisAPI) CreateStreamRequest(arg0 *kinesis.CreateStreamInput) (* // CreateStreamRequest indicates an expected call of CreateStreamRequest func (mr *MockKinesisAPIMockRecorder) CreateStreamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStreamRequest", reflect.TypeOf((*MockKinesisAPI)(nil).CreateStreamRequest), arg0) } // CreateStreamWithContext mocks base method func (m *MockKinesisAPI) CreateStreamWithContext(arg0 aws.Context, arg1 *kinesis.CreateStreamInput, arg2 ...request.Option) (*kinesis.CreateStreamOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -130,14 +119,12 @@ func (m *MockKinesisAPI) CreateStreamWithContext(arg0 aws.Context, arg1 *kinesis // CreateStreamWithContext indicates an expected call of CreateStreamWithContext func (mr *MockKinesisAPIMockRecorder) CreateStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStreamWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).CreateStreamWithContext), varargs...) } // DecreaseStreamRetentionPeriod mocks base method func (m *MockKinesisAPI) DecreaseStreamRetentionPeriod(arg0 *kinesis.DecreaseStreamRetentionPeriodInput) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DecreaseStreamRetentionPeriod", arg0) ret0, _ := ret[0].(*kinesis.DecreaseStreamRetentionPeriodOutput) ret1, _ := ret[1].(error) @@ -146,13 +133,11 @@ func (m *MockKinesisAPI) DecreaseStreamRetentionPeriod(arg0 *kinesis.DecreaseStr // DecreaseStreamRetentionPeriod indicates an expected call of DecreaseStreamRetentionPeriod func (mr *MockKinesisAPIMockRecorder) DecreaseStreamRetentionPeriod(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecreaseStreamRetentionPeriod", reflect.TypeOf((*MockKinesisAPI)(nil).DecreaseStreamRetentionPeriod), arg0) } // DecreaseStreamRetentionPeriodRequest mocks base method func (m *MockKinesisAPI) DecreaseStreamRetentionPeriodRequest(arg0 *kinesis.DecreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.DecreaseStreamRetentionPeriodOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DecreaseStreamRetentionPeriodRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DecreaseStreamRetentionPeriodOutput) @@ -161,13 +146,11 @@ func (m *MockKinesisAPI) DecreaseStreamRetentionPeriodRequest(arg0 *kinesis.Decr // DecreaseStreamRetentionPeriodRequest indicates an expected call of DecreaseStreamRetentionPeriodRequest func (mr *MockKinesisAPIMockRecorder) DecreaseStreamRetentionPeriodRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecreaseStreamRetentionPeriodRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DecreaseStreamRetentionPeriodRequest), arg0) } // DecreaseStreamRetentionPeriodWithContext mocks base method func (m *MockKinesisAPI) DecreaseStreamRetentionPeriodWithContext(arg0 aws.Context, arg1 *kinesis.DecreaseStreamRetentionPeriodInput, arg2 ...request.Option) (*kinesis.DecreaseStreamRetentionPeriodOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -180,14 +163,12 @@ func (m *MockKinesisAPI) DecreaseStreamRetentionPeriodWithContext(arg0 aws.Conte // DecreaseStreamRetentionPeriodWithContext indicates an expected call of DecreaseStreamRetentionPeriodWithContext func (mr *MockKinesisAPIMockRecorder) DecreaseStreamRetentionPeriodWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecreaseStreamRetentionPeriodWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DecreaseStreamRetentionPeriodWithContext), varargs...) } // DeleteStream mocks base method func (m *MockKinesisAPI) DeleteStream(arg0 *kinesis.DeleteStreamInput) (*kinesis.DeleteStreamOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteStream", arg0) ret0, _ := ret[0].(*kinesis.DeleteStreamOutput) ret1, _ := ret[1].(error) @@ -196,13 +177,11 @@ func (m *MockKinesisAPI) DeleteStream(arg0 *kinesis.DeleteStreamInput) (*kinesis // DeleteStream indicates an expected call of DeleteStream func (mr *MockKinesisAPIMockRecorder) DeleteStream(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStream", reflect.TypeOf((*MockKinesisAPI)(nil).DeleteStream), arg0) } // DeleteStreamRequest mocks base method func (m *MockKinesisAPI) DeleteStreamRequest(arg0 *kinesis.DeleteStreamInput) (*request.Request, *kinesis.DeleteStreamOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteStreamRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DeleteStreamOutput) @@ -211,13 +190,11 @@ func (m *MockKinesisAPI) DeleteStreamRequest(arg0 *kinesis.DeleteStreamInput) (* // DeleteStreamRequest indicates an expected call of DeleteStreamRequest func (mr *MockKinesisAPIMockRecorder) DeleteStreamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStreamRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DeleteStreamRequest), arg0) } // DeleteStreamWithContext mocks base method func (m *MockKinesisAPI) DeleteStreamWithContext(arg0 aws.Context, arg1 *kinesis.DeleteStreamInput, arg2 ...request.Option) (*kinesis.DeleteStreamOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -230,14 +207,12 @@ func (m *MockKinesisAPI) DeleteStreamWithContext(arg0 aws.Context, arg1 *kinesis // DeleteStreamWithContext indicates an expected call of DeleteStreamWithContext func (mr *MockKinesisAPIMockRecorder) DeleteStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStreamWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DeleteStreamWithContext), varargs...) } // DeregisterStreamConsumer mocks base method func (m *MockKinesisAPI) DeregisterStreamConsumer(arg0 *kinesis.DeregisterStreamConsumerInput) (*kinesis.DeregisterStreamConsumerOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeregisterStreamConsumer", arg0) ret0, _ := ret[0].(*kinesis.DeregisterStreamConsumerOutput) ret1, _ := ret[1].(error) @@ -246,13 +221,11 @@ func (m *MockKinesisAPI) DeregisterStreamConsumer(arg0 *kinesis.DeregisterStream // DeregisterStreamConsumer indicates an expected call of DeregisterStreamConsumer func (mr *MockKinesisAPIMockRecorder) DeregisterStreamConsumer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterStreamConsumer", reflect.TypeOf((*MockKinesisAPI)(nil).DeregisterStreamConsumer), arg0) } // DeregisterStreamConsumerRequest mocks base method func (m *MockKinesisAPI) DeregisterStreamConsumerRequest(arg0 *kinesis.DeregisterStreamConsumerInput) (*request.Request, *kinesis.DeregisterStreamConsumerOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeregisterStreamConsumerRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DeregisterStreamConsumerOutput) @@ -261,13 +234,11 @@ func (m *MockKinesisAPI) DeregisterStreamConsumerRequest(arg0 *kinesis.Deregiste // DeregisterStreamConsumerRequest indicates an expected call of DeregisterStreamConsumerRequest func (mr *MockKinesisAPIMockRecorder) DeregisterStreamConsumerRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterStreamConsumerRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DeregisterStreamConsumerRequest), arg0) } // DeregisterStreamConsumerWithContext mocks base method func (m *MockKinesisAPI) DeregisterStreamConsumerWithContext(arg0 aws.Context, arg1 *kinesis.DeregisterStreamConsumerInput, arg2 ...request.Option) (*kinesis.DeregisterStreamConsumerOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -280,14 +251,12 @@ func (m *MockKinesisAPI) DeregisterStreamConsumerWithContext(arg0 aws.Context, a // DeregisterStreamConsumerWithContext indicates an expected call of DeregisterStreamConsumerWithContext func (mr *MockKinesisAPIMockRecorder) DeregisterStreamConsumerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterStreamConsumerWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DeregisterStreamConsumerWithContext), varargs...) } // DescribeLimits mocks base method func (m *MockKinesisAPI) DescribeLimits(arg0 *kinesis.DescribeLimitsInput) (*kinesis.DescribeLimitsOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeLimits", arg0) ret0, _ := ret[0].(*kinesis.DescribeLimitsOutput) ret1, _ := ret[1].(error) @@ -296,13 +265,11 @@ func (m *MockKinesisAPI) DescribeLimits(arg0 *kinesis.DescribeLimitsInput) (*kin // DescribeLimits indicates an expected call of DescribeLimits func (mr *MockKinesisAPIMockRecorder) DescribeLimits(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimits", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeLimits), arg0) } // DescribeLimitsRequest mocks base method func (m *MockKinesisAPI) DescribeLimitsRequest(arg0 *kinesis.DescribeLimitsInput) (*request.Request, *kinesis.DescribeLimitsOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeLimitsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DescribeLimitsOutput) @@ -311,13 +278,11 @@ func (m *MockKinesisAPI) DescribeLimitsRequest(arg0 *kinesis.DescribeLimitsInput // DescribeLimitsRequest indicates an expected call of DescribeLimitsRequest func (mr *MockKinesisAPIMockRecorder) DescribeLimitsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimitsRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeLimitsRequest), arg0) } // DescribeLimitsWithContext mocks base method func (m *MockKinesisAPI) DescribeLimitsWithContext(arg0 aws.Context, arg1 *kinesis.DescribeLimitsInput, arg2 ...request.Option) (*kinesis.DescribeLimitsOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -330,14 +295,12 @@ func (m *MockKinesisAPI) DescribeLimitsWithContext(arg0 aws.Context, arg1 *kines // DescribeLimitsWithContext indicates an expected call of DescribeLimitsWithContext func (mr *MockKinesisAPIMockRecorder) DescribeLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimitsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeLimitsWithContext), varargs...) } // DescribeStream mocks base method func (m *MockKinesisAPI) DescribeStream(arg0 *kinesis.DescribeStreamInput) (*kinesis.DescribeStreamOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStream", arg0) ret0, _ := ret[0].(*kinesis.DescribeStreamOutput) ret1, _ := ret[1].(error) @@ -346,13 +309,11 @@ func (m *MockKinesisAPI) DescribeStream(arg0 *kinesis.DescribeStreamInput) (*kin // DescribeStream indicates an expected call of DescribeStream func (mr *MockKinesisAPIMockRecorder) DescribeStream(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStream", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStream), arg0) } // DescribeStreamConsumer mocks base method func (m *MockKinesisAPI) DescribeStreamConsumer(arg0 *kinesis.DescribeStreamConsumerInput) (*kinesis.DescribeStreamConsumerOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStreamConsumer", arg0) ret0, _ := ret[0].(*kinesis.DescribeStreamConsumerOutput) ret1, _ := ret[1].(error) @@ -361,13 +322,11 @@ func (m *MockKinesisAPI) DescribeStreamConsumer(arg0 *kinesis.DescribeStreamCons // DescribeStreamConsumer indicates an expected call of DescribeStreamConsumer func (mr *MockKinesisAPIMockRecorder) DescribeStreamConsumer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamConsumer", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamConsumer), arg0) } // DescribeStreamConsumerRequest mocks base method func (m *MockKinesisAPI) DescribeStreamConsumerRequest(arg0 *kinesis.DescribeStreamConsumerInput) (*request.Request, *kinesis.DescribeStreamConsumerOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStreamConsumerRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DescribeStreamConsumerOutput) @@ -376,13 +335,11 @@ func (m *MockKinesisAPI) DescribeStreamConsumerRequest(arg0 *kinesis.DescribeStr // DescribeStreamConsumerRequest indicates an expected call of DescribeStreamConsumerRequest func (mr *MockKinesisAPIMockRecorder) DescribeStreamConsumerRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamConsumerRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamConsumerRequest), arg0) } // DescribeStreamConsumerWithContext mocks base method func (m *MockKinesisAPI) DescribeStreamConsumerWithContext(arg0 aws.Context, arg1 *kinesis.DescribeStreamConsumerInput, arg2 ...request.Option) (*kinesis.DescribeStreamConsumerOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -395,14 +352,12 @@ func (m *MockKinesisAPI) DescribeStreamConsumerWithContext(arg0 aws.Context, arg // DescribeStreamConsumerWithContext indicates an expected call of DescribeStreamConsumerWithContext func (mr *MockKinesisAPIMockRecorder) DescribeStreamConsumerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamConsumerWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamConsumerWithContext), varargs...) } // DescribeStreamPages mocks base method func (m *MockKinesisAPI) DescribeStreamPages(arg0 *kinesis.DescribeStreamInput, arg1 func(*kinesis.DescribeStreamOutput, bool) bool) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStreamPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -410,13 +365,11 @@ func (m *MockKinesisAPI) DescribeStreamPages(arg0 *kinesis.DescribeStreamInput, // DescribeStreamPages indicates an expected call of DescribeStreamPages func (mr *MockKinesisAPIMockRecorder) DescribeStreamPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamPages", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamPages), arg0, arg1) } // DescribeStreamPagesWithContext mocks base method func (m *MockKinesisAPI) DescribeStreamPagesWithContext(arg0 aws.Context, arg1 *kinesis.DescribeStreamInput, arg2 func(*kinesis.DescribeStreamOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) @@ -428,14 +381,12 @@ func (m *MockKinesisAPI) DescribeStreamPagesWithContext(arg0 aws.Context, arg1 * // DescribeStreamPagesWithContext indicates an expected call of DescribeStreamPagesWithContext func (mr *MockKinesisAPIMockRecorder) DescribeStreamPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamPagesWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamPagesWithContext), varargs...) } // DescribeStreamRequest mocks base method func (m *MockKinesisAPI) DescribeStreamRequest(arg0 *kinesis.DescribeStreamInput) (*request.Request, *kinesis.DescribeStreamOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStreamRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DescribeStreamOutput) @@ -444,13 +395,11 @@ func (m *MockKinesisAPI) DescribeStreamRequest(arg0 *kinesis.DescribeStreamInput // DescribeStreamRequest indicates an expected call of DescribeStreamRequest func (mr *MockKinesisAPIMockRecorder) DescribeStreamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamRequest), arg0) } // DescribeStreamSummary mocks base method func (m *MockKinesisAPI) DescribeStreamSummary(arg0 *kinesis.DescribeStreamSummaryInput) (*kinesis.DescribeStreamSummaryOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStreamSummary", arg0) ret0, _ := ret[0].(*kinesis.DescribeStreamSummaryOutput) ret1, _ := ret[1].(error) @@ -459,13 +408,11 @@ func (m *MockKinesisAPI) DescribeStreamSummary(arg0 *kinesis.DescribeStreamSumma // DescribeStreamSummary indicates an expected call of DescribeStreamSummary func (mr *MockKinesisAPIMockRecorder) DescribeStreamSummary(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamSummary", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamSummary), arg0) } // DescribeStreamSummaryRequest mocks base method func (m *MockKinesisAPI) DescribeStreamSummaryRequest(arg0 *kinesis.DescribeStreamSummaryInput) (*request.Request, *kinesis.DescribeStreamSummaryOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeStreamSummaryRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.DescribeStreamSummaryOutput) @@ -474,13 +421,11 @@ func (m *MockKinesisAPI) DescribeStreamSummaryRequest(arg0 *kinesis.DescribeStre // DescribeStreamSummaryRequest indicates an expected call of DescribeStreamSummaryRequest func (mr *MockKinesisAPIMockRecorder) DescribeStreamSummaryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamSummaryRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamSummaryRequest), arg0) } // DescribeStreamSummaryWithContext mocks base method func (m *MockKinesisAPI) DescribeStreamSummaryWithContext(arg0 aws.Context, arg1 *kinesis.DescribeStreamSummaryInput, arg2 ...request.Option) (*kinesis.DescribeStreamSummaryOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -493,14 +438,12 @@ func (m *MockKinesisAPI) DescribeStreamSummaryWithContext(arg0 aws.Context, arg1 // DescribeStreamSummaryWithContext indicates an expected call of DescribeStreamSummaryWithContext func (mr *MockKinesisAPIMockRecorder) DescribeStreamSummaryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamSummaryWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamSummaryWithContext), varargs...) } // DescribeStreamWithContext mocks base method func (m *MockKinesisAPI) DescribeStreamWithContext(arg0 aws.Context, arg1 *kinesis.DescribeStreamInput, arg2 ...request.Option) (*kinesis.DescribeStreamOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -513,14 +456,12 @@ func (m *MockKinesisAPI) DescribeStreamWithContext(arg0 aws.Context, arg1 *kines // DescribeStreamWithContext indicates an expected call of DescribeStreamWithContext func (mr *MockKinesisAPIMockRecorder) DescribeStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStreamWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DescribeStreamWithContext), varargs...) } // DisableEnhancedMonitoring mocks base method func (m *MockKinesisAPI) DisableEnhancedMonitoring(arg0 *kinesis.DisableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DisableEnhancedMonitoring", arg0) ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput) ret1, _ := ret[1].(error) @@ -529,13 +470,11 @@ func (m *MockKinesisAPI) DisableEnhancedMonitoring(arg0 *kinesis.DisableEnhanced // DisableEnhancedMonitoring indicates an expected call of DisableEnhancedMonitoring func (mr *MockKinesisAPIMockRecorder) DisableEnhancedMonitoring(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEnhancedMonitoring", reflect.TypeOf((*MockKinesisAPI)(nil).DisableEnhancedMonitoring), arg0) } // DisableEnhancedMonitoringRequest mocks base method func (m *MockKinesisAPI) DisableEnhancedMonitoringRequest(arg0 *kinesis.DisableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DisableEnhancedMonitoringRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.EnhancedMonitoringOutput) @@ -544,13 +483,11 @@ func (m *MockKinesisAPI) DisableEnhancedMonitoringRequest(arg0 *kinesis.DisableE // DisableEnhancedMonitoringRequest indicates an expected call of DisableEnhancedMonitoringRequest func (mr *MockKinesisAPIMockRecorder) DisableEnhancedMonitoringRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEnhancedMonitoringRequest", reflect.TypeOf((*MockKinesisAPI)(nil).DisableEnhancedMonitoringRequest), arg0) } // DisableEnhancedMonitoringWithContext mocks base method func (m *MockKinesisAPI) DisableEnhancedMonitoringWithContext(arg0 aws.Context, arg1 *kinesis.DisableEnhancedMonitoringInput, arg2 ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -563,14 +500,12 @@ func (m *MockKinesisAPI) DisableEnhancedMonitoringWithContext(arg0 aws.Context, // DisableEnhancedMonitoringWithContext indicates an expected call of DisableEnhancedMonitoringWithContext func (mr *MockKinesisAPIMockRecorder) DisableEnhancedMonitoringWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEnhancedMonitoringWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).DisableEnhancedMonitoringWithContext), varargs...) } // EnableEnhancedMonitoring mocks base method func (m *MockKinesisAPI) EnableEnhancedMonitoring(arg0 *kinesis.EnableEnhancedMonitoringInput) (*kinesis.EnhancedMonitoringOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EnableEnhancedMonitoring", arg0) ret0, _ := ret[0].(*kinesis.EnhancedMonitoringOutput) ret1, _ := ret[1].(error) @@ -579,13 +514,11 @@ func (m *MockKinesisAPI) EnableEnhancedMonitoring(arg0 *kinesis.EnableEnhancedMo // EnableEnhancedMonitoring indicates an expected call of EnableEnhancedMonitoring func (mr *MockKinesisAPIMockRecorder) EnableEnhancedMonitoring(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEnhancedMonitoring", reflect.TypeOf((*MockKinesisAPI)(nil).EnableEnhancedMonitoring), arg0) } // EnableEnhancedMonitoringRequest mocks base method func (m *MockKinesisAPI) EnableEnhancedMonitoringRequest(arg0 *kinesis.EnableEnhancedMonitoringInput) (*request.Request, *kinesis.EnhancedMonitoringOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EnableEnhancedMonitoringRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.EnhancedMonitoringOutput) @@ -594,13 +527,11 @@ func (m *MockKinesisAPI) EnableEnhancedMonitoringRequest(arg0 *kinesis.EnableEnh // EnableEnhancedMonitoringRequest indicates an expected call of EnableEnhancedMonitoringRequest func (mr *MockKinesisAPIMockRecorder) EnableEnhancedMonitoringRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEnhancedMonitoringRequest", reflect.TypeOf((*MockKinesisAPI)(nil).EnableEnhancedMonitoringRequest), arg0) } // EnableEnhancedMonitoringWithContext mocks base method func (m *MockKinesisAPI) EnableEnhancedMonitoringWithContext(arg0 aws.Context, arg1 *kinesis.EnableEnhancedMonitoringInput, arg2 ...request.Option) (*kinesis.EnhancedMonitoringOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -613,14 +544,12 @@ func (m *MockKinesisAPI) EnableEnhancedMonitoringWithContext(arg0 aws.Context, a // EnableEnhancedMonitoringWithContext indicates an expected call of EnableEnhancedMonitoringWithContext func (mr *MockKinesisAPIMockRecorder) EnableEnhancedMonitoringWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEnhancedMonitoringWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).EnableEnhancedMonitoringWithContext), varargs...) } // GetRecords mocks base method func (m *MockKinesisAPI) GetRecords(arg0 *kinesis.GetRecordsInput) (*kinesis.GetRecordsOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRecords", arg0) ret0, _ := ret[0].(*kinesis.GetRecordsOutput) ret1, _ := ret[1].(error) @@ -629,13 +558,11 @@ func (m *MockKinesisAPI) GetRecords(arg0 *kinesis.GetRecordsInput) (*kinesis.Get // GetRecords indicates an expected call of GetRecords func (mr *MockKinesisAPIMockRecorder) GetRecords(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecords", reflect.TypeOf((*MockKinesisAPI)(nil).GetRecords), arg0) } // GetRecordsRequest mocks base method func (m *MockKinesisAPI) GetRecordsRequest(arg0 *kinesis.GetRecordsInput) (*request.Request, *kinesis.GetRecordsOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRecordsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.GetRecordsOutput) @@ -644,13 +571,11 @@ func (m *MockKinesisAPI) GetRecordsRequest(arg0 *kinesis.GetRecordsInput) (*requ // GetRecordsRequest indicates an expected call of GetRecordsRequest func (mr *MockKinesisAPIMockRecorder) GetRecordsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecordsRequest", reflect.TypeOf((*MockKinesisAPI)(nil).GetRecordsRequest), arg0) } // GetRecordsWithContext mocks base method func (m *MockKinesisAPI) GetRecordsWithContext(arg0 aws.Context, arg1 *kinesis.GetRecordsInput, arg2 ...request.Option) (*kinesis.GetRecordsOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -663,14 +588,12 @@ func (m *MockKinesisAPI) GetRecordsWithContext(arg0 aws.Context, arg1 *kinesis.G // GetRecordsWithContext indicates an expected call of GetRecordsWithContext func (mr *MockKinesisAPIMockRecorder) GetRecordsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecordsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).GetRecordsWithContext), varargs...) } // GetShardIterator mocks base method func (m *MockKinesisAPI) GetShardIterator(arg0 *kinesis.GetShardIteratorInput) (*kinesis.GetShardIteratorOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetShardIterator", arg0) ret0, _ := ret[0].(*kinesis.GetShardIteratorOutput) ret1, _ := ret[1].(error) @@ -679,13 +602,11 @@ func (m *MockKinesisAPI) GetShardIterator(arg0 *kinesis.GetShardIteratorInput) ( // GetShardIterator indicates an expected call of GetShardIterator func (mr *MockKinesisAPIMockRecorder) GetShardIterator(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShardIterator", reflect.TypeOf((*MockKinesisAPI)(nil).GetShardIterator), arg0) } // GetShardIteratorRequest mocks base method func (m *MockKinesisAPI) GetShardIteratorRequest(arg0 *kinesis.GetShardIteratorInput) (*request.Request, *kinesis.GetShardIteratorOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetShardIteratorRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.GetShardIteratorOutput) @@ -694,13 +615,11 @@ func (m *MockKinesisAPI) GetShardIteratorRequest(arg0 *kinesis.GetShardIteratorI // GetShardIteratorRequest indicates an expected call of GetShardIteratorRequest func (mr *MockKinesisAPIMockRecorder) GetShardIteratorRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShardIteratorRequest", reflect.TypeOf((*MockKinesisAPI)(nil).GetShardIteratorRequest), arg0) } // GetShardIteratorWithContext mocks base method func (m *MockKinesisAPI) GetShardIteratorWithContext(arg0 aws.Context, arg1 *kinesis.GetShardIteratorInput, arg2 ...request.Option) (*kinesis.GetShardIteratorOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -713,14 +632,12 @@ func (m *MockKinesisAPI) GetShardIteratorWithContext(arg0 aws.Context, arg1 *kin // GetShardIteratorWithContext indicates an expected call of GetShardIteratorWithContext func (mr *MockKinesisAPIMockRecorder) GetShardIteratorWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShardIteratorWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).GetShardIteratorWithContext), varargs...) } // IncreaseStreamRetentionPeriod mocks base method func (m *MockKinesisAPI) IncreaseStreamRetentionPeriod(arg0 *kinesis.IncreaseStreamRetentionPeriodInput) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IncreaseStreamRetentionPeriod", arg0) ret0, _ := ret[0].(*kinesis.IncreaseStreamRetentionPeriodOutput) ret1, _ := ret[1].(error) @@ -729,13 +646,11 @@ func (m *MockKinesisAPI) IncreaseStreamRetentionPeriod(arg0 *kinesis.IncreaseStr // IncreaseStreamRetentionPeriod indicates an expected call of IncreaseStreamRetentionPeriod func (mr *MockKinesisAPIMockRecorder) IncreaseStreamRetentionPeriod(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseStreamRetentionPeriod", reflect.TypeOf((*MockKinesisAPI)(nil).IncreaseStreamRetentionPeriod), arg0) } // IncreaseStreamRetentionPeriodRequest mocks base method func (m *MockKinesisAPI) IncreaseStreamRetentionPeriodRequest(arg0 *kinesis.IncreaseStreamRetentionPeriodInput) (*request.Request, *kinesis.IncreaseStreamRetentionPeriodOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IncreaseStreamRetentionPeriodRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.IncreaseStreamRetentionPeriodOutput) @@ -744,13 +659,11 @@ func (m *MockKinesisAPI) IncreaseStreamRetentionPeriodRequest(arg0 *kinesis.Incr // IncreaseStreamRetentionPeriodRequest indicates an expected call of IncreaseStreamRetentionPeriodRequest func (mr *MockKinesisAPIMockRecorder) IncreaseStreamRetentionPeriodRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseStreamRetentionPeriodRequest", reflect.TypeOf((*MockKinesisAPI)(nil).IncreaseStreamRetentionPeriodRequest), arg0) } // IncreaseStreamRetentionPeriodWithContext mocks base method func (m *MockKinesisAPI) IncreaseStreamRetentionPeriodWithContext(arg0 aws.Context, arg1 *kinesis.IncreaseStreamRetentionPeriodInput, arg2 ...request.Option) (*kinesis.IncreaseStreamRetentionPeriodOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -763,14 +676,12 @@ func (m *MockKinesisAPI) IncreaseStreamRetentionPeriodWithContext(arg0 aws.Conte // IncreaseStreamRetentionPeriodWithContext indicates an expected call of IncreaseStreamRetentionPeriodWithContext func (mr *MockKinesisAPIMockRecorder) IncreaseStreamRetentionPeriodWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncreaseStreamRetentionPeriodWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).IncreaseStreamRetentionPeriodWithContext), varargs...) } // ListShards mocks base method func (m *MockKinesisAPI) ListShards(arg0 *kinesis.ListShardsInput) (*kinesis.ListShardsOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListShards", arg0) ret0, _ := ret[0].(*kinesis.ListShardsOutput) ret1, _ := ret[1].(error) @@ -779,13 +690,11 @@ func (m *MockKinesisAPI) ListShards(arg0 *kinesis.ListShardsInput) (*kinesis.Lis // ListShards indicates an expected call of ListShards func (mr *MockKinesisAPIMockRecorder) ListShards(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListShards", reflect.TypeOf((*MockKinesisAPI)(nil).ListShards), arg0) } // ListShardsRequest mocks base method func (m *MockKinesisAPI) ListShardsRequest(arg0 *kinesis.ListShardsInput) (*request.Request, *kinesis.ListShardsOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListShardsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.ListShardsOutput) @@ -794,13 +703,11 @@ func (m *MockKinesisAPI) ListShardsRequest(arg0 *kinesis.ListShardsInput) (*requ // ListShardsRequest indicates an expected call of ListShardsRequest func (mr *MockKinesisAPIMockRecorder) ListShardsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListShardsRequest", reflect.TypeOf((*MockKinesisAPI)(nil).ListShardsRequest), arg0) } // ListShardsWithContext mocks base method func (m *MockKinesisAPI) ListShardsWithContext(arg0 aws.Context, arg1 *kinesis.ListShardsInput, arg2 ...request.Option) (*kinesis.ListShardsOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -813,14 +720,12 @@ func (m *MockKinesisAPI) ListShardsWithContext(arg0 aws.Context, arg1 *kinesis.L // ListShardsWithContext indicates an expected call of ListShardsWithContext func (mr *MockKinesisAPIMockRecorder) ListShardsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListShardsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).ListShardsWithContext), varargs...) } // ListStreamConsumers mocks base method func (m *MockKinesisAPI) ListStreamConsumers(arg0 *kinesis.ListStreamConsumersInput) (*kinesis.ListStreamConsumersOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListStreamConsumers", arg0) ret0, _ := ret[0].(*kinesis.ListStreamConsumersOutput) ret1, _ := ret[1].(error) @@ -829,13 +734,11 @@ func (m *MockKinesisAPI) ListStreamConsumers(arg0 *kinesis.ListStreamConsumersIn // ListStreamConsumers indicates an expected call of ListStreamConsumers func (mr *MockKinesisAPIMockRecorder) ListStreamConsumers(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamConsumers", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamConsumers), arg0) } // ListStreamConsumersPages mocks base method func (m *MockKinesisAPI) ListStreamConsumersPages(arg0 *kinesis.ListStreamConsumersInput, arg1 func(*kinesis.ListStreamConsumersOutput, bool) bool) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListStreamConsumersPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -843,13 +746,11 @@ func (m *MockKinesisAPI) ListStreamConsumersPages(arg0 *kinesis.ListStreamConsum // ListStreamConsumersPages indicates an expected call of ListStreamConsumersPages func (mr *MockKinesisAPIMockRecorder) ListStreamConsumersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamConsumersPages", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamConsumersPages), arg0, arg1) } // ListStreamConsumersPagesWithContext mocks base method func (m *MockKinesisAPI) ListStreamConsumersPagesWithContext(arg0 aws.Context, arg1 *kinesis.ListStreamConsumersInput, arg2 func(*kinesis.ListStreamConsumersOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) @@ -861,14 +762,12 @@ func (m *MockKinesisAPI) ListStreamConsumersPagesWithContext(arg0 aws.Context, a // ListStreamConsumersPagesWithContext indicates an expected call of ListStreamConsumersPagesWithContext func (mr *MockKinesisAPIMockRecorder) ListStreamConsumersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamConsumersPagesWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamConsumersPagesWithContext), varargs...) } // ListStreamConsumersRequest mocks base method func (m *MockKinesisAPI) ListStreamConsumersRequest(arg0 *kinesis.ListStreamConsumersInput) (*request.Request, *kinesis.ListStreamConsumersOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListStreamConsumersRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.ListStreamConsumersOutput) @@ -877,13 +776,11 @@ func (m *MockKinesisAPI) ListStreamConsumersRequest(arg0 *kinesis.ListStreamCons // ListStreamConsumersRequest indicates an expected call of ListStreamConsumersRequest func (mr *MockKinesisAPIMockRecorder) ListStreamConsumersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamConsumersRequest", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamConsumersRequest), arg0) } // ListStreamConsumersWithContext mocks base method func (m *MockKinesisAPI) ListStreamConsumersWithContext(arg0 aws.Context, arg1 *kinesis.ListStreamConsumersInput, arg2 ...request.Option) (*kinesis.ListStreamConsumersOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -896,14 +793,12 @@ func (m *MockKinesisAPI) ListStreamConsumersWithContext(arg0 aws.Context, arg1 * // ListStreamConsumersWithContext indicates an expected call of ListStreamConsumersWithContext func (mr *MockKinesisAPIMockRecorder) ListStreamConsumersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamConsumersWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamConsumersWithContext), varargs...) } // ListStreams mocks base method func (m *MockKinesisAPI) ListStreams(arg0 *kinesis.ListStreamsInput) (*kinesis.ListStreamsOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListStreams", arg0) ret0, _ := ret[0].(*kinesis.ListStreamsOutput) ret1, _ := ret[1].(error) @@ -912,13 +807,11 @@ func (m *MockKinesisAPI) ListStreams(arg0 *kinesis.ListStreamsInput) (*kinesis.L // ListStreams indicates an expected call of ListStreams func (mr *MockKinesisAPIMockRecorder) ListStreams(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreams", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreams), arg0) } // ListStreamsPages mocks base method func (m *MockKinesisAPI) ListStreamsPages(arg0 *kinesis.ListStreamsInput, arg1 func(*kinesis.ListStreamsOutput, bool) bool) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListStreamsPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -926,13 +819,11 @@ func (m *MockKinesisAPI) ListStreamsPages(arg0 *kinesis.ListStreamsInput, arg1 f // ListStreamsPages indicates an expected call of ListStreamsPages func (mr *MockKinesisAPIMockRecorder) ListStreamsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamsPages", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamsPages), arg0, arg1) } // ListStreamsPagesWithContext mocks base method func (m *MockKinesisAPI) ListStreamsPagesWithContext(arg0 aws.Context, arg1 *kinesis.ListStreamsInput, arg2 func(*kinesis.ListStreamsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) @@ -944,14 +835,12 @@ func (m *MockKinesisAPI) ListStreamsPagesWithContext(arg0 aws.Context, arg1 *kin // ListStreamsPagesWithContext indicates an expected call of ListStreamsPagesWithContext func (mr *MockKinesisAPIMockRecorder) ListStreamsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamsPagesWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamsPagesWithContext), varargs...) } // ListStreamsRequest mocks base method func (m *MockKinesisAPI) ListStreamsRequest(arg0 *kinesis.ListStreamsInput) (*request.Request, *kinesis.ListStreamsOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListStreamsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.ListStreamsOutput) @@ -960,13 +849,11 @@ func (m *MockKinesisAPI) ListStreamsRequest(arg0 *kinesis.ListStreamsInput) (*re // ListStreamsRequest indicates an expected call of ListStreamsRequest func (mr *MockKinesisAPIMockRecorder) ListStreamsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamsRequest", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamsRequest), arg0) } // ListStreamsWithContext mocks base method func (m *MockKinesisAPI) ListStreamsWithContext(arg0 aws.Context, arg1 *kinesis.ListStreamsInput, arg2 ...request.Option) (*kinesis.ListStreamsOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -979,14 +866,12 @@ func (m *MockKinesisAPI) ListStreamsWithContext(arg0 aws.Context, arg1 *kinesis. // ListStreamsWithContext indicates an expected call of ListStreamsWithContext func (mr *MockKinesisAPIMockRecorder) ListStreamsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListStreamsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).ListStreamsWithContext), varargs...) } // ListTagsForStream mocks base method func (m *MockKinesisAPI) ListTagsForStream(arg0 *kinesis.ListTagsForStreamInput) (*kinesis.ListTagsForStreamOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForStream", arg0) ret0, _ := ret[0].(*kinesis.ListTagsForStreamOutput) ret1, _ := ret[1].(error) @@ -995,13 +880,11 @@ func (m *MockKinesisAPI) ListTagsForStream(arg0 *kinesis.ListTagsForStreamInput) // ListTagsForStream indicates an expected call of ListTagsForStream func (mr *MockKinesisAPIMockRecorder) ListTagsForStream(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForStream", reflect.TypeOf((*MockKinesisAPI)(nil).ListTagsForStream), arg0) } // ListTagsForStreamRequest mocks base method func (m *MockKinesisAPI) ListTagsForStreamRequest(arg0 *kinesis.ListTagsForStreamInput) (*request.Request, *kinesis.ListTagsForStreamOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForStreamRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.ListTagsForStreamOutput) @@ -1010,13 +893,11 @@ func (m *MockKinesisAPI) ListTagsForStreamRequest(arg0 *kinesis.ListTagsForStrea // ListTagsForStreamRequest indicates an expected call of ListTagsForStreamRequest func (mr *MockKinesisAPIMockRecorder) ListTagsForStreamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForStreamRequest", reflect.TypeOf((*MockKinesisAPI)(nil).ListTagsForStreamRequest), arg0) } // ListTagsForStreamWithContext mocks base method func (m *MockKinesisAPI) ListTagsForStreamWithContext(arg0 aws.Context, arg1 *kinesis.ListTagsForStreamInput, arg2 ...request.Option) (*kinesis.ListTagsForStreamOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1029,14 +910,12 @@ func (m *MockKinesisAPI) ListTagsForStreamWithContext(arg0 aws.Context, arg1 *ki // ListTagsForStreamWithContext indicates an expected call of ListTagsForStreamWithContext func (mr *MockKinesisAPIMockRecorder) ListTagsForStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForStreamWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).ListTagsForStreamWithContext), varargs...) } // MergeShards mocks base method func (m *MockKinesisAPI) MergeShards(arg0 *kinesis.MergeShardsInput) (*kinesis.MergeShardsOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MergeShards", arg0) ret0, _ := ret[0].(*kinesis.MergeShardsOutput) ret1, _ := ret[1].(error) @@ -1045,13 +924,11 @@ func (m *MockKinesisAPI) MergeShards(arg0 *kinesis.MergeShardsInput) (*kinesis.M // MergeShards indicates an expected call of MergeShards func (mr *MockKinesisAPIMockRecorder) MergeShards(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeShards", reflect.TypeOf((*MockKinesisAPI)(nil).MergeShards), arg0) } // MergeShardsRequest mocks base method func (m *MockKinesisAPI) MergeShardsRequest(arg0 *kinesis.MergeShardsInput) (*request.Request, *kinesis.MergeShardsOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MergeShardsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.MergeShardsOutput) @@ -1060,13 +937,11 @@ func (m *MockKinesisAPI) MergeShardsRequest(arg0 *kinesis.MergeShardsInput) (*re // MergeShardsRequest indicates an expected call of MergeShardsRequest func (mr *MockKinesisAPIMockRecorder) MergeShardsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeShardsRequest", reflect.TypeOf((*MockKinesisAPI)(nil).MergeShardsRequest), arg0) } // MergeShardsWithContext mocks base method func (m *MockKinesisAPI) MergeShardsWithContext(arg0 aws.Context, arg1 *kinesis.MergeShardsInput, arg2 ...request.Option) (*kinesis.MergeShardsOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1079,14 +954,12 @@ func (m *MockKinesisAPI) MergeShardsWithContext(arg0 aws.Context, arg1 *kinesis. // MergeShardsWithContext indicates an expected call of MergeShardsWithContext func (mr *MockKinesisAPIMockRecorder) MergeShardsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeShardsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).MergeShardsWithContext), varargs...) } // PutRecord mocks base method func (m *MockKinesisAPI) PutRecord(arg0 *kinesis.PutRecordInput) (*kinesis.PutRecordOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PutRecord", arg0) ret0, _ := ret[0].(*kinesis.PutRecordOutput) ret1, _ := ret[1].(error) @@ -1095,13 +968,11 @@ func (m *MockKinesisAPI) PutRecord(arg0 *kinesis.PutRecordInput) (*kinesis.PutRe // PutRecord indicates an expected call of PutRecord func (mr *MockKinesisAPIMockRecorder) PutRecord(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRecord", reflect.TypeOf((*MockKinesisAPI)(nil).PutRecord), arg0) } // PutRecordRequest mocks base method func (m *MockKinesisAPI) PutRecordRequest(arg0 *kinesis.PutRecordInput) (*request.Request, *kinesis.PutRecordOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PutRecordRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.PutRecordOutput) @@ -1110,13 +981,11 @@ func (m *MockKinesisAPI) PutRecordRequest(arg0 *kinesis.PutRecordInput) (*reques // PutRecordRequest indicates an expected call of PutRecordRequest func (mr *MockKinesisAPIMockRecorder) PutRecordRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRecordRequest", reflect.TypeOf((*MockKinesisAPI)(nil).PutRecordRequest), arg0) } // PutRecordWithContext mocks base method func (m *MockKinesisAPI) PutRecordWithContext(arg0 aws.Context, arg1 *kinesis.PutRecordInput, arg2 ...request.Option) (*kinesis.PutRecordOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1129,14 +998,12 @@ func (m *MockKinesisAPI) PutRecordWithContext(arg0 aws.Context, arg1 *kinesis.Pu // PutRecordWithContext indicates an expected call of PutRecordWithContext func (mr *MockKinesisAPIMockRecorder) PutRecordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRecordWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).PutRecordWithContext), varargs...) } // PutRecords mocks base method func (m *MockKinesisAPI) PutRecords(arg0 *kinesis.PutRecordsInput) (*kinesis.PutRecordsOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PutRecords", arg0) ret0, _ := ret[0].(*kinesis.PutRecordsOutput) ret1, _ := ret[1].(error) @@ -1145,13 +1012,11 @@ func (m *MockKinesisAPI) PutRecords(arg0 *kinesis.PutRecordsInput) (*kinesis.Put // PutRecords indicates an expected call of PutRecords func (mr *MockKinesisAPIMockRecorder) PutRecords(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRecords", reflect.TypeOf((*MockKinesisAPI)(nil).PutRecords), arg0) } // PutRecordsRequest mocks base method func (m *MockKinesisAPI) PutRecordsRequest(arg0 *kinesis.PutRecordsInput) (*request.Request, *kinesis.PutRecordsOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PutRecordsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.PutRecordsOutput) @@ -1160,13 +1025,11 @@ func (m *MockKinesisAPI) PutRecordsRequest(arg0 *kinesis.PutRecordsInput) (*requ // PutRecordsRequest indicates an expected call of PutRecordsRequest func (mr *MockKinesisAPIMockRecorder) PutRecordsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRecordsRequest", reflect.TypeOf((*MockKinesisAPI)(nil).PutRecordsRequest), arg0) } // PutRecordsWithContext mocks base method func (m *MockKinesisAPI) PutRecordsWithContext(arg0 aws.Context, arg1 *kinesis.PutRecordsInput, arg2 ...request.Option) (*kinesis.PutRecordsOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1179,14 +1042,12 @@ func (m *MockKinesisAPI) PutRecordsWithContext(arg0 aws.Context, arg1 *kinesis.P // PutRecordsWithContext indicates an expected call of PutRecordsWithContext func (mr *MockKinesisAPIMockRecorder) PutRecordsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutRecordsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).PutRecordsWithContext), varargs...) } // RegisterStreamConsumer mocks base method func (m *MockKinesisAPI) RegisterStreamConsumer(arg0 *kinesis.RegisterStreamConsumerInput) (*kinesis.RegisterStreamConsumerOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RegisterStreamConsumer", arg0) ret0, _ := ret[0].(*kinesis.RegisterStreamConsumerOutput) ret1, _ := ret[1].(error) @@ -1195,13 +1056,11 @@ func (m *MockKinesisAPI) RegisterStreamConsumer(arg0 *kinesis.RegisterStreamCons // RegisterStreamConsumer indicates an expected call of RegisterStreamConsumer func (mr *MockKinesisAPIMockRecorder) RegisterStreamConsumer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterStreamConsumer", reflect.TypeOf((*MockKinesisAPI)(nil).RegisterStreamConsumer), arg0) } // RegisterStreamConsumerRequest mocks base method func (m *MockKinesisAPI) RegisterStreamConsumerRequest(arg0 *kinesis.RegisterStreamConsumerInput) (*request.Request, *kinesis.RegisterStreamConsumerOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RegisterStreamConsumerRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.RegisterStreamConsumerOutput) @@ -1210,13 +1069,11 @@ func (m *MockKinesisAPI) RegisterStreamConsumerRequest(arg0 *kinesis.RegisterStr // RegisterStreamConsumerRequest indicates an expected call of RegisterStreamConsumerRequest func (mr *MockKinesisAPIMockRecorder) RegisterStreamConsumerRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterStreamConsumerRequest", reflect.TypeOf((*MockKinesisAPI)(nil).RegisterStreamConsumerRequest), arg0) } // RegisterStreamConsumerWithContext mocks base method func (m *MockKinesisAPI) RegisterStreamConsumerWithContext(arg0 aws.Context, arg1 *kinesis.RegisterStreamConsumerInput, arg2 ...request.Option) (*kinesis.RegisterStreamConsumerOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1229,14 +1086,12 @@ func (m *MockKinesisAPI) RegisterStreamConsumerWithContext(arg0 aws.Context, arg // RegisterStreamConsumerWithContext indicates an expected call of RegisterStreamConsumerWithContext func (mr *MockKinesisAPIMockRecorder) RegisterStreamConsumerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterStreamConsumerWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).RegisterStreamConsumerWithContext), varargs...) } // RemoveTagsFromStream mocks base method func (m *MockKinesisAPI) RemoveTagsFromStream(arg0 *kinesis.RemoveTagsFromStreamInput) (*kinesis.RemoveTagsFromStreamOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTagsFromStream", arg0) ret0, _ := ret[0].(*kinesis.RemoveTagsFromStreamOutput) ret1, _ := ret[1].(error) @@ -1245,13 +1100,11 @@ func (m *MockKinesisAPI) RemoveTagsFromStream(arg0 *kinesis.RemoveTagsFromStream // RemoveTagsFromStream indicates an expected call of RemoveTagsFromStream func (mr *MockKinesisAPIMockRecorder) RemoveTagsFromStream(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromStream", reflect.TypeOf((*MockKinesisAPI)(nil).RemoveTagsFromStream), arg0) } // RemoveTagsFromStreamRequest mocks base method func (m *MockKinesisAPI) RemoveTagsFromStreamRequest(arg0 *kinesis.RemoveTagsFromStreamInput) (*request.Request, *kinesis.RemoveTagsFromStreamOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTagsFromStreamRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.RemoveTagsFromStreamOutput) @@ -1260,13 +1113,11 @@ func (m *MockKinesisAPI) RemoveTagsFromStreamRequest(arg0 *kinesis.RemoveTagsFro // RemoveTagsFromStreamRequest indicates an expected call of RemoveTagsFromStreamRequest func (mr *MockKinesisAPIMockRecorder) RemoveTagsFromStreamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromStreamRequest", reflect.TypeOf((*MockKinesisAPI)(nil).RemoveTagsFromStreamRequest), arg0) } // RemoveTagsFromStreamWithContext mocks base method func (m *MockKinesisAPI) RemoveTagsFromStreamWithContext(arg0 aws.Context, arg1 *kinesis.RemoveTagsFromStreamInput, arg2 ...request.Option) (*kinesis.RemoveTagsFromStreamOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1279,14 +1130,12 @@ func (m *MockKinesisAPI) RemoveTagsFromStreamWithContext(arg0 aws.Context, arg1 // RemoveTagsFromStreamWithContext indicates an expected call of RemoveTagsFromStreamWithContext func (mr *MockKinesisAPIMockRecorder) RemoveTagsFromStreamWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromStreamWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).RemoveTagsFromStreamWithContext), varargs...) } // SplitShard mocks base method func (m *MockKinesisAPI) SplitShard(arg0 *kinesis.SplitShardInput) (*kinesis.SplitShardOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SplitShard", arg0) ret0, _ := ret[0].(*kinesis.SplitShardOutput) ret1, _ := ret[1].(error) @@ -1295,13 +1144,11 @@ func (m *MockKinesisAPI) SplitShard(arg0 *kinesis.SplitShardInput) (*kinesis.Spl // SplitShard indicates an expected call of SplitShard func (mr *MockKinesisAPIMockRecorder) SplitShard(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SplitShard", reflect.TypeOf((*MockKinesisAPI)(nil).SplitShard), arg0) } // SplitShardRequest mocks base method func (m *MockKinesisAPI) SplitShardRequest(arg0 *kinesis.SplitShardInput) (*request.Request, *kinesis.SplitShardOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SplitShardRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.SplitShardOutput) @@ -1310,13 +1157,11 @@ func (m *MockKinesisAPI) SplitShardRequest(arg0 *kinesis.SplitShardInput) (*requ // SplitShardRequest indicates an expected call of SplitShardRequest func (mr *MockKinesisAPIMockRecorder) SplitShardRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SplitShardRequest", reflect.TypeOf((*MockKinesisAPI)(nil).SplitShardRequest), arg0) } // SplitShardWithContext mocks base method func (m *MockKinesisAPI) SplitShardWithContext(arg0 aws.Context, arg1 *kinesis.SplitShardInput, arg2 ...request.Option) (*kinesis.SplitShardOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1329,14 +1174,12 @@ func (m *MockKinesisAPI) SplitShardWithContext(arg0 aws.Context, arg1 *kinesis.S // SplitShardWithContext indicates an expected call of SplitShardWithContext func (mr *MockKinesisAPIMockRecorder) SplitShardWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SplitShardWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).SplitShardWithContext), varargs...) } // StartStreamEncryption mocks base method func (m *MockKinesisAPI) StartStreamEncryption(arg0 *kinesis.StartStreamEncryptionInput) (*kinesis.StartStreamEncryptionOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StartStreamEncryption", arg0) ret0, _ := ret[0].(*kinesis.StartStreamEncryptionOutput) ret1, _ := ret[1].(error) @@ -1345,13 +1188,11 @@ func (m *MockKinesisAPI) StartStreamEncryption(arg0 *kinesis.StartStreamEncrypti // StartStreamEncryption indicates an expected call of StartStreamEncryption func (mr *MockKinesisAPIMockRecorder) StartStreamEncryption(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartStreamEncryption", reflect.TypeOf((*MockKinesisAPI)(nil).StartStreamEncryption), arg0) } // StartStreamEncryptionRequest mocks base method func (m *MockKinesisAPI) StartStreamEncryptionRequest(arg0 *kinesis.StartStreamEncryptionInput) (*request.Request, *kinesis.StartStreamEncryptionOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StartStreamEncryptionRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.StartStreamEncryptionOutput) @@ -1360,13 +1201,11 @@ func (m *MockKinesisAPI) StartStreamEncryptionRequest(arg0 *kinesis.StartStreamE // StartStreamEncryptionRequest indicates an expected call of StartStreamEncryptionRequest func (mr *MockKinesisAPIMockRecorder) StartStreamEncryptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartStreamEncryptionRequest", reflect.TypeOf((*MockKinesisAPI)(nil).StartStreamEncryptionRequest), arg0) } // StartStreamEncryptionWithContext mocks base method func (m *MockKinesisAPI) StartStreamEncryptionWithContext(arg0 aws.Context, arg1 *kinesis.StartStreamEncryptionInput, arg2 ...request.Option) (*kinesis.StartStreamEncryptionOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1379,14 +1218,12 @@ func (m *MockKinesisAPI) StartStreamEncryptionWithContext(arg0 aws.Context, arg1 // StartStreamEncryptionWithContext indicates an expected call of StartStreamEncryptionWithContext func (mr *MockKinesisAPIMockRecorder) StartStreamEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartStreamEncryptionWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).StartStreamEncryptionWithContext), varargs...) } // StopStreamEncryption mocks base method func (m *MockKinesisAPI) StopStreamEncryption(arg0 *kinesis.StopStreamEncryptionInput) (*kinesis.StopStreamEncryptionOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StopStreamEncryption", arg0) ret0, _ := ret[0].(*kinesis.StopStreamEncryptionOutput) ret1, _ := ret[1].(error) @@ -1395,13 +1232,11 @@ func (m *MockKinesisAPI) StopStreamEncryption(arg0 *kinesis.StopStreamEncryption // StopStreamEncryption indicates an expected call of StopStreamEncryption func (mr *MockKinesisAPIMockRecorder) StopStreamEncryption(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopStreamEncryption", reflect.TypeOf((*MockKinesisAPI)(nil).StopStreamEncryption), arg0) } // StopStreamEncryptionRequest mocks base method func (m *MockKinesisAPI) StopStreamEncryptionRequest(arg0 *kinesis.StopStreamEncryptionInput) (*request.Request, *kinesis.StopStreamEncryptionOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StopStreamEncryptionRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.StopStreamEncryptionOutput) @@ -1410,13 +1245,11 @@ func (m *MockKinesisAPI) StopStreamEncryptionRequest(arg0 *kinesis.StopStreamEnc // StopStreamEncryptionRequest indicates an expected call of StopStreamEncryptionRequest func (mr *MockKinesisAPIMockRecorder) StopStreamEncryptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopStreamEncryptionRequest", reflect.TypeOf((*MockKinesisAPI)(nil).StopStreamEncryptionRequest), arg0) } // StopStreamEncryptionWithContext mocks base method func (m *MockKinesisAPI) StopStreamEncryptionWithContext(arg0 aws.Context, arg1 *kinesis.StopStreamEncryptionInput, arg2 ...request.Option) (*kinesis.StopStreamEncryptionOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1429,14 +1262,12 @@ func (m *MockKinesisAPI) StopStreamEncryptionWithContext(arg0 aws.Context, arg1 // StopStreamEncryptionWithContext indicates an expected call of StopStreamEncryptionWithContext func (mr *MockKinesisAPIMockRecorder) StopStreamEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopStreamEncryptionWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).StopStreamEncryptionWithContext), varargs...) } // UpdateShardCount mocks base method func (m *MockKinesisAPI) UpdateShardCount(arg0 *kinesis.UpdateShardCountInput) (*kinesis.UpdateShardCountOutput, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateShardCount", arg0) ret0, _ := ret[0].(*kinesis.UpdateShardCountOutput) ret1, _ := ret[1].(error) @@ -1445,13 +1276,11 @@ func (m *MockKinesisAPI) UpdateShardCount(arg0 *kinesis.UpdateShardCountInput) ( // UpdateShardCount indicates an expected call of UpdateShardCount func (mr *MockKinesisAPIMockRecorder) UpdateShardCount(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShardCount", reflect.TypeOf((*MockKinesisAPI)(nil).UpdateShardCount), arg0) } // UpdateShardCountRequest mocks base method func (m *MockKinesisAPI) UpdateShardCountRequest(arg0 *kinesis.UpdateShardCountInput) (*request.Request, *kinesis.UpdateShardCountOutput) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateShardCountRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*kinesis.UpdateShardCountOutput) @@ -1460,13 +1289,11 @@ func (m *MockKinesisAPI) UpdateShardCountRequest(arg0 *kinesis.UpdateShardCountI // UpdateShardCountRequest indicates an expected call of UpdateShardCountRequest func (mr *MockKinesisAPIMockRecorder) UpdateShardCountRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShardCountRequest", reflect.TypeOf((*MockKinesisAPI)(nil).UpdateShardCountRequest), arg0) } // UpdateShardCountWithContext mocks base method func (m *MockKinesisAPI) UpdateShardCountWithContext(arg0 aws.Context, arg1 *kinesis.UpdateShardCountInput, arg2 ...request.Option) (*kinesis.UpdateShardCountOutput, error) { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1479,14 +1306,12 @@ func (m *MockKinesisAPI) UpdateShardCountWithContext(arg0 aws.Context, arg1 *kin // UpdateShardCountWithContext indicates an expected call of UpdateShardCountWithContext func (mr *MockKinesisAPIMockRecorder) UpdateShardCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateShardCountWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).UpdateShardCountWithContext), varargs...) } // WaitUntilStreamExists mocks base method func (m *MockKinesisAPI) WaitUntilStreamExists(arg0 *kinesis.DescribeStreamInput) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WaitUntilStreamExists", arg0) ret0, _ := ret[0].(error) return ret0 @@ -1494,13 +1319,11 @@ func (m *MockKinesisAPI) WaitUntilStreamExists(arg0 *kinesis.DescribeStreamInput // WaitUntilStreamExists indicates an expected call of WaitUntilStreamExists func (mr *MockKinesisAPIMockRecorder) WaitUntilStreamExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStreamExists", reflect.TypeOf((*MockKinesisAPI)(nil).WaitUntilStreamExists), arg0) } // WaitUntilStreamExistsWithContext mocks base method func (m *MockKinesisAPI) WaitUntilStreamExistsWithContext(arg0 aws.Context, arg1 *kinesis.DescribeStreamInput, arg2 ...request.WaiterOption) error { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1512,14 +1335,12 @@ func (m *MockKinesisAPI) WaitUntilStreamExistsWithContext(arg0 aws.Context, arg1 // WaitUntilStreamExistsWithContext indicates an expected call of WaitUntilStreamExistsWithContext func (mr *MockKinesisAPIMockRecorder) WaitUntilStreamExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStreamExistsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).WaitUntilStreamExistsWithContext), varargs...) } // WaitUntilStreamNotExists mocks base method func (m *MockKinesisAPI) WaitUntilStreamNotExists(arg0 *kinesis.DescribeStreamInput) error { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WaitUntilStreamNotExists", arg0) ret0, _ := ret[0].(error) return ret0 @@ -1527,13 +1348,11 @@ func (m *MockKinesisAPI) WaitUntilStreamNotExists(arg0 *kinesis.DescribeStreamIn // WaitUntilStreamNotExists indicates an expected call of WaitUntilStreamNotExists func (mr *MockKinesisAPIMockRecorder) WaitUntilStreamNotExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStreamNotExists", reflect.TypeOf((*MockKinesisAPI)(nil).WaitUntilStreamNotExists), arg0) } // WaitUntilStreamNotExistsWithContext mocks base method func (m *MockKinesisAPI) WaitUntilStreamNotExistsWithContext(arg0 aws.Context, arg1 *kinesis.DescribeStreamInput, arg2 ...request.WaiterOption) error { - m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) @@ -1545,7 +1364,6 @@ func (m *MockKinesisAPI) WaitUntilStreamNotExistsWithContext(arg0 aws.Context, a // WaitUntilStreamNotExistsWithContext indicates an expected call of WaitUntilStreamNotExistsWithContext func (mr *MockKinesisAPIMockRecorder) WaitUntilStreamNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStreamNotExistsWithContext", reflect.TypeOf((*MockKinesisAPI)(nil).WaitUntilStreamNotExistsWithContext), varargs...) } diff --git a/transport/transporters/kinesis/transporter/transporter.go b/transport/transporters/kinesis/transporter/transporter.go index e5992552..f183bb29 100644 --- a/transport/transporters/kinesis/transporter/transporter.go +++ b/transport/transporters/kinesis/transporter/transporter.go @@ -209,7 +209,7 @@ func (t *KinesisTransporter) transportWithRetry(ctx context.Context, pri *kinesi return nil, cancelled } -// StartTransporting reads in message batches, outputs its String to STDOUT and then sends a progress report on the batch +// StartTransporting reads in message batches, outputs its data to Kinesis and then sends a progress report on the batch func (t *KinesisTransporter) StartTransporting() { t.log.Info("starting transporter") defer t.shutdown() diff --git a/transport/transporters/rabbitmq/transporter/mocks/mock_transporter.go b/transport/transporters/rabbitmq/transporter/mocks/mock_transporter.go index 866fd19a..88bd5552 100644 --- a/transport/transporters/rabbitmq/transporter/mocks/mock_transporter.go +++ b/transport/transporters/rabbitmq/transporter/mocks/mock_transporter.go @@ -36,7 +36,6 @@ func (m *MockConnectionGetter) EXPECT() *MockConnectionGetterMockRecorder { // GetConnection mocks base method func (m *MockConnectionGetter) GetConnection(arg0 context.Context) (wabbit.Conn, error) { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetConnection", arg0) ret0, _ := ret[0].(wabbit.Conn) ret1, _ := ret[1].(error) @@ -45,6 +44,5 @@ func (m *MockConnectionGetter) GetConnection(arg0 context.Context) (wabbit.Conn, // GetConnection indicates an expected call of GetConnection func (mr *MockConnectionGetterMockRecorder) GetConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnection", reflect.TypeOf((*MockConnectionGetter)(nil).GetConnection), arg0) } diff --git a/transport/transporters/s3/config.go b/transport/transporters/s3/config.go new file mode 100644 index 00000000..faa1ff4e --- /dev/null +++ b/transport/transporters/s3/config.go @@ -0,0 +1,82 @@ +/* + Copyright 2019 Nextdoor.com, Inc. + + Licensed 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. + */ + +package s3 + +import ( + "gopkg.in/Nextdoor/cli.v1" + "gopkg.in/Nextdoor/cli.v1/altsrc" +) + +const ( + ConfVarBucketName = "s3-bucket" + ConfVarKeySpace = "s3-key-space" + ConfVarPutBatchSize = "s3-batch-size" + ConfVarAwsAccessKeyId = "aws-access-key-id" + ConfVarAwsSecretAccessKey = "aws-secret-access-key" + ConfVarAwsRegion = "aws-region" + ConfVarEndpoint = "endpoint" +) + +var Flags = []cli.Flag{ + cli.StringFlag{ + Name: "config", + Value: "config.yaml", + Usage: "bifrost YAML config file", + }, + altsrc.NewStringFlag(cli.StringFlag{ + Name: ConfVarBucketName, + Usage: "s3 bucket name", + EnvVar: "BIFROST_S3_BUCKET", + }), + altsrc.NewStringFlag(cli.StringFlag{ + Name: ConfVarKeySpace, + Usage: "s3 key space", + EnvVar: "BIFROST_S3_KEY_SPACE", + Value: "", + }), + altsrc.NewIntFlag(cli.IntFlag{ + Name: ConfVarPutBatchSize, + Usage: "s3 put batch size in number of records", + EnvVar: "BIFROST_S3_BATCH_SIZE", + Value: 50000, + }), + altsrc.NewStringFlag(cli.StringFlag{ + Name: ConfVarAwsAccessKeyId, + Usage: "aws access key id", + EnvVar: "AWS_ACCESS_KEY_ID", + Value: "", + }), + altsrc.NewStringFlag(cli.StringFlag{ + Name: ConfVarAwsSecretAccessKey, + Usage: "aws secret access key", + EnvVar: "AWS_SECRET_ACCESS_KEY", + Value: "", + }), + altsrc.NewStringFlag(cli.StringFlag{ + Name: ConfVarAwsRegion, + Usage: "aws region", + EnvVar: "AWS_REGION", + Value: "", + }), + altsrc.NewStringFlag(cli.StringFlag{ + Name: ConfVarEndpoint, + Usage: "endpoint", + EnvVar: "ENDPOINT", + Value: "", + Hidden: true, + }), +} diff --git a/transport/transporters/s3/factory.go b/transport/transporters/s3/factory.go new file mode 100644 index 00000000..a6b565c1 --- /dev/null +++ b/transport/transporters/s3/factory.go @@ -0,0 +1,154 @@ +/* + Copyright 2019 Nextdoor.com, Inc. + + Licensed 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. + */ + +package s3 + + +import ( + "os" + "time" + + "github.com/Nextdoor/pg-bifrost.git/shutdown" + "github.com/Nextdoor/pg-bifrost.git/stats" + "github.com/Nextdoor/pg-bifrost.git/transport" + "github.com/Nextdoor/pg-bifrost.git/transport/batch" + "github.com/Nextdoor/pg-bifrost.git/transport/transporters/s3/transporter" + "github.com/cenkalti/backoff" + "github.com/cevaris/ordered_map" + "github.com/sirupsen/logrus" +) + +var ( + logger = logrus.New() + log = logger.WithField("package", "s3") +) + +func init() { + logger.SetOutput(os.Stdout) + logger.SetLevel(logrus.InfoLevel) +} + +func New( + shutdownHandler shutdown.ShutdownHandler, + txnsWritten chan<- *ordered_map.OrderedMap, + statsChan chan stats.Stat, + workers int, + inputChans []<-chan transport.Batch, + transportConfig map[string]interface{}) []*transport.Transporter { + + // Get configs + bucketNameVar := transportConfig[ConfVarBucketName] + bucketName, ok := bucketNameVar.(string) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarBucketName, "string") + } + + keySpaceVar := transportConfig[ConfVarKeySpace] + keySpace, ok := keySpaceVar.(string) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarKeySpace, "string") + } + + awsRegion := transportConfig[ConfVarAwsRegion] + var awsRegionVar string + if awsRegion != "" { + awsRegionVar, ok = awsRegion.(string) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarAwsRegion, "string") + } + } + + awsAccessKeyId := transportConfig[ConfVarAwsAccessKeyId] + var awsAccessKeyIdVar string + if awsAccessKeyId != "" { + awsAccessKeyIdVar, ok = awsAccessKeyId.(string) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarAwsAccessKeyId, "string") + } + } + + awsSecretAccessKey := transportConfig[ConfVarAwsSecretAccessKey] + var awsSecretAccessKeyVar string + if awsSecretAccessKey != "" { + awsSecretAccessKeyVar, ok = awsSecretAccessKey.(string) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarAwsSecretAccessKey, "string") + } + } + + endpoint := transportConfig[ConfVarEndpoint] + var endpointVar string + var endpointVarPtr *string = nil + if endpoint != "" { + endpointVar, ok = endpoint.(string) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarEndpoint, "string") + } + endpointVarPtr = &endpointVar + } + + transports := make([]*transport.Transporter, workers) + + // Make and link transporters to the batcher's output channels + for i := 0; i < workers; i++ { + // One retry policy per worker is required because the policy + // is not thread safe. + retryPolicy := &backoff.ExponentialBackOff{ + InitialInterval: 1500 * time.Millisecond, + RandomizationFactor: 0.5, + Multiplier: 1.2, + MaxInterval: 5 * time.Second, + MaxElapsedTime: time.Duration(time.Minute * 5), + Clock: backoff.SystemClock, + } + + t := transporter.NewTransporter(shutdownHandler, + inputChans[i], + txnsWritten, + statsChan, + *log, + i, + bucketName, + keySpace, + retryPolicy, + &awsRegionVar, + &awsAccessKeyIdVar, + &awsSecretAccessKeyVar, + endpointVarPtr, + ) + transports[i] = &t + } + + return transports +} + +// NewBatchFactory returns a GenericBatchFactory configured for S3 +func NewBatchFactory(transportConfig map[string]interface{}) transport.BatchFactory { + batchSizeVar := transportConfig[ConfVarPutBatchSize] + batchSize, ok := batchSizeVar.(int) + + if !ok { + log.Fatalf("Expected type for %s is %s", ConfVarPutBatchSize, "int") + } + + return batch.NewGenericBatchFactory(batchSize) +} diff --git a/transport/transporters/s3/transporter/mocks/mock_s3.go b/transport/transporters/s3/transporter/mocks/mock_s3.go new file mode 100644 index 00000000..591764ee --- /dev/null +++ b/transport/transporters/s3/transporter/mocks/mock_s3.go @@ -0,0 +1,3729 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/aws/aws-sdk-go/service/s3/s3iface (interfaces: S3API) + +// Package mocks is a generated GoMock package. +package mocks + +import ( + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + s3 "github.com/aws/aws-sdk-go/service/s3" + gomock "github.com/golang/mock/gomock" + reflect "reflect" +) + +// MockS3API is a mock of S3API interface +type MockS3API struct { + ctrl *gomock.Controller + recorder *MockS3APIMockRecorder +} + +// MockS3APIMockRecorder is the mock recorder for MockS3API +type MockS3APIMockRecorder struct { + mock *MockS3API +} + +// NewMockS3API creates a new mock instance +func NewMockS3API(ctrl *gomock.Controller) *MockS3API { + mock := &MockS3API{ctrl: ctrl} + mock.recorder = &MockS3APIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockS3API) EXPECT() *MockS3APIMockRecorder { + return m.recorder +} + +// AbortMultipartUpload mocks base method +func (m *MockS3API) AbortMultipartUpload(arg0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) { + ret := m.ctrl.Call(m, "AbortMultipartUpload", arg0) + ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AbortMultipartUpload indicates an expected call of AbortMultipartUpload +func (mr *MockS3APIMockRecorder) AbortMultipartUpload(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUpload", reflect.TypeOf((*MockS3API)(nil).AbortMultipartUpload), arg0) +} + +// AbortMultipartUploadRequest mocks base method +func (m *MockS3API) AbortMultipartUploadRequest(arg0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) { + ret := m.ctrl.Call(m, "AbortMultipartUploadRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.AbortMultipartUploadOutput) + return ret0, ret1 +} + +// AbortMultipartUploadRequest indicates an expected call of AbortMultipartUploadRequest +func (mr *MockS3APIMockRecorder) AbortMultipartUploadRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUploadRequest", reflect.TypeOf((*MockS3API)(nil).AbortMultipartUploadRequest), arg0) +} + +// AbortMultipartUploadWithContext mocks base method +func (m *MockS3API) AbortMultipartUploadWithContext(arg0 aws.Context, arg1 *s3.AbortMultipartUploadInput, arg2 ...request.Option) (*s3.AbortMultipartUploadOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AbortMultipartUploadWithContext", varargs...) + ret0, _ := ret[0].(*s3.AbortMultipartUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AbortMultipartUploadWithContext indicates an expected call of AbortMultipartUploadWithContext +func (mr *MockS3APIMockRecorder) AbortMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AbortMultipartUploadWithContext", reflect.TypeOf((*MockS3API)(nil).AbortMultipartUploadWithContext), varargs...) +} + +// CompleteMultipartUpload mocks base method +func (m *MockS3API) CompleteMultipartUpload(arg0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) { + ret := m.ctrl.Call(m, "CompleteMultipartUpload", arg0) + ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteMultipartUpload indicates an expected call of CompleteMultipartUpload +func (mr *MockS3APIMockRecorder) CompleteMultipartUpload(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUpload", reflect.TypeOf((*MockS3API)(nil).CompleteMultipartUpload), arg0) +} + +// CompleteMultipartUploadRequest mocks base method +func (m *MockS3API) CompleteMultipartUploadRequest(arg0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) { + ret := m.ctrl.Call(m, "CompleteMultipartUploadRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.CompleteMultipartUploadOutput) + return ret0, ret1 +} + +// CompleteMultipartUploadRequest indicates an expected call of CompleteMultipartUploadRequest +func (mr *MockS3APIMockRecorder) CompleteMultipartUploadRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUploadRequest", reflect.TypeOf((*MockS3API)(nil).CompleteMultipartUploadRequest), arg0) +} + +// CompleteMultipartUploadWithContext mocks base method +func (m *MockS3API) CompleteMultipartUploadWithContext(arg0 aws.Context, arg1 *s3.CompleteMultipartUploadInput, arg2 ...request.Option) (*s3.CompleteMultipartUploadOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CompleteMultipartUploadWithContext", varargs...) + ret0, _ := ret[0].(*s3.CompleteMultipartUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteMultipartUploadWithContext indicates an expected call of CompleteMultipartUploadWithContext +func (mr *MockS3APIMockRecorder) CompleteMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteMultipartUploadWithContext", reflect.TypeOf((*MockS3API)(nil).CompleteMultipartUploadWithContext), varargs...) +} + +// CopyObject mocks base method +func (m *MockS3API) CopyObject(arg0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) { + ret := m.ctrl.Call(m, "CopyObject", arg0) + ret0, _ := ret[0].(*s3.CopyObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopyObject indicates an expected call of CopyObject +func (mr *MockS3APIMockRecorder) CopyObject(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObject", reflect.TypeOf((*MockS3API)(nil).CopyObject), arg0) +} + +// CopyObjectRequest mocks base method +func (m *MockS3API) CopyObjectRequest(arg0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) { + ret := m.ctrl.Call(m, "CopyObjectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.CopyObjectOutput) + return ret0, ret1 +} + +// CopyObjectRequest indicates an expected call of CopyObjectRequest +func (mr *MockS3APIMockRecorder) CopyObjectRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectRequest", reflect.TypeOf((*MockS3API)(nil).CopyObjectRequest), arg0) +} + +// CopyObjectWithContext mocks base method +func (m *MockS3API) CopyObjectWithContext(arg0 aws.Context, arg1 *s3.CopyObjectInput, arg2 ...request.Option) (*s3.CopyObjectOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CopyObjectWithContext", varargs...) + ret0, _ := ret[0].(*s3.CopyObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CopyObjectWithContext indicates an expected call of CopyObjectWithContext +func (mr *MockS3APIMockRecorder) CopyObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyObjectWithContext", reflect.TypeOf((*MockS3API)(nil).CopyObjectWithContext), varargs...) +} + +// CreateBucket mocks base method +func (m *MockS3API) CreateBucket(arg0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) { + ret := m.ctrl.Call(m, "CreateBucket", arg0) + ret0, _ := ret[0].(*s3.CreateBucketOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateBucket indicates an expected call of CreateBucket +func (mr *MockS3APIMockRecorder) CreateBucket(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockS3API)(nil).CreateBucket), arg0) +} + +// CreateBucketRequest mocks base method +func (m *MockS3API) CreateBucketRequest(arg0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) { + ret := m.ctrl.Call(m, "CreateBucketRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.CreateBucketOutput) + return ret0, ret1 +} + +// CreateBucketRequest indicates an expected call of CreateBucketRequest +func (mr *MockS3APIMockRecorder) CreateBucketRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucketRequest", reflect.TypeOf((*MockS3API)(nil).CreateBucketRequest), arg0) +} + +// CreateBucketWithContext mocks base method +func (m *MockS3API) CreateBucketWithContext(arg0 aws.Context, arg1 *s3.CreateBucketInput, arg2 ...request.Option) (*s3.CreateBucketOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateBucketWithContext", varargs...) + ret0, _ := ret[0].(*s3.CreateBucketOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateBucketWithContext indicates an expected call of CreateBucketWithContext +func (mr *MockS3APIMockRecorder) CreateBucketWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucketWithContext", reflect.TypeOf((*MockS3API)(nil).CreateBucketWithContext), varargs...) +} + +// CreateMultipartUpload mocks base method +func (m *MockS3API) CreateMultipartUpload(arg0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) { + ret := m.ctrl.Call(m, "CreateMultipartUpload", arg0) + ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateMultipartUpload indicates an expected call of CreateMultipartUpload +func (mr *MockS3APIMockRecorder) CreateMultipartUpload(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUpload", reflect.TypeOf((*MockS3API)(nil).CreateMultipartUpload), arg0) +} + +// CreateMultipartUploadRequest mocks base method +func (m *MockS3API) CreateMultipartUploadRequest(arg0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) { + ret := m.ctrl.Call(m, "CreateMultipartUploadRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.CreateMultipartUploadOutput) + return ret0, ret1 +} + +// CreateMultipartUploadRequest indicates an expected call of CreateMultipartUploadRequest +func (mr *MockS3APIMockRecorder) CreateMultipartUploadRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUploadRequest", reflect.TypeOf((*MockS3API)(nil).CreateMultipartUploadRequest), arg0) +} + +// CreateMultipartUploadWithContext mocks base method +func (m *MockS3API) CreateMultipartUploadWithContext(arg0 aws.Context, arg1 *s3.CreateMultipartUploadInput, arg2 ...request.Option) (*s3.CreateMultipartUploadOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateMultipartUploadWithContext", varargs...) + ret0, _ := ret[0].(*s3.CreateMultipartUploadOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateMultipartUploadWithContext indicates an expected call of CreateMultipartUploadWithContext +func (mr *MockS3APIMockRecorder) CreateMultipartUploadWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMultipartUploadWithContext", reflect.TypeOf((*MockS3API)(nil).CreateMultipartUploadWithContext), varargs...) +} + +// DeleteBucket mocks base method +func (m *MockS3API) DeleteBucket(arg0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucket", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucket indicates an expected call of DeleteBucket +func (mr *MockS3APIMockRecorder) DeleteBucket(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockS3API)(nil).DeleteBucket), arg0) +} + +// DeleteBucketAnalyticsConfiguration mocks base method +func (m *MockS3API) DeleteBucketAnalyticsConfiguration(arg0 *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfiguration", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketAnalyticsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketAnalyticsConfiguration indicates an expected call of DeleteBucketAnalyticsConfiguration +func (mr *MockS3APIMockRecorder) DeleteBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketAnalyticsConfiguration), arg0) +} + +// DeleteBucketAnalyticsConfigurationRequest mocks base method +func (m *MockS3API) DeleteBucketAnalyticsConfigurationRequest(arg0 *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) { + ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketAnalyticsConfigurationOutput) + return ret0, ret1 +} + +// DeleteBucketAnalyticsConfigurationRequest indicates an expected call of DeleteBucketAnalyticsConfigurationRequest +func (mr *MockS3APIMockRecorder) DeleteBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketAnalyticsConfigurationRequest), arg0) +} + +// DeleteBucketAnalyticsConfigurationWithContext mocks base method +func (m *MockS3API) DeleteBucketAnalyticsConfigurationWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketAnalyticsConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketAnalyticsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketAnalyticsConfigurationWithContext indicates an expected call of DeleteBucketAnalyticsConfigurationWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketAnalyticsConfigurationWithContext), varargs...) +} + +// DeleteBucketCors mocks base method +func (m *MockS3API) DeleteBucketCors(arg0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketCors", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketCors indicates an expected call of DeleteBucketCors +func (mr *MockS3APIMockRecorder) DeleteBucketCors(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCors", reflect.TypeOf((*MockS3API)(nil).DeleteBucketCors), arg0) +} + +// DeleteBucketCorsRequest mocks base method +func (m *MockS3API) DeleteBucketCorsRequest(arg0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) { + ret := m.ctrl.Call(m, "DeleteBucketCorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketCorsOutput) + return ret0, ret1 +} + +// DeleteBucketCorsRequest indicates an expected call of DeleteBucketCorsRequest +func (mr *MockS3APIMockRecorder) DeleteBucketCorsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCorsRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketCorsRequest), arg0) +} + +// DeleteBucketCorsWithContext mocks base method +func (m *MockS3API) DeleteBucketCorsWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketCorsInput, arg2 ...request.Option) (*s3.DeleteBucketCorsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketCorsWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketCorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketCorsWithContext indicates an expected call of DeleteBucketCorsWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketCorsWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketCorsWithContext), varargs...) +} + +// DeleteBucketEncryption mocks base method +func (m *MockS3API) DeleteBucketEncryption(arg0 *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketEncryption", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketEncryptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketEncryption indicates an expected call of DeleteBucketEncryption +func (mr *MockS3APIMockRecorder) DeleteBucketEncryption(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryption", reflect.TypeOf((*MockS3API)(nil).DeleteBucketEncryption), arg0) +} + +// DeleteBucketEncryptionRequest mocks base method +func (m *MockS3API) DeleteBucketEncryptionRequest(arg0 *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) { + ret := m.ctrl.Call(m, "DeleteBucketEncryptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketEncryptionOutput) + return ret0, ret1 +} + +// DeleteBucketEncryptionRequest indicates an expected call of DeleteBucketEncryptionRequest +func (mr *MockS3APIMockRecorder) DeleteBucketEncryptionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryptionRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketEncryptionRequest), arg0) +} + +// DeleteBucketEncryptionWithContext mocks base method +func (m *MockS3API) DeleteBucketEncryptionWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketEncryptionInput, arg2 ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketEncryptionWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketEncryptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketEncryptionWithContext indicates an expected call of DeleteBucketEncryptionWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketEncryptionWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketEncryptionWithContext), varargs...) +} + +// DeleteBucketInventoryConfiguration mocks base method +func (m *MockS3API) DeleteBucketInventoryConfiguration(arg0 *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketInventoryConfiguration", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketInventoryConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketInventoryConfiguration indicates an expected call of DeleteBucketInventoryConfiguration +func (mr *MockS3APIMockRecorder) DeleteBucketInventoryConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketInventoryConfiguration), arg0) +} + +// DeleteBucketInventoryConfigurationRequest mocks base method +func (m *MockS3API) DeleteBucketInventoryConfigurationRequest(arg0 *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) { + ret := m.ctrl.Call(m, "DeleteBucketInventoryConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketInventoryConfigurationOutput) + return ret0, ret1 +} + +// DeleteBucketInventoryConfigurationRequest indicates an expected call of DeleteBucketInventoryConfigurationRequest +func (mr *MockS3APIMockRecorder) DeleteBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketInventoryConfigurationRequest), arg0) +} + +// DeleteBucketInventoryConfigurationWithContext mocks base method +func (m *MockS3API) DeleteBucketInventoryConfigurationWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketInventoryConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketInventoryConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketInventoryConfigurationWithContext indicates an expected call of DeleteBucketInventoryConfigurationWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketInventoryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketInventoryConfigurationWithContext), varargs...) +} + +// DeleteBucketLifecycle mocks base method +func (m *MockS3API) DeleteBucketLifecycle(arg0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketLifecycle", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketLifecycle indicates an expected call of DeleteBucketLifecycle +func (mr *MockS3APIMockRecorder) DeleteBucketLifecycle(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycle", reflect.TypeOf((*MockS3API)(nil).DeleteBucketLifecycle), arg0) +} + +// DeleteBucketLifecycleRequest mocks base method +func (m *MockS3API) DeleteBucketLifecycleRequest(arg0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) { + ret := m.ctrl.Call(m, "DeleteBucketLifecycleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketLifecycleOutput) + return ret0, ret1 +} + +// DeleteBucketLifecycleRequest indicates an expected call of DeleteBucketLifecycleRequest +func (mr *MockS3APIMockRecorder) DeleteBucketLifecycleRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycleRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketLifecycleRequest), arg0) +} + +// DeleteBucketLifecycleWithContext mocks base method +func (m *MockS3API) DeleteBucketLifecycleWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketLifecycleInput, arg2 ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketLifecycleWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketLifecycleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketLifecycleWithContext indicates an expected call of DeleteBucketLifecycleWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketLifecycleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketLifecycleWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketLifecycleWithContext), varargs...) +} + +// DeleteBucketMetricsConfiguration mocks base method +func (m *MockS3API) DeleteBucketMetricsConfiguration(arg0 *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketMetricsConfiguration", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketMetricsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketMetricsConfiguration indicates an expected call of DeleteBucketMetricsConfiguration +func (mr *MockS3APIMockRecorder) DeleteBucketMetricsConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfiguration", reflect.TypeOf((*MockS3API)(nil).DeleteBucketMetricsConfiguration), arg0) +} + +// DeleteBucketMetricsConfigurationRequest mocks base method +func (m *MockS3API) DeleteBucketMetricsConfigurationRequest(arg0 *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) { + ret := m.ctrl.Call(m, "DeleteBucketMetricsConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketMetricsConfigurationOutput) + return ret0, ret1 +} + +// DeleteBucketMetricsConfigurationRequest indicates an expected call of DeleteBucketMetricsConfigurationRequest +func (mr *MockS3APIMockRecorder) DeleteBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketMetricsConfigurationRequest), arg0) +} + +// DeleteBucketMetricsConfigurationWithContext mocks base method +func (m *MockS3API) DeleteBucketMetricsConfigurationWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketMetricsConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketMetricsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketMetricsConfigurationWithContext indicates an expected call of DeleteBucketMetricsConfigurationWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketMetricsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketMetricsConfigurationWithContext), varargs...) +} + +// DeleteBucketPolicy mocks base method +func (m *MockS3API) DeleteBucketPolicy(arg0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketPolicy", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketPolicy indicates an expected call of DeleteBucketPolicy +func (mr *MockS3APIMockRecorder) DeleteBucketPolicy(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicy", reflect.TypeOf((*MockS3API)(nil).DeleteBucketPolicy), arg0) +} + +// DeleteBucketPolicyRequest mocks base method +func (m *MockS3API) DeleteBucketPolicyRequest(arg0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) { + ret := m.ctrl.Call(m, "DeleteBucketPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketPolicyOutput) + return ret0, ret1 +} + +// DeleteBucketPolicyRequest indicates an expected call of DeleteBucketPolicyRequest +func (mr *MockS3APIMockRecorder) DeleteBucketPolicyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicyRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketPolicyRequest), arg0) +} + +// DeleteBucketPolicyWithContext mocks base method +func (m *MockS3API) DeleteBucketPolicyWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketPolicyInput, arg2 ...request.Option) (*s3.DeleteBucketPolicyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketPolicyWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketPolicyWithContext indicates an expected call of DeleteBucketPolicyWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketPolicyWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketPolicyWithContext), varargs...) +} + +// DeleteBucketReplication mocks base method +func (m *MockS3API) DeleteBucketReplication(arg0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketReplication", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketReplication indicates an expected call of DeleteBucketReplication +func (mr *MockS3APIMockRecorder) DeleteBucketReplication(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplication", reflect.TypeOf((*MockS3API)(nil).DeleteBucketReplication), arg0) +} + +// DeleteBucketReplicationRequest mocks base method +func (m *MockS3API) DeleteBucketReplicationRequest(arg0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) { + ret := m.ctrl.Call(m, "DeleteBucketReplicationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketReplicationOutput) + return ret0, ret1 +} + +// DeleteBucketReplicationRequest indicates an expected call of DeleteBucketReplicationRequest +func (mr *MockS3APIMockRecorder) DeleteBucketReplicationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplicationRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketReplicationRequest), arg0) +} + +// DeleteBucketReplicationWithContext mocks base method +func (m *MockS3API) DeleteBucketReplicationWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketReplicationInput, arg2 ...request.Option) (*s3.DeleteBucketReplicationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketReplicationWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketReplicationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketReplicationWithContext indicates an expected call of DeleteBucketReplicationWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketReplicationWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketReplicationWithContext), varargs...) +} + +// DeleteBucketRequest mocks base method +func (m *MockS3API) DeleteBucketRequest(arg0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) { + ret := m.ctrl.Call(m, "DeleteBucketRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketOutput) + return ret0, ret1 +} + +// DeleteBucketRequest indicates an expected call of DeleteBucketRequest +func (mr *MockS3APIMockRecorder) DeleteBucketRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketRequest), arg0) +} + +// DeleteBucketTagging mocks base method +func (m *MockS3API) DeleteBucketTagging(arg0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketTagging", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketTagging indicates an expected call of DeleteBucketTagging +func (mr *MockS3APIMockRecorder) DeleteBucketTagging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTagging", reflect.TypeOf((*MockS3API)(nil).DeleteBucketTagging), arg0) +} + +// DeleteBucketTaggingRequest mocks base method +func (m *MockS3API) DeleteBucketTaggingRequest(arg0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) { + ret := m.ctrl.Call(m, "DeleteBucketTaggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketTaggingOutput) + return ret0, ret1 +} + +// DeleteBucketTaggingRequest indicates an expected call of DeleteBucketTaggingRequest +func (mr *MockS3APIMockRecorder) DeleteBucketTaggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTaggingRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketTaggingRequest), arg0) +} + +// DeleteBucketTaggingWithContext mocks base method +func (m *MockS3API) DeleteBucketTaggingWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketTaggingInput, arg2 ...request.Option) (*s3.DeleteBucketTaggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketTaggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketTaggingWithContext indicates an expected call of DeleteBucketTaggingWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketTaggingWithContext), varargs...) +} + +// DeleteBucketWebsite mocks base method +func (m *MockS3API) DeleteBucketWebsite(arg0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) { + ret := m.ctrl.Call(m, "DeleteBucketWebsite", arg0) + ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketWebsite indicates an expected call of DeleteBucketWebsite +func (mr *MockS3APIMockRecorder) DeleteBucketWebsite(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsite", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWebsite), arg0) +} + +// DeleteBucketWebsiteRequest mocks base method +func (m *MockS3API) DeleteBucketWebsiteRequest(arg0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) { + ret := m.ctrl.Call(m, "DeleteBucketWebsiteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteBucketWebsiteOutput) + return ret0, ret1 +} + +// DeleteBucketWebsiteRequest indicates an expected call of DeleteBucketWebsiteRequest +func (mr *MockS3APIMockRecorder) DeleteBucketWebsiteRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsiteRequest", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWebsiteRequest), arg0) +} + +// DeleteBucketWebsiteWithContext mocks base method +func (m *MockS3API) DeleteBucketWebsiteWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketWebsiteInput, arg2 ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketWebsiteWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketWebsiteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketWebsiteWithContext indicates an expected call of DeleteBucketWebsiteWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketWebsiteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWebsiteWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWebsiteWithContext), varargs...) +} + +// DeleteBucketWithContext mocks base method +func (m *MockS3API) DeleteBucketWithContext(arg0 aws.Context, arg1 *s3.DeleteBucketInput, arg2 ...request.Option) (*s3.DeleteBucketOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteBucketWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteBucketOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteBucketWithContext indicates an expected call of DeleteBucketWithContext +func (mr *MockS3APIMockRecorder) DeleteBucketWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucketWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteBucketWithContext), varargs...) +} + +// DeleteObject mocks base method +func (m *MockS3API) DeleteObject(arg0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) { + ret := m.ctrl.Call(m, "DeleteObject", arg0) + ret0, _ := ret[0].(*s3.DeleteObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteObject indicates an expected call of DeleteObject +func (mr *MockS3APIMockRecorder) DeleteObject(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockS3API)(nil).DeleteObject), arg0) +} + +// DeleteObjectRequest mocks base method +func (m *MockS3API) DeleteObjectRequest(arg0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) { + ret := m.ctrl.Call(m, "DeleteObjectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteObjectOutput) + return ret0, ret1 +} + +// DeleteObjectRequest indicates an expected call of DeleteObjectRequest +func (mr *MockS3APIMockRecorder) DeleteObjectRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectRequest", reflect.TypeOf((*MockS3API)(nil).DeleteObjectRequest), arg0) +} + +// DeleteObjectTagging mocks base method +func (m *MockS3API) DeleteObjectTagging(arg0 *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) { + ret := m.ctrl.Call(m, "DeleteObjectTagging", arg0) + ret0, _ := ret[0].(*s3.DeleteObjectTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteObjectTagging indicates an expected call of DeleteObjectTagging +func (mr *MockS3APIMockRecorder) DeleteObjectTagging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTagging", reflect.TypeOf((*MockS3API)(nil).DeleteObjectTagging), arg0) +} + +// DeleteObjectTaggingRequest mocks base method +func (m *MockS3API) DeleteObjectTaggingRequest(arg0 *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) { + ret := m.ctrl.Call(m, "DeleteObjectTaggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteObjectTaggingOutput) + return ret0, ret1 +} + +// DeleteObjectTaggingRequest indicates an expected call of DeleteObjectTaggingRequest +func (mr *MockS3APIMockRecorder) DeleteObjectTaggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTaggingRequest", reflect.TypeOf((*MockS3API)(nil).DeleteObjectTaggingRequest), arg0) +} + +// DeleteObjectTaggingWithContext mocks base method +func (m *MockS3API) DeleteObjectTaggingWithContext(arg0 aws.Context, arg1 *s3.DeleteObjectTaggingInput, arg2 ...request.Option) (*s3.DeleteObjectTaggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteObjectTaggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteObjectTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteObjectTaggingWithContext indicates an expected call of DeleteObjectTaggingWithContext +func (mr *MockS3APIMockRecorder) DeleteObjectTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteObjectTaggingWithContext), varargs...) +} + +// DeleteObjectWithContext mocks base method +func (m *MockS3API) DeleteObjectWithContext(arg0 aws.Context, arg1 *s3.DeleteObjectInput, arg2 ...request.Option) (*s3.DeleteObjectOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteObjectWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteObjectWithContext indicates an expected call of DeleteObjectWithContext +func (mr *MockS3APIMockRecorder) DeleteObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteObjectWithContext), varargs...) +} + +// DeleteObjects mocks base method +func (m *MockS3API) DeleteObjects(arg0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) { + ret := m.ctrl.Call(m, "DeleteObjects", arg0) + ret0, _ := ret[0].(*s3.DeleteObjectsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteObjects indicates an expected call of DeleteObjects +func (mr *MockS3APIMockRecorder) DeleteObjects(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjects", reflect.TypeOf((*MockS3API)(nil).DeleteObjects), arg0) +} + +// DeleteObjectsRequest mocks base method +func (m *MockS3API) DeleteObjectsRequest(arg0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) { + ret := m.ctrl.Call(m, "DeleteObjectsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.DeleteObjectsOutput) + return ret0, ret1 +} + +// DeleteObjectsRequest indicates an expected call of DeleteObjectsRequest +func (mr *MockS3APIMockRecorder) DeleteObjectsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectsRequest", reflect.TypeOf((*MockS3API)(nil).DeleteObjectsRequest), arg0) +} + +// DeleteObjectsWithContext mocks base method +func (m *MockS3API) DeleteObjectsWithContext(arg0 aws.Context, arg1 *s3.DeleteObjectsInput, arg2 ...request.Option) (*s3.DeleteObjectsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteObjectsWithContext", varargs...) + ret0, _ := ret[0].(*s3.DeleteObjectsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteObjectsWithContext indicates an expected call of DeleteObjectsWithContext +func (mr *MockS3APIMockRecorder) DeleteObjectsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjectsWithContext", reflect.TypeOf((*MockS3API)(nil).DeleteObjectsWithContext), varargs...) +} + +// GetBucketAccelerateConfiguration mocks base method +func (m *MockS3API) GetBucketAccelerateConfiguration(arg0 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketAccelerateConfiguration", arg0) + ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketAccelerateConfiguration indicates an expected call of GetBucketAccelerateConfiguration +func (mr *MockS3APIMockRecorder) GetBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketAccelerateConfiguration), arg0) +} + +// GetBucketAccelerateConfigurationRequest mocks base method +func (m *MockS3API) GetBucketAccelerateConfigurationRequest(arg0 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) { + ret := m.ctrl.Call(m, "GetBucketAccelerateConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketAccelerateConfigurationOutput) + return ret0, ret1 +} + +// GetBucketAccelerateConfigurationRequest indicates an expected call of GetBucketAccelerateConfigurationRequest +func (mr *MockS3APIMockRecorder) GetBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketAccelerateConfigurationRequest), arg0) +} + +// GetBucketAccelerateConfigurationWithContext mocks base method +func (m *MockS3API) GetBucketAccelerateConfigurationWithContext(arg0 aws.Context, arg1 *s3.GetBucketAccelerateConfigurationInput, arg2 ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketAccelerateConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketAccelerateConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketAccelerateConfigurationWithContext indicates an expected call of GetBucketAccelerateConfigurationWithContext +func (mr *MockS3APIMockRecorder) GetBucketAccelerateConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAccelerateConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketAccelerateConfigurationWithContext), varargs...) +} + +// GetBucketAcl mocks base method +func (m *MockS3API) GetBucketAcl(arg0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) { + ret := m.ctrl.Call(m, "GetBucketAcl", arg0) + ret0, _ := ret[0].(*s3.GetBucketAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketAcl indicates an expected call of GetBucketAcl +func (mr *MockS3APIMockRecorder) GetBucketAcl(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAcl", reflect.TypeOf((*MockS3API)(nil).GetBucketAcl), arg0) +} + +// GetBucketAclRequest mocks base method +func (m *MockS3API) GetBucketAclRequest(arg0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) { + ret := m.ctrl.Call(m, "GetBucketAclRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketAclOutput) + return ret0, ret1 +} + +// GetBucketAclRequest indicates an expected call of GetBucketAclRequest +func (mr *MockS3APIMockRecorder) GetBucketAclRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAclRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketAclRequest), arg0) +} + +// GetBucketAclWithContext mocks base method +func (m *MockS3API) GetBucketAclWithContext(arg0 aws.Context, arg1 *s3.GetBucketAclInput, arg2 ...request.Option) (*s3.GetBucketAclOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketAclWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketAclWithContext indicates an expected call of GetBucketAclWithContext +func (mr *MockS3APIMockRecorder) GetBucketAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAclWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketAclWithContext), varargs...) +} + +// GetBucketAnalyticsConfiguration mocks base method +func (m *MockS3API) GetBucketAnalyticsConfiguration(arg0 *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketAnalyticsConfiguration", arg0) + ret0, _ := ret[0].(*s3.GetBucketAnalyticsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketAnalyticsConfiguration indicates an expected call of GetBucketAnalyticsConfiguration +func (mr *MockS3APIMockRecorder) GetBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketAnalyticsConfiguration), arg0) +} + +// GetBucketAnalyticsConfigurationRequest mocks base method +func (m *MockS3API) GetBucketAnalyticsConfigurationRequest(arg0 *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) { + ret := m.ctrl.Call(m, "GetBucketAnalyticsConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketAnalyticsConfigurationOutput) + return ret0, ret1 +} + +// GetBucketAnalyticsConfigurationRequest indicates an expected call of GetBucketAnalyticsConfigurationRequest +func (mr *MockS3APIMockRecorder) GetBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketAnalyticsConfigurationRequest), arg0) +} + +// GetBucketAnalyticsConfigurationWithContext mocks base method +func (m *MockS3API) GetBucketAnalyticsConfigurationWithContext(arg0 aws.Context, arg1 *s3.GetBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketAnalyticsConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketAnalyticsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketAnalyticsConfigurationWithContext indicates an expected call of GetBucketAnalyticsConfigurationWithContext +func (mr *MockS3APIMockRecorder) GetBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketAnalyticsConfigurationWithContext), varargs...) +} + +// GetBucketCors mocks base method +func (m *MockS3API) GetBucketCors(arg0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) { + ret := m.ctrl.Call(m, "GetBucketCors", arg0) + ret0, _ := ret[0].(*s3.GetBucketCorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketCors indicates an expected call of GetBucketCors +func (mr *MockS3APIMockRecorder) GetBucketCors(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCors", reflect.TypeOf((*MockS3API)(nil).GetBucketCors), arg0) +} + +// GetBucketCorsRequest mocks base method +func (m *MockS3API) GetBucketCorsRequest(arg0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) { + ret := m.ctrl.Call(m, "GetBucketCorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketCorsOutput) + return ret0, ret1 +} + +// GetBucketCorsRequest indicates an expected call of GetBucketCorsRequest +func (mr *MockS3APIMockRecorder) GetBucketCorsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCorsRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketCorsRequest), arg0) +} + +// GetBucketCorsWithContext mocks base method +func (m *MockS3API) GetBucketCorsWithContext(arg0 aws.Context, arg1 *s3.GetBucketCorsInput, arg2 ...request.Option) (*s3.GetBucketCorsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketCorsWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketCorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketCorsWithContext indicates an expected call of GetBucketCorsWithContext +func (mr *MockS3APIMockRecorder) GetBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketCorsWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketCorsWithContext), varargs...) +} + +// GetBucketEncryption mocks base method +func (m *MockS3API) GetBucketEncryption(arg0 *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) { + ret := m.ctrl.Call(m, "GetBucketEncryption", arg0) + ret0, _ := ret[0].(*s3.GetBucketEncryptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketEncryption indicates an expected call of GetBucketEncryption +func (mr *MockS3APIMockRecorder) GetBucketEncryption(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryption", reflect.TypeOf((*MockS3API)(nil).GetBucketEncryption), arg0) +} + +// GetBucketEncryptionRequest mocks base method +func (m *MockS3API) GetBucketEncryptionRequest(arg0 *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) { + ret := m.ctrl.Call(m, "GetBucketEncryptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketEncryptionOutput) + return ret0, ret1 +} + +// GetBucketEncryptionRequest indicates an expected call of GetBucketEncryptionRequest +func (mr *MockS3APIMockRecorder) GetBucketEncryptionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryptionRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketEncryptionRequest), arg0) +} + +// GetBucketEncryptionWithContext mocks base method +func (m *MockS3API) GetBucketEncryptionWithContext(arg0 aws.Context, arg1 *s3.GetBucketEncryptionInput, arg2 ...request.Option) (*s3.GetBucketEncryptionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketEncryptionWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketEncryptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketEncryptionWithContext indicates an expected call of GetBucketEncryptionWithContext +func (mr *MockS3APIMockRecorder) GetBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketEncryptionWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketEncryptionWithContext), varargs...) +} + +// GetBucketInventoryConfiguration mocks base method +func (m *MockS3API) GetBucketInventoryConfiguration(arg0 *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketInventoryConfiguration", arg0) + ret0, _ := ret[0].(*s3.GetBucketInventoryConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketInventoryConfiguration indicates an expected call of GetBucketInventoryConfiguration +func (mr *MockS3APIMockRecorder) GetBucketInventoryConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketInventoryConfiguration), arg0) +} + +// GetBucketInventoryConfigurationRequest mocks base method +func (m *MockS3API) GetBucketInventoryConfigurationRequest(arg0 *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) { + ret := m.ctrl.Call(m, "GetBucketInventoryConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketInventoryConfigurationOutput) + return ret0, ret1 +} + +// GetBucketInventoryConfigurationRequest indicates an expected call of GetBucketInventoryConfigurationRequest +func (mr *MockS3APIMockRecorder) GetBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketInventoryConfigurationRequest), arg0) +} + +// GetBucketInventoryConfigurationWithContext mocks base method +func (m *MockS3API) GetBucketInventoryConfigurationWithContext(arg0 aws.Context, arg1 *s3.GetBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketInventoryConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketInventoryConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketInventoryConfigurationWithContext indicates an expected call of GetBucketInventoryConfigurationWithContext +func (mr *MockS3APIMockRecorder) GetBucketInventoryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketInventoryConfigurationWithContext), varargs...) +} + +// GetBucketLifecycle mocks base method +func (m *MockS3API) GetBucketLifecycle(arg0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) { + ret := m.ctrl.Call(m, "GetBucketLifecycle", arg0) + ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLifecycle indicates an expected call of GetBucketLifecycle +func (mr *MockS3APIMockRecorder) GetBucketLifecycle(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycle", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycle), arg0) +} + +// GetBucketLifecycleConfiguration mocks base method +func (m *MockS3API) GetBucketLifecycleConfiguration(arg0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketLifecycleConfiguration", arg0) + ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLifecycleConfiguration indicates an expected call of GetBucketLifecycleConfiguration +func (mr *MockS3APIMockRecorder) GetBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleConfiguration), arg0) +} + +// GetBucketLifecycleConfigurationRequest mocks base method +func (m *MockS3API) GetBucketLifecycleConfigurationRequest(arg0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) { + ret := m.ctrl.Call(m, "GetBucketLifecycleConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketLifecycleConfigurationOutput) + return ret0, ret1 +} + +// GetBucketLifecycleConfigurationRequest indicates an expected call of GetBucketLifecycleConfigurationRequest +func (mr *MockS3APIMockRecorder) GetBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleConfigurationRequest), arg0) +} + +// GetBucketLifecycleConfigurationWithContext mocks base method +func (m *MockS3API) GetBucketLifecycleConfigurationWithContext(arg0 aws.Context, arg1 *s3.GetBucketLifecycleConfigurationInput, arg2 ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketLifecycleConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketLifecycleConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLifecycleConfigurationWithContext indicates an expected call of GetBucketLifecycleConfigurationWithContext +func (mr *MockS3APIMockRecorder) GetBucketLifecycleConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleConfigurationWithContext), varargs...) +} + +// GetBucketLifecycleRequest mocks base method +func (m *MockS3API) GetBucketLifecycleRequest(arg0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) { + ret := m.ctrl.Call(m, "GetBucketLifecycleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketLifecycleOutput) + return ret0, ret1 +} + +// GetBucketLifecycleRequest indicates an expected call of GetBucketLifecycleRequest +func (mr *MockS3APIMockRecorder) GetBucketLifecycleRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleRequest), arg0) +} + +// GetBucketLifecycleWithContext mocks base method +func (m *MockS3API) GetBucketLifecycleWithContext(arg0 aws.Context, arg1 *s3.GetBucketLifecycleInput, arg2 ...request.Option) (*s3.GetBucketLifecycleOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketLifecycleWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketLifecycleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLifecycleWithContext indicates an expected call of GetBucketLifecycleWithContext +func (mr *MockS3APIMockRecorder) GetBucketLifecycleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLifecycleWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLifecycleWithContext), varargs...) +} + +// GetBucketLocation mocks base method +func (m *MockS3API) GetBucketLocation(arg0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketLocation", arg0) + ret0, _ := ret[0].(*s3.GetBucketLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLocation indicates an expected call of GetBucketLocation +func (mr *MockS3APIMockRecorder) GetBucketLocation(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocation", reflect.TypeOf((*MockS3API)(nil).GetBucketLocation), arg0) +} + +// GetBucketLocationRequest mocks base method +func (m *MockS3API) GetBucketLocationRequest(arg0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) { + ret := m.ctrl.Call(m, "GetBucketLocationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketLocationOutput) + return ret0, ret1 +} + +// GetBucketLocationRequest indicates an expected call of GetBucketLocationRequest +func (mr *MockS3APIMockRecorder) GetBucketLocationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLocationRequest), arg0) +} + +// GetBucketLocationWithContext mocks base method +func (m *MockS3API) GetBucketLocationWithContext(arg0 aws.Context, arg1 *s3.GetBucketLocationInput, arg2 ...request.Option) (*s3.GetBucketLocationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketLocationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketLocationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLocationWithContext indicates an expected call of GetBucketLocationWithContext +func (mr *MockS3APIMockRecorder) GetBucketLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLocationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLocationWithContext), varargs...) +} + +// GetBucketLogging mocks base method +func (m *MockS3API) GetBucketLogging(arg0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) { + ret := m.ctrl.Call(m, "GetBucketLogging", arg0) + ret0, _ := ret[0].(*s3.GetBucketLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLogging indicates an expected call of GetBucketLogging +func (mr *MockS3APIMockRecorder) GetBucketLogging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLogging", reflect.TypeOf((*MockS3API)(nil).GetBucketLogging), arg0) +} + +// GetBucketLoggingRequest mocks base method +func (m *MockS3API) GetBucketLoggingRequest(arg0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) { + ret := m.ctrl.Call(m, "GetBucketLoggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketLoggingOutput) + return ret0, ret1 +} + +// GetBucketLoggingRequest indicates an expected call of GetBucketLoggingRequest +func (mr *MockS3APIMockRecorder) GetBucketLoggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLoggingRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketLoggingRequest), arg0) +} + +// GetBucketLoggingWithContext mocks base method +func (m *MockS3API) GetBucketLoggingWithContext(arg0 aws.Context, arg1 *s3.GetBucketLoggingInput, arg2 ...request.Option) (*s3.GetBucketLoggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketLoggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketLoggingWithContext indicates an expected call of GetBucketLoggingWithContext +func (mr *MockS3APIMockRecorder) GetBucketLoggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketLoggingWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketLoggingWithContext), varargs...) +} + +// GetBucketMetricsConfiguration mocks base method +func (m *MockS3API) GetBucketMetricsConfiguration(arg0 *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketMetricsConfiguration", arg0) + ret0, _ := ret[0].(*s3.GetBucketMetricsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketMetricsConfiguration indicates an expected call of GetBucketMetricsConfiguration +func (mr *MockS3APIMockRecorder) GetBucketMetricsConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketMetricsConfiguration), arg0) +} + +// GetBucketMetricsConfigurationRequest mocks base method +func (m *MockS3API) GetBucketMetricsConfigurationRequest(arg0 *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) { + ret := m.ctrl.Call(m, "GetBucketMetricsConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketMetricsConfigurationOutput) + return ret0, ret1 +} + +// GetBucketMetricsConfigurationRequest indicates an expected call of GetBucketMetricsConfigurationRequest +func (mr *MockS3APIMockRecorder) GetBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketMetricsConfigurationRequest), arg0) +} + +// GetBucketMetricsConfigurationWithContext mocks base method +func (m *MockS3API) GetBucketMetricsConfigurationWithContext(arg0 aws.Context, arg1 *s3.GetBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketMetricsConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketMetricsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketMetricsConfigurationWithContext indicates an expected call of GetBucketMetricsConfigurationWithContext +func (mr *MockS3APIMockRecorder) GetBucketMetricsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketMetricsConfigurationWithContext), varargs...) +} + +// GetBucketNotification mocks base method +func (m *MockS3API) GetBucketNotification(arg0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) { + ret := m.ctrl.Call(m, "GetBucketNotification", arg0) + ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketNotification indicates an expected call of GetBucketNotification +func (mr *MockS3APIMockRecorder) GetBucketNotification(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotification", reflect.TypeOf((*MockS3API)(nil).GetBucketNotification), arg0) +} + +// GetBucketNotificationConfiguration mocks base method +func (m *MockS3API) GetBucketNotificationConfiguration(arg0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) { + ret := m.ctrl.Call(m, "GetBucketNotificationConfiguration", arg0) + ret0, _ := ret[0].(*s3.NotificationConfiguration) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketNotificationConfiguration indicates an expected call of GetBucketNotificationConfiguration +func (mr *MockS3APIMockRecorder) GetBucketNotificationConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfiguration", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationConfiguration), arg0) +} + +// GetBucketNotificationConfigurationRequest mocks base method +func (m *MockS3API) GetBucketNotificationConfigurationRequest(arg0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) { + ret := m.ctrl.Call(m, "GetBucketNotificationConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.NotificationConfiguration) + return ret0, ret1 +} + +// GetBucketNotificationConfigurationRequest indicates an expected call of GetBucketNotificationConfigurationRequest +func (mr *MockS3APIMockRecorder) GetBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationConfigurationRequest), arg0) +} + +// GetBucketNotificationConfigurationWithContext mocks base method +func (m *MockS3API) GetBucketNotificationConfigurationWithContext(arg0 aws.Context, arg1 *s3.GetBucketNotificationConfigurationRequest, arg2 ...request.Option) (*s3.NotificationConfiguration, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketNotificationConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.NotificationConfiguration) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketNotificationConfigurationWithContext indicates an expected call of GetBucketNotificationConfigurationWithContext +func (mr *MockS3APIMockRecorder) GetBucketNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationConfigurationWithContext), varargs...) +} + +// GetBucketNotificationRequest mocks base method +func (m *MockS3API) GetBucketNotificationRequest(arg0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) { + ret := m.ctrl.Call(m, "GetBucketNotificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.NotificationConfigurationDeprecated) + return ret0, ret1 +} + +// GetBucketNotificationRequest indicates an expected call of GetBucketNotificationRequest +func (mr *MockS3APIMockRecorder) GetBucketNotificationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationRequest), arg0) +} + +// GetBucketNotificationWithContext mocks base method +func (m *MockS3API) GetBucketNotificationWithContext(arg0 aws.Context, arg1 *s3.GetBucketNotificationConfigurationRequest, arg2 ...request.Option) (*s3.NotificationConfigurationDeprecated, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketNotificationWithContext", varargs...) + ret0, _ := ret[0].(*s3.NotificationConfigurationDeprecated) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketNotificationWithContext indicates an expected call of GetBucketNotificationWithContext +func (mr *MockS3APIMockRecorder) GetBucketNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketNotificationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketNotificationWithContext), varargs...) +} + +// GetBucketPolicy mocks base method +func (m *MockS3API) GetBucketPolicy(arg0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) { + ret := m.ctrl.Call(m, "GetBucketPolicy", arg0) + ret0, _ := ret[0].(*s3.GetBucketPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketPolicy indicates an expected call of GetBucketPolicy +func (mr *MockS3APIMockRecorder) GetBucketPolicy(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicy", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicy), arg0) +} + +// GetBucketPolicyRequest mocks base method +func (m *MockS3API) GetBucketPolicyRequest(arg0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) { + ret := m.ctrl.Call(m, "GetBucketPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketPolicyOutput) + return ret0, ret1 +} + +// GetBucketPolicyRequest indicates an expected call of GetBucketPolicyRequest +func (mr *MockS3APIMockRecorder) GetBucketPolicyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyRequest), arg0) +} + +// GetBucketPolicyWithContext mocks base method +func (m *MockS3API) GetBucketPolicyWithContext(arg0 aws.Context, arg1 *s3.GetBucketPolicyInput, arg2 ...request.Option) (*s3.GetBucketPolicyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketPolicyWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketPolicyWithContext indicates an expected call of GetBucketPolicyWithContext +func (mr *MockS3APIMockRecorder) GetBucketPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketPolicyWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketPolicyWithContext), varargs...) +} + +// GetBucketReplication mocks base method +func (m *MockS3API) GetBucketReplication(arg0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) { + ret := m.ctrl.Call(m, "GetBucketReplication", arg0) + ret0, _ := ret[0].(*s3.GetBucketReplicationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketReplication indicates an expected call of GetBucketReplication +func (mr *MockS3APIMockRecorder) GetBucketReplication(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplication", reflect.TypeOf((*MockS3API)(nil).GetBucketReplication), arg0) +} + +// GetBucketReplicationRequest mocks base method +func (m *MockS3API) GetBucketReplicationRequest(arg0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) { + ret := m.ctrl.Call(m, "GetBucketReplicationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketReplicationOutput) + return ret0, ret1 +} + +// GetBucketReplicationRequest indicates an expected call of GetBucketReplicationRequest +func (mr *MockS3APIMockRecorder) GetBucketReplicationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplicationRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketReplicationRequest), arg0) +} + +// GetBucketReplicationWithContext mocks base method +func (m *MockS3API) GetBucketReplicationWithContext(arg0 aws.Context, arg1 *s3.GetBucketReplicationInput, arg2 ...request.Option) (*s3.GetBucketReplicationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketReplicationWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketReplicationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketReplicationWithContext indicates an expected call of GetBucketReplicationWithContext +func (mr *MockS3APIMockRecorder) GetBucketReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketReplicationWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketReplicationWithContext), varargs...) +} + +// GetBucketRequestPayment mocks base method +func (m *MockS3API) GetBucketRequestPayment(arg0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) { + ret := m.ctrl.Call(m, "GetBucketRequestPayment", arg0) + ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketRequestPayment indicates an expected call of GetBucketRequestPayment +func (mr *MockS3APIMockRecorder) GetBucketRequestPayment(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPayment", reflect.TypeOf((*MockS3API)(nil).GetBucketRequestPayment), arg0) +} + +// GetBucketRequestPaymentRequest mocks base method +func (m *MockS3API) GetBucketRequestPaymentRequest(arg0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) { + ret := m.ctrl.Call(m, "GetBucketRequestPaymentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketRequestPaymentOutput) + return ret0, ret1 +} + +// GetBucketRequestPaymentRequest indicates an expected call of GetBucketRequestPaymentRequest +func (mr *MockS3APIMockRecorder) GetBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPaymentRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketRequestPaymentRequest), arg0) +} + +// GetBucketRequestPaymentWithContext mocks base method +func (m *MockS3API) GetBucketRequestPaymentWithContext(arg0 aws.Context, arg1 *s3.GetBucketRequestPaymentInput, arg2 ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketRequestPaymentWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketRequestPaymentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketRequestPaymentWithContext indicates an expected call of GetBucketRequestPaymentWithContext +func (mr *MockS3APIMockRecorder) GetBucketRequestPaymentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketRequestPaymentWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketRequestPaymentWithContext), varargs...) +} + +// GetBucketTagging mocks base method +func (m *MockS3API) GetBucketTagging(arg0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) { + ret := m.ctrl.Call(m, "GetBucketTagging", arg0) + ret0, _ := ret[0].(*s3.GetBucketTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketTagging indicates an expected call of GetBucketTagging +func (mr *MockS3APIMockRecorder) GetBucketTagging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTagging", reflect.TypeOf((*MockS3API)(nil).GetBucketTagging), arg0) +} + +// GetBucketTaggingRequest mocks base method +func (m *MockS3API) GetBucketTaggingRequest(arg0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) { + ret := m.ctrl.Call(m, "GetBucketTaggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketTaggingOutput) + return ret0, ret1 +} + +// GetBucketTaggingRequest indicates an expected call of GetBucketTaggingRequest +func (mr *MockS3APIMockRecorder) GetBucketTaggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTaggingRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketTaggingRequest), arg0) +} + +// GetBucketTaggingWithContext mocks base method +func (m *MockS3API) GetBucketTaggingWithContext(arg0 aws.Context, arg1 *s3.GetBucketTaggingInput, arg2 ...request.Option) (*s3.GetBucketTaggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketTaggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketTaggingWithContext indicates an expected call of GetBucketTaggingWithContext +func (mr *MockS3APIMockRecorder) GetBucketTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketTaggingWithContext), varargs...) +} + +// GetBucketVersioning mocks base method +func (m *MockS3API) GetBucketVersioning(arg0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) { + ret := m.ctrl.Call(m, "GetBucketVersioning", arg0) + ret0, _ := ret[0].(*s3.GetBucketVersioningOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketVersioning indicates an expected call of GetBucketVersioning +func (mr *MockS3APIMockRecorder) GetBucketVersioning(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioning", reflect.TypeOf((*MockS3API)(nil).GetBucketVersioning), arg0) +} + +// GetBucketVersioningRequest mocks base method +func (m *MockS3API) GetBucketVersioningRequest(arg0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) { + ret := m.ctrl.Call(m, "GetBucketVersioningRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketVersioningOutput) + return ret0, ret1 +} + +// GetBucketVersioningRequest indicates an expected call of GetBucketVersioningRequest +func (mr *MockS3APIMockRecorder) GetBucketVersioningRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioningRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketVersioningRequest), arg0) +} + +// GetBucketVersioningWithContext mocks base method +func (m *MockS3API) GetBucketVersioningWithContext(arg0 aws.Context, arg1 *s3.GetBucketVersioningInput, arg2 ...request.Option) (*s3.GetBucketVersioningOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketVersioningWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketVersioningOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketVersioningWithContext indicates an expected call of GetBucketVersioningWithContext +func (mr *MockS3APIMockRecorder) GetBucketVersioningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketVersioningWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketVersioningWithContext), varargs...) +} + +// GetBucketWebsite mocks base method +func (m *MockS3API) GetBucketWebsite(arg0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) { + ret := m.ctrl.Call(m, "GetBucketWebsite", arg0) + ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketWebsite indicates an expected call of GetBucketWebsite +func (mr *MockS3APIMockRecorder) GetBucketWebsite(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsite", reflect.TypeOf((*MockS3API)(nil).GetBucketWebsite), arg0) +} + +// GetBucketWebsiteRequest mocks base method +func (m *MockS3API) GetBucketWebsiteRequest(arg0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) { + ret := m.ctrl.Call(m, "GetBucketWebsiteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetBucketWebsiteOutput) + return ret0, ret1 +} + +// GetBucketWebsiteRequest indicates an expected call of GetBucketWebsiteRequest +func (mr *MockS3APIMockRecorder) GetBucketWebsiteRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsiteRequest", reflect.TypeOf((*MockS3API)(nil).GetBucketWebsiteRequest), arg0) +} + +// GetBucketWebsiteWithContext mocks base method +func (m *MockS3API) GetBucketWebsiteWithContext(arg0 aws.Context, arg1 *s3.GetBucketWebsiteInput, arg2 ...request.Option) (*s3.GetBucketWebsiteOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetBucketWebsiteWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetBucketWebsiteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetBucketWebsiteWithContext indicates an expected call of GetBucketWebsiteWithContext +func (mr *MockS3APIMockRecorder) GetBucketWebsiteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketWebsiteWithContext", reflect.TypeOf((*MockS3API)(nil).GetBucketWebsiteWithContext), varargs...) +} + +// GetObject mocks base method +func (m *MockS3API) GetObject(arg0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) { + ret := m.ctrl.Call(m, "GetObject", arg0) + ret0, _ := ret[0].(*s3.GetObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObject indicates an expected call of GetObject +func (mr *MockS3APIMockRecorder) GetObject(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockS3API)(nil).GetObject), arg0) +} + +// GetObjectAcl mocks base method +func (m *MockS3API) GetObjectAcl(arg0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) { + ret := m.ctrl.Call(m, "GetObjectAcl", arg0) + ret0, _ := ret[0].(*s3.GetObjectAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectAcl indicates an expected call of GetObjectAcl +func (mr *MockS3APIMockRecorder) GetObjectAcl(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAcl", reflect.TypeOf((*MockS3API)(nil).GetObjectAcl), arg0) +} + +// GetObjectAclRequest mocks base method +func (m *MockS3API) GetObjectAclRequest(arg0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) { + ret := m.ctrl.Call(m, "GetObjectAclRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetObjectAclOutput) + return ret0, ret1 +} + +// GetObjectAclRequest indicates an expected call of GetObjectAclRequest +func (mr *MockS3APIMockRecorder) GetObjectAclRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAclRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectAclRequest), arg0) +} + +// GetObjectAclWithContext mocks base method +func (m *MockS3API) GetObjectAclWithContext(arg0 aws.Context, arg1 *s3.GetObjectAclInput, arg2 ...request.Option) (*s3.GetObjectAclOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetObjectAclWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetObjectAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectAclWithContext indicates an expected call of GetObjectAclWithContext +func (mr *MockS3APIMockRecorder) GetObjectAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectAclWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectAclWithContext), varargs...) +} + +// GetObjectRequest mocks base method +func (m *MockS3API) GetObjectRequest(arg0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) { + ret := m.ctrl.Call(m, "GetObjectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetObjectOutput) + return ret0, ret1 +} + +// GetObjectRequest indicates an expected call of GetObjectRequest +func (mr *MockS3APIMockRecorder) GetObjectRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectRequest), arg0) +} + +// GetObjectTagging mocks base method +func (m *MockS3API) GetObjectTagging(arg0 *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) { + ret := m.ctrl.Call(m, "GetObjectTagging", arg0) + ret0, _ := ret[0].(*s3.GetObjectTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectTagging indicates an expected call of GetObjectTagging +func (mr *MockS3APIMockRecorder) GetObjectTagging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTagging", reflect.TypeOf((*MockS3API)(nil).GetObjectTagging), arg0) +} + +// GetObjectTaggingRequest mocks base method +func (m *MockS3API) GetObjectTaggingRequest(arg0 *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) { + ret := m.ctrl.Call(m, "GetObjectTaggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetObjectTaggingOutput) + return ret0, ret1 +} + +// GetObjectTaggingRequest indicates an expected call of GetObjectTaggingRequest +func (mr *MockS3APIMockRecorder) GetObjectTaggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTaggingRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectTaggingRequest), arg0) +} + +// GetObjectTaggingWithContext mocks base method +func (m *MockS3API) GetObjectTaggingWithContext(arg0 aws.Context, arg1 *s3.GetObjectTaggingInput, arg2 ...request.Option) (*s3.GetObjectTaggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetObjectTaggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetObjectTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectTaggingWithContext indicates an expected call of GetObjectTaggingWithContext +func (mr *MockS3APIMockRecorder) GetObjectTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectTaggingWithContext), varargs...) +} + +// GetObjectTorrent mocks base method +func (m *MockS3API) GetObjectTorrent(arg0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) { + ret := m.ctrl.Call(m, "GetObjectTorrent", arg0) + ret0, _ := ret[0].(*s3.GetObjectTorrentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectTorrent indicates an expected call of GetObjectTorrent +func (mr *MockS3APIMockRecorder) GetObjectTorrent(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrent", reflect.TypeOf((*MockS3API)(nil).GetObjectTorrent), arg0) +} + +// GetObjectTorrentRequest mocks base method +func (m *MockS3API) GetObjectTorrentRequest(arg0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) { + ret := m.ctrl.Call(m, "GetObjectTorrentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.GetObjectTorrentOutput) + return ret0, ret1 +} + +// GetObjectTorrentRequest indicates an expected call of GetObjectTorrentRequest +func (mr *MockS3APIMockRecorder) GetObjectTorrentRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrentRequest", reflect.TypeOf((*MockS3API)(nil).GetObjectTorrentRequest), arg0) +} + +// GetObjectTorrentWithContext mocks base method +func (m *MockS3API) GetObjectTorrentWithContext(arg0 aws.Context, arg1 *s3.GetObjectTorrentInput, arg2 ...request.Option) (*s3.GetObjectTorrentOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetObjectTorrentWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetObjectTorrentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectTorrentWithContext indicates an expected call of GetObjectTorrentWithContext +func (mr *MockS3APIMockRecorder) GetObjectTorrentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectTorrentWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectTorrentWithContext), varargs...) +} + +// GetObjectWithContext mocks base method +func (m *MockS3API) GetObjectWithContext(arg0 aws.Context, arg1 *s3.GetObjectInput, arg2 ...request.Option) (*s3.GetObjectOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetObjectWithContext", varargs...) + ret0, _ := ret[0].(*s3.GetObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetObjectWithContext indicates an expected call of GetObjectWithContext +func (mr *MockS3APIMockRecorder) GetObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectWithContext", reflect.TypeOf((*MockS3API)(nil).GetObjectWithContext), varargs...) +} + +// HeadBucket mocks base method +func (m *MockS3API) HeadBucket(arg0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) { + ret := m.ctrl.Call(m, "HeadBucket", arg0) + ret0, _ := ret[0].(*s3.HeadBucketOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeadBucket indicates an expected call of HeadBucket +func (mr *MockS3APIMockRecorder) HeadBucket(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucket", reflect.TypeOf((*MockS3API)(nil).HeadBucket), arg0) +} + +// HeadBucketRequest mocks base method +func (m *MockS3API) HeadBucketRequest(arg0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) { + ret := m.ctrl.Call(m, "HeadBucketRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.HeadBucketOutput) + return ret0, ret1 +} + +// HeadBucketRequest indicates an expected call of HeadBucketRequest +func (mr *MockS3APIMockRecorder) HeadBucketRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucketRequest", reflect.TypeOf((*MockS3API)(nil).HeadBucketRequest), arg0) +} + +// HeadBucketWithContext mocks base method +func (m *MockS3API) HeadBucketWithContext(arg0 aws.Context, arg1 *s3.HeadBucketInput, arg2 ...request.Option) (*s3.HeadBucketOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HeadBucketWithContext", varargs...) + ret0, _ := ret[0].(*s3.HeadBucketOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeadBucketWithContext indicates an expected call of HeadBucketWithContext +func (mr *MockS3APIMockRecorder) HeadBucketWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadBucketWithContext", reflect.TypeOf((*MockS3API)(nil).HeadBucketWithContext), varargs...) +} + +// HeadObject mocks base method +func (m *MockS3API) HeadObject(arg0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) { + ret := m.ctrl.Call(m, "HeadObject", arg0) + ret0, _ := ret[0].(*s3.HeadObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeadObject indicates an expected call of HeadObject +func (mr *MockS3APIMockRecorder) HeadObject(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockS3API)(nil).HeadObject), arg0) +} + +// HeadObjectRequest mocks base method +func (m *MockS3API) HeadObjectRequest(arg0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) { + ret := m.ctrl.Call(m, "HeadObjectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.HeadObjectOutput) + return ret0, ret1 +} + +// HeadObjectRequest indicates an expected call of HeadObjectRequest +func (mr *MockS3APIMockRecorder) HeadObjectRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObjectRequest", reflect.TypeOf((*MockS3API)(nil).HeadObjectRequest), arg0) +} + +// HeadObjectWithContext mocks base method +func (m *MockS3API) HeadObjectWithContext(arg0 aws.Context, arg1 *s3.HeadObjectInput, arg2 ...request.Option) (*s3.HeadObjectOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HeadObjectWithContext", varargs...) + ret0, _ := ret[0].(*s3.HeadObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HeadObjectWithContext indicates an expected call of HeadObjectWithContext +func (mr *MockS3APIMockRecorder) HeadObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObjectWithContext", reflect.TypeOf((*MockS3API)(nil).HeadObjectWithContext), varargs...) +} + +// ListBucketAnalyticsConfigurations mocks base method +func (m *MockS3API) ListBucketAnalyticsConfigurations(arg0 *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { + ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurations", arg0) + ret0, _ := ret[0].(*s3.ListBucketAnalyticsConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketAnalyticsConfigurations indicates an expected call of ListBucketAnalyticsConfigurations +func (mr *MockS3APIMockRecorder) ListBucketAnalyticsConfigurations(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketAnalyticsConfigurations), arg0) +} + +// ListBucketAnalyticsConfigurationsRequest mocks base method +func (m *MockS3API) ListBucketAnalyticsConfigurationsRequest(arg0 *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) { + ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListBucketAnalyticsConfigurationsOutput) + return ret0, ret1 +} + +// ListBucketAnalyticsConfigurationsRequest indicates an expected call of ListBucketAnalyticsConfigurationsRequest +func (mr *MockS3APIMockRecorder) ListBucketAnalyticsConfigurationsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketAnalyticsConfigurationsRequest), arg0) +} + +// ListBucketAnalyticsConfigurationsWithContext mocks base method +func (m *MockS3API) ListBucketAnalyticsConfigurationsWithContext(arg0 aws.Context, arg1 *s3.ListBucketAnalyticsConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBucketAnalyticsConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListBucketAnalyticsConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketAnalyticsConfigurationsWithContext indicates an expected call of ListBucketAnalyticsConfigurationsWithContext +func (mr *MockS3APIMockRecorder) ListBucketAnalyticsConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketAnalyticsConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketAnalyticsConfigurationsWithContext), varargs...) +} + +// ListBucketInventoryConfigurations mocks base method +func (m *MockS3API) ListBucketInventoryConfigurations(arg0 *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) { + ret := m.ctrl.Call(m, "ListBucketInventoryConfigurations", arg0) + ret0, _ := ret[0].(*s3.ListBucketInventoryConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketInventoryConfigurations indicates an expected call of ListBucketInventoryConfigurations +func (mr *MockS3APIMockRecorder) ListBucketInventoryConfigurations(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketInventoryConfigurations), arg0) +} + +// ListBucketInventoryConfigurationsRequest mocks base method +func (m *MockS3API) ListBucketInventoryConfigurationsRequest(arg0 *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) { + ret := m.ctrl.Call(m, "ListBucketInventoryConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListBucketInventoryConfigurationsOutput) + return ret0, ret1 +} + +// ListBucketInventoryConfigurationsRequest indicates an expected call of ListBucketInventoryConfigurationsRequest +func (mr *MockS3APIMockRecorder) ListBucketInventoryConfigurationsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketInventoryConfigurationsRequest), arg0) +} + +// ListBucketInventoryConfigurationsWithContext mocks base method +func (m *MockS3API) ListBucketInventoryConfigurationsWithContext(arg0 aws.Context, arg1 *s3.ListBucketInventoryConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBucketInventoryConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListBucketInventoryConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketInventoryConfigurationsWithContext indicates an expected call of ListBucketInventoryConfigurationsWithContext +func (mr *MockS3APIMockRecorder) ListBucketInventoryConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketInventoryConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketInventoryConfigurationsWithContext), varargs...) +} + +// ListBucketMetricsConfigurations mocks base method +func (m *MockS3API) ListBucketMetricsConfigurations(arg0 *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) { + ret := m.ctrl.Call(m, "ListBucketMetricsConfigurations", arg0) + ret0, _ := ret[0].(*s3.ListBucketMetricsConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketMetricsConfigurations indicates an expected call of ListBucketMetricsConfigurations +func (mr *MockS3APIMockRecorder) ListBucketMetricsConfigurations(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurations", reflect.TypeOf((*MockS3API)(nil).ListBucketMetricsConfigurations), arg0) +} + +// ListBucketMetricsConfigurationsRequest mocks base method +func (m *MockS3API) ListBucketMetricsConfigurationsRequest(arg0 *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) { + ret := m.ctrl.Call(m, "ListBucketMetricsConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListBucketMetricsConfigurationsOutput) + return ret0, ret1 +} + +// ListBucketMetricsConfigurationsRequest indicates an expected call of ListBucketMetricsConfigurationsRequest +func (mr *MockS3APIMockRecorder) ListBucketMetricsConfigurationsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurationsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketMetricsConfigurationsRequest), arg0) +} + +// ListBucketMetricsConfigurationsWithContext mocks base method +func (m *MockS3API) ListBucketMetricsConfigurationsWithContext(arg0 aws.Context, arg1 *s3.ListBucketMetricsConfigurationsInput, arg2 ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBucketMetricsConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListBucketMetricsConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketMetricsConfigurationsWithContext indicates an expected call of ListBucketMetricsConfigurationsWithContext +func (mr *MockS3APIMockRecorder) ListBucketMetricsConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketMetricsConfigurationsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketMetricsConfigurationsWithContext), varargs...) +} + +// ListBuckets mocks base method +func (m *MockS3API) ListBuckets(arg0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) { + ret := m.ctrl.Call(m, "ListBuckets", arg0) + ret0, _ := ret[0].(*s3.ListBucketsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBuckets indicates an expected call of ListBuckets +func (mr *MockS3APIMockRecorder) ListBuckets(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBuckets", reflect.TypeOf((*MockS3API)(nil).ListBuckets), arg0) +} + +// ListBucketsRequest mocks base method +func (m *MockS3API) ListBucketsRequest(arg0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) { + ret := m.ctrl.Call(m, "ListBucketsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListBucketsOutput) + return ret0, ret1 +} + +// ListBucketsRequest indicates an expected call of ListBucketsRequest +func (mr *MockS3APIMockRecorder) ListBucketsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsRequest", reflect.TypeOf((*MockS3API)(nil).ListBucketsRequest), arg0) +} + +// ListBucketsWithContext mocks base method +func (m *MockS3API) ListBucketsWithContext(arg0 aws.Context, arg1 *s3.ListBucketsInput, arg2 ...request.Option) (*s3.ListBucketsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListBucketsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListBucketsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListBucketsWithContext indicates an expected call of ListBucketsWithContext +func (mr *MockS3APIMockRecorder) ListBucketsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBucketsWithContext", reflect.TypeOf((*MockS3API)(nil).ListBucketsWithContext), varargs...) +} + +// ListMultipartUploads mocks base method +func (m *MockS3API) ListMultipartUploads(arg0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) { + ret := m.ctrl.Call(m, "ListMultipartUploads", arg0) + ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListMultipartUploads indicates an expected call of ListMultipartUploads +func (mr *MockS3APIMockRecorder) ListMultipartUploads(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploads", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploads), arg0) +} + +// ListMultipartUploadsPages mocks base method +func (m *MockS3API) ListMultipartUploadsPages(arg0 *s3.ListMultipartUploadsInput, arg1 func(*s3.ListMultipartUploadsOutput, bool) bool) error { + ret := m.ctrl.Call(m, "ListMultipartUploadsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListMultipartUploadsPages indicates an expected call of ListMultipartUploadsPages +func (mr *MockS3APIMockRecorder) ListMultipartUploadsPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsPages", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsPages), arg0, arg1) +} + +// ListMultipartUploadsPagesWithContext mocks base method +func (m *MockS3API) ListMultipartUploadsPagesWithContext(arg0 aws.Context, arg1 *s3.ListMultipartUploadsInput, arg2 func(*s3.ListMultipartUploadsOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListMultipartUploadsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListMultipartUploadsPagesWithContext indicates an expected call of ListMultipartUploadsPagesWithContext +func (mr *MockS3APIMockRecorder) ListMultipartUploadsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsPagesWithContext), varargs...) +} + +// ListMultipartUploadsRequest mocks base method +func (m *MockS3API) ListMultipartUploadsRequest(arg0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) { + ret := m.ctrl.Call(m, "ListMultipartUploadsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListMultipartUploadsOutput) + return ret0, ret1 +} + +// ListMultipartUploadsRequest indicates an expected call of ListMultipartUploadsRequest +func (mr *MockS3APIMockRecorder) ListMultipartUploadsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsRequest", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsRequest), arg0) +} + +// ListMultipartUploadsWithContext mocks base method +func (m *MockS3API) ListMultipartUploadsWithContext(arg0 aws.Context, arg1 *s3.ListMultipartUploadsInput, arg2 ...request.Option) (*s3.ListMultipartUploadsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListMultipartUploadsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListMultipartUploadsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListMultipartUploadsWithContext indicates an expected call of ListMultipartUploadsWithContext +func (mr *MockS3APIMockRecorder) ListMultipartUploadsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMultipartUploadsWithContext", reflect.TypeOf((*MockS3API)(nil).ListMultipartUploadsWithContext), varargs...) +} + +// ListObjectVersions mocks base method +func (m *MockS3API) ListObjectVersions(arg0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) { + ret := m.ctrl.Call(m, "ListObjectVersions", arg0) + ret0, _ := ret[0].(*s3.ListObjectVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObjectVersions indicates an expected call of ListObjectVersions +func (mr *MockS3APIMockRecorder) ListObjectVersions(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersions", reflect.TypeOf((*MockS3API)(nil).ListObjectVersions), arg0) +} + +// ListObjectVersionsPages mocks base method +func (m *MockS3API) ListObjectVersionsPages(arg0 *s3.ListObjectVersionsInput, arg1 func(*s3.ListObjectVersionsOutput, bool) bool) error { + ret := m.ctrl.Call(m, "ListObjectVersionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListObjectVersionsPages indicates an expected call of ListObjectVersionsPages +func (mr *MockS3APIMockRecorder) ListObjectVersionsPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsPages", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsPages), arg0, arg1) +} + +// ListObjectVersionsPagesWithContext mocks base method +func (m *MockS3API) ListObjectVersionsPagesWithContext(arg0 aws.Context, arg1 *s3.ListObjectVersionsInput, arg2 func(*s3.ListObjectVersionsOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListObjectVersionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListObjectVersionsPagesWithContext indicates an expected call of ListObjectVersionsPagesWithContext +func (mr *MockS3APIMockRecorder) ListObjectVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsPagesWithContext), varargs...) +} + +// ListObjectVersionsRequest mocks base method +func (m *MockS3API) ListObjectVersionsRequest(arg0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) { + ret := m.ctrl.Call(m, "ListObjectVersionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListObjectVersionsOutput) + return ret0, ret1 +} + +// ListObjectVersionsRequest indicates an expected call of ListObjectVersionsRequest +func (mr *MockS3APIMockRecorder) ListObjectVersionsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsRequest", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsRequest), arg0) +} + +// ListObjectVersionsWithContext mocks base method +func (m *MockS3API) ListObjectVersionsWithContext(arg0 aws.Context, arg1 *s3.ListObjectVersionsInput, arg2 ...request.Option) (*s3.ListObjectVersionsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListObjectVersionsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListObjectVersionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObjectVersionsWithContext indicates an expected call of ListObjectVersionsWithContext +func (mr *MockS3APIMockRecorder) ListObjectVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectVersionsWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectVersionsWithContext), varargs...) +} + +// ListObjects mocks base method +func (m *MockS3API) ListObjects(arg0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) { + ret := m.ctrl.Call(m, "ListObjects", arg0) + ret0, _ := ret[0].(*s3.ListObjectsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObjects indicates an expected call of ListObjects +func (mr *MockS3APIMockRecorder) ListObjects(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjects", reflect.TypeOf((*MockS3API)(nil).ListObjects), arg0) +} + +// ListObjectsPages mocks base method +func (m *MockS3API) ListObjectsPages(arg0 *s3.ListObjectsInput, arg1 func(*s3.ListObjectsOutput, bool) bool) error { + ret := m.ctrl.Call(m, "ListObjectsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListObjectsPages indicates an expected call of ListObjectsPages +func (mr *MockS3APIMockRecorder) ListObjectsPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsPages", reflect.TypeOf((*MockS3API)(nil).ListObjectsPages), arg0, arg1) +} + +// ListObjectsPagesWithContext mocks base method +func (m *MockS3API) ListObjectsPagesWithContext(arg0 aws.Context, arg1 *s3.ListObjectsInput, arg2 func(*s3.ListObjectsOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListObjectsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListObjectsPagesWithContext indicates an expected call of ListObjectsPagesWithContext +func (mr *MockS3APIMockRecorder) ListObjectsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsPagesWithContext), varargs...) +} + +// ListObjectsRequest mocks base method +func (m *MockS3API) ListObjectsRequest(arg0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) { + ret := m.ctrl.Call(m, "ListObjectsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListObjectsOutput) + return ret0, ret1 +} + +// ListObjectsRequest indicates an expected call of ListObjectsRequest +func (mr *MockS3APIMockRecorder) ListObjectsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsRequest", reflect.TypeOf((*MockS3API)(nil).ListObjectsRequest), arg0) +} + +// ListObjectsV2 mocks base method +func (m *MockS3API) ListObjectsV2(arg0 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) { + ret := m.ctrl.Call(m, "ListObjectsV2", arg0) + ret0, _ := ret[0].(*s3.ListObjectsV2Output) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObjectsV2 indicates an expected call of ListObjectsV2 +func (mr *MockS3APIMockRecorder) ListObjectsV2(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2), arg0) +} + +// ListObjectsV2Pages mocks base method +func (m *MockS3API) ListObjectsV2Pages(arg0 *s3.ListObjectsV2Input, arg1 func(*s3.ListObjectsV2Output, bool) bool) error { + ret := m.ctrl.Call(m, "ListObjectsV2Pages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListObjectsV2Pages indicates an expected call of ListObjectsV2Pages +func (mr *MockS3APIMockRecorder) ListObjectsV2Pages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Pages", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2Pages), arg0, arg1) +} + +// ListObjectsV2PagesWithContext mocks base method +func (m *MockS3API) ListObjectsV2PagesWithContext(arg0 aws.Context, arg1 *s3.ListObjectsV2Input, arg2 func(*s3.ListObjectsV2Output, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListObjectsV2PagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListObjectsV2PagesWithContext indicates an expected call of ListObjectsV2PagesWithContext +func (mr *MockS3APIMockRecorder) ListObjectsV2PagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2PagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2PagesWithContext), varargs...) +} + +// ListObjectsV2Request mocks base method +func (m *MockS3API) ListObjectsV2Request(arg0 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) { + ret := m.ctrl.Call(m, "ListObjectsV2Request", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListObjectsV2Output) + return ret0, ret1 +} + +// ListObjectsV2Request indicates an expected call of ListObjectsV2Request +func (mr *MockS3APIMockRecorder) ListObjectsV2Request(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2Request", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2Request), arg0) +} + +// ListObjectsV2WithContext mocks base method +func (m *MockS3API) ListObjectsV2WithContext(arg0 aws.Context, arg1 *s3.ListObjectsV2Input, arg2 ...request.Option) (*s3.ListObjectsV2Output, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListObjectsV2WithContext", varargs...) + ret0, _ := ret[0].(*s3.ListObjectsV2Output) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObjectsV2WithContext indicates an expected call of ListObjectsV2WithContext +func (mr *MockS3APIMockRecorder) ListObjectsV2WithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsV2WithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsV2WithContext), varargs...) +} + +// ListObjectsWithContext mocks base method +func (m *MockS3API) ListObjectsWithContext(arg0 aws.Context, arg1 *s3.ListObjectsInput, arg2 ...request.Option) (*s3.ListObjectsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListObjectsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListObjectsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListObjectsWithContext indicates an expected call of ListObjectsWithContext +func (mr *MockS3APIMockRecorder) ListObjectsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListObjectsWithContext", reflect.TypeOf((*MockS3API)(nil).ListObjectsWithContext), varargs...) +} + +// ListParts mocks base method +func (m *MockS3API) ListParts(arg0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) { + ret := m.ctrl.Call(m, "ListParts", arg0) + ret0, _ := ret[0].(*s3.ListPartsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListParts indicates an expected call of ListParts +func (mr *MockS3APIMockRecorder) ListParts(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListParts", reflect.TypeOf((*MockS3API)(nil).ListParts), arg0) +} + +// ListPartsPages mocks base method +func (m *MockS3API) ListPartsPages(arg0 *s3.ListPartsInput, arg1 func(*s3.ListPartsOutput, bool) bool) error { + ret := m.ctrl.Call(m, "ListPartsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPartsPages indicates an expected call of ListPartsPages +func (mr *MockS3APIMockRecorder) ListPartsPages(arg0, arg1 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsPages", reflect.TypeOf((*MockS3API)(nil).ListPartsPages), arg0, arg1) +} + +// ListPartsPagesWithContext mocks base method +func (m *MockS3API) ListPartsPagesWithContext(arg0 aws.Context, arg1 *s3.ListPartsInput, arg2 func(*s3.ListPartsOutput, bool) bool, arg3 ...request.Option) error { + varargs := []interface{}{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPartsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// ListPartsPagesWithContext indicates an expected call of ListPartsPagesWithContext +func (mr *MockS3APIMockRecorder) ListPartsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsPagesWithContext", reflect.TypeOf((*MockS3API)(nil).ListPartsPagesWithContext), varargs...) +} + +// ListPartsRequest mocks base method +func (m *MockS3API) ListPartsRequest(arg0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) { + ret := m.ctrl.Call(m, "ListPartsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.ListPartsOutput) + return ret0, ret1 +} + +// ListPartsRequest indicates an expected call of ListPartsRequest +func (mr *MockS3APIMockRecorder) ListPartsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsRequest", reflect.TypeOf((*MockS3API)(nil).ListPartsRequest), arg0) +} + +// ListPartsWithContext mocks base method +func (m *MockS3API) ListPartsWithContext(arg0 aws.Context, arg1 *s3.ListPartsInput, arg2 ...request.Option) (*s3.ListPartsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListPartsWithContext", varargs...) + ret0, _ := ret[0].(*s3.ListPartsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListPartsWithContext indicates an expected call of ListPartsWithContext +func (mr *MockS3APIMockRecorder) ListPartsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartsWithContext", reflect.TypeOf((*MockS3API)(nil).ListPartsWithContext), varargs...) +} + +// PutBucketAccelerateConfiguration mocks base method +func (m *MockS3API) PutBucketAccelerateConfiguration(arg0 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketAccelerateConfiguration", arg0) + ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketAccelerateConfiguration indicates an expected call of PutBucketAccelerateConfiguration +func (mr *MockS3APIMockRecorder) PutBucketAccelerateConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketAccelerateConfiguration), arg0) +} + +// PutBucketAccelerateConfigurationRequest mocks base method +func (m *MockS3API) PutBucketAccelerateConfigurationRequest(arg0 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) { + ret := m.ctrl.Call(m, "PutBucketAccelerateConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketAccelerateConfigurationOutput) + return ret0, ret1 +} + +// PutBucketAccelerateConfigurationRequest indicates an expected call of PutBucketAccelerateConfigurationRequest +func (mr *MockS3APIMockRecorder) PutBucketAccelerateConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketAccelerateConfigurationRequest), arg0) +} + +// PutBucketAccelerateConfigurationWithContext mocks base method +func (m *MockS3API) PutBucketAccelerateConfigurationWithContext(arg0 aws.Context, arg1 *s3.PutBucketAccelerateConfigurationInput, arg2 ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketAccelerateConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketAccelerateConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketAccelerateConfigurationWithContext indicates an expected call of PutBucketAccelerateConfigurationWithContext +func (mr *MockS3APIMockRecorder) PutBucketAccelerateConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAccelerateConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketAccelerateConfigurationWithContext), varargs...) +} + +// PutBucketAcl mocks base method +func (m *MockS3API) PutBucketAcl(arg0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) { + ret := m.ctrl.Call(m, "PutBucketAcl", arg0) + ret0, _ := ret[0].(*s3.PutBucketAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketAcl indicates an expected call of PutBucketAcl +func (mr *MockS3APIMockRecorder) PutBucketAcl(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAcl", reflect.TypeOf((*MockS3API)(nil).PutBucketAcl), arg0) +} + +// PutBucketAclRequest mocks base method +func (m *MockS3API) PutBucketAclRequest(arg0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) { + ret := m.ctrl.Call(m, "PutBucketAclRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketAclOutput) + return ret0, ret1 +} + +// PutBucketAclRequest indicates an expected call of PutBucketAclRequest +func (mr *MockS3APIMockRecorder) PutBucketAclRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAclRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketAclRequest), arg0) +} + +// PutBucketAclWithContext mocks base method +func (m *MockS3API) PutBucketAclWithContext(arg0 aws.Context, arg1 *s3.PutBucketAclInput, arg2 ...request.Option) (*s3.PutBucketAclOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketAclWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketAclWithContext indicates an expected call of PutBucketAclWithContext +func (mr *MockS3APIMockRecorder) PutBucketAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAclWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketAclWithContext), varargs...) +} + +// PutBucketAnalyticsConfiguration mocks base method +func (m *MockS3API) PutBucketAnalyticsConfiguration(arg0 *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketAnalyticsConfiguration", arg0) + ret0, _ := ret[0].(*s3.PutBucketAnalyticsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketAnalyticsConfiguration indicates an expected call of PutBucketAnalyticsConfiguration +func (mr *MockS3APIMockRecorder) PutBucketAnalyticsConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketAnalyticsConfiguration), arg0) +} + +// PutBucketAnalyticsConfigurationRequest mocks base method +func (m *MockS3API) PutBucketAnalyticsConfigurationRequest(arg0 *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) { + ret := m.ctrl.Call(m, "PutBucketAnalyticsConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketAnalyticsConfigurationOutput) + return ret0, ret1 +} + +// PutBucketAnalyticsConfigurationRequest indicates an expected call of PutBucketAnalyticsConfigurationRequest +func (mr *MockS3APIMockRecorder) PutBucketAnalyticsConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketAnalyticsConfigurationRequest), arg0) +} + +// PutBucketAnalyticsConfigurationWithContext mocks base method +func (m *MockS3API) PutBucketAnalyticsConfigurationWithContext(arg0 aws.Context, arg1 *s3.PutBucketAnalyticsConfigurationInput, arg2 ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketAnalyticsConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketAnalyticsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketAnalyticsConfigurationWithContext indicates an expected call of PutBucketAnalyticsConfigurationWithContext +func (mr *MockS3APIMockRecorder) PutBucketAnalyticsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketAnalyticsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketAnalyticsConfigurationWithContext), varargs...) +} + +// PutBucketCors mocks base method +func (m *MockS3API) PutBucketCors(arg0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) { + ret := m.ctrl.Call(m, "PutBucketCors", arg0) + ret0, _ := ret[0].(*s3.PutBucketCorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketCors indicates an expected call of PutBucketCors +func (mr *MockS3APIMockRecorder) PutBucketCors(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCors", reflect.TypeOf((*MockS3API)(nil).PutBucketCors), arg0) +} + +// PutBucketCorsRequest mocks base method +func (m *MockS3API) PutBucketCorsRequest(arg0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) { + ret := m.ctrl.Call(m, "PutBucketCorsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketCorsOutput) + return ret0, ret1 +} + +// PutBucketCorsRequest indicates an expected call of PutBucketCorsRequest +func (mr *MockS3APIMockRecorder) PutBucketCorsRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCorsRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketCorsRequest), arg0) +} + +// PutBucketCorsWithContext mocks base method +func (m *MockS3API) PutBucketCorsWithContext(arg0 aws.Context, arg1 *s3.PutBucketCorsInput, arg2 ...request.Option) (*s3.PutBucketCorsOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketCorsWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketCorsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketCorsWithContext indicates an expected call of PutBucketCorsWithContext +func (mr *MockS3APIMockRecorder) PutBucketCorsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketCorsWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketCorsWithContext), varargs...) +} + +// PutBucketEncryption mocks base method +func (m *MockS3API) PutBucketEncryption(arg0 *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) { + ret := m.ctrl.Call(m, "PutBucketEncryption", arg0) + ret0, _ := ret[0].(*s3.PutBucketEncryptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketEncryption indicates an expected call of PutBucketEncryption +func (mr *MockS3APIMockRecorder) PutBucketEncryption(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryption", reflect.TypeOf((*MockS3API)(nil).PutBucketEncryption), arg0) +} + +// PutBucketEncryptionRequest mocks base method +func (m *MockS3API) PutBucketEncryptionRequest(arg0 *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) { + ret := m.ctrl.Call(m, "PutBucketEncryptionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketEncryptionOutput) + return ret0, ret1 +} + +// PutBucketEncryptionRequest indicates an expected call of PutBucketEncryptionRequest +func (mr *MockS3APIMockRecorder) PutBucketEncryptionRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryptionRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketEncryptionRequest), arg0) +} + +// PutBucketEncryptionWithContext mocks base method +func (m *MockS3API) PutBucketEncryptionWithContext(arg0 aws.Context, arg1 *s3.PutBucketEncryptionInput, arg2 ...request.Option) (*s3.PutBucketEncryptionOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketEncryptionWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketEncryptionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketEncryptionWithContext indicates an expected call of PutBucketEncryptionWithContext +func (mr *MockS3APIMockRecorder) PutBucketEncryptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketEncryptionWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketEncryptionWithContext), varargs...) +} + +// PutBucketInventoryConfiguration mocks base method +func (m *MockS3API) PutBucketInventoryConfiguration(arg0 *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketInventoryConfiguration", arg0) + ret0, _ := ret[0].(*s3.PutBucketInventoryConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketInventoryConfiguration indicates an expected call of PutBucketInventoryConfiguration +func (mr *MockS3APIMockRecorder) PutBucketInventoryConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketInventoryConfiguration), arg0) +} + +// PutBucketInventoryConfigurationRequest mocks base method +func (m *MockS3API) PutBucketInventoryConfigurationRequest(arg0 *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) { + ret := m.ctrl.Call(m, "PutBucketInventoryConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketInventoryConfigurationOutput) + return ret0, ret1 +} + +// PutBucketInventoryConfigurationRequest indicates an expected call of PutBucketInventoryConfigurationRequest +func (mr *MockS3APIMockRecorder) PutBucketInventoryConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketInventoryConfigurationRequest), arg0) +} + +// PutBucketInventoryConfigurationWithContext mocks base method +func (m *MockS3API) PutBucketInventoryConfigurationWithContext(arg0 aws.Context, arg1 *s3.PutBucketInventoryConfigurationInput, arg2 ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketInventoryConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketInventoryConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketInventoryConfigurationWithContext indicates an expected call of PutBucketInventoryConfigurationWithContext +func (mr *MockS3APIMockRecorder) PutBucketInventoryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketInventoryConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketInventoryConfigurationWithContext), varargs...) +} + +// PutBucketLifecycle mocks base method +func (m *MockS3API) PutBucketLifecycle(arg0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) { + ret := m.ctrl.Call(m, "PutBucketLifecycle", arg0) + ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketLifecycle indicates an expected call of PutBucketLifecycle +func (mr *MockS3APIMockRecorder) PutBucketLifecycle(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycle", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycle), arg0) +} + +// PutBucketLifecycleConfiguration mocks base method +func (m *MockS3API) PutBucketLifecycleConfiguration(arg0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketLifecycleConfiguration", arg0) + ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketLifecycleConfiguration indicates an expected call of PutBucketLifecycleConfiguration +func (mr *MockS3APIMockRecorder) PutBucketLifecycleConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleConfiguration), arg0) +} + +// PutBucketLifecycleConfigurationRequest mocks base method +func (m *MockS3API) PutBucketLifecycleConfigurationRequest(arg0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) { + ret := m.ctrl.Call(m, "PutBucketLifecycleConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketLifecycleConfigurationOutput) + return ret0, ret1 +} + +// PutBucketLifecycleConfigurationRequest indicates an expected call of PutBucketLifecycleConfigurationRequest +func (mr *MockS3APIMockRecorder) PutBucketLifecycleConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleConfigurationRequest), arg0) +} + +// PutBucketLifecycleConfigurationWithContext mocks base method +func (m *MockS3API) PutBucketLifecycleConfigurationWithContext(arg0 aws.Context, arg1 *s3.PutBucketLifecycleConfigurationInput, arg2 ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketLifecycleConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketLifecycleConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketLifecycleConfigurationWithContext indicates an expected call of PutBucketLifecycleConfigurationWithContext +func (mr *MockS3APIMockRecorder) PutBucketLifecycleConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleConfigurationWithContext), varargs...) +} + +// PutBucketLifecycleRequest mocks base method +func (m *MockS3API) PutBucketLifecycleRequest(arg0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) { + ret := m.ctrl.Call(m, "PutBucketLifecycleRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketLifecycleOutput) + return ret0, ret1 +} + +// PutBucketLifecycleRequest indicates an expected call of PutBucketLifecycleRequest +func (mr *MockS3APIMockRecorder) PutBucketLifecycleRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleRequest), arg0) +} + +// PutBucketLifecycleWithContext mocks base method +func (m *MockS3API) PutBucketLifecycleWithContext(arg0 aws.Context, arg1 *s3.PutBucketLifecycleInput, arg2 ...request.Option) (*s3.PutBucketLifecycleOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketLifecycleWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketLifecycleOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketLifecycleWithContext indicates an expected call of PutBucketLifecycleWithContext +func (mr *MockS3APIMockRecorder) PutBucketLifecycleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLifecycleWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketLifecycleWithContext), varargs...) +} + +// PutBucketLogging mocks base method +func (m *MockS3API) PutBucketLogging(arg0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) { + ret := m.ctrl.Call(m, "PutBucketLogging", arg0) + ret0, _ := ret[0].(*s3.PutBucketLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketLogging indicates an expected call of PutBucketLogging +func (mr *MockS3APIMockRecorder) PutBucketLogging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLogging", reflect.TypeOf((*MockS3API)(nil).PutBucketLogging), arg0) +} + +// PutBucketLoggingRequest mocks base method +func (m *MockS3API) PutBucketLoggingRequest(arg0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) { + ret := m.ctrl.Call(m, "PutBucketLoggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketLoggingOutput) + return ret0, ret1 +} + +// PutBucketLoggingRequest indicates an expected call of PutBucketLoggingRequest +func (mr *MockS3APIMockRecorder) PutBucketLoggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLoggingRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketLoggingRequest), arg0) +} + +// PutBucketLoggingWithContext mocks base method +func (m *MockS3API) PutBucketLoggingWithContext(arg0 aws.Context, arg1 *s3.PutBucketLoggingInput, arg2 ...request.Option) (*s3.PutBucketLoggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketLoggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketLoggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketLoggingWithContext indicates an expected call of PutBucketLoggingWithContext +func (mr *MockS3APIMockRecorder) PutBucketLoggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketLoggingWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketLoggingWithContext), varargs...) +} + +// PutBucketMetricsConfiguration mocks base method +func (m *MockS3API) PutBucketMetricsConfiguration(arg0 *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketMetricsConfiguration", arg0) + ret0, _ := ret[0].(*s3.PutBucketMetricsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketMetricsConfiguration indicates an expected call of PutBucketMetricsConfiguration +func (mr *MockS3APIMockRecorder) PutBucketMetricsConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketMetricsConfiguration), arg0) +} + +// PutBucketMetricsConfigurationRequest mocks base method +func (m *MockS3API) PutBucketMetricsConfigurationRequest(arg0 *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) { + ret := m.ctrl.Call(m, "PutBucketMetricsConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketMetricsConfigurationOutput) + return ret0, ret1 +} + +// PutBucketMetricsConfigurationRequest indicates an expected call of PutBucketMetricsConfigurationRequest +func (mr *MockS3APIMockRecorder) PutBucketMetricsConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketMetricsConfigurationRequest), arg0) +} + +// PutBucketMetricsConfigurationWithContext mocks base method +func (m *MockS3API) PutBucketMetricsConfigurationWithContext(arg0 aws.Context, arg1 *s3.PutBucketMetricsConfigurationInput, arg2 ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketMetricsConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketMetricsConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketMetricsConfigurationWithContext indicates an expected call of PutBucketMetricsConfigurationWithContext +func (mr *MockS3APIMockRecorder) PutBucketMetricsConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketMetricsConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketMetricsConfigurationWithContext), varargs...) +} + +// PutBucketNotification mocks base method +func (m *MockS3API) PutBucketNotification(arg0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketNotification", arg0) + ret0, _ := ret[0].(*s3.PutBucketNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketNotification indicates an expected call of PutBucketNotification +func (mr *MockS3APIMockRecorder) PutBucketNotification(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotification", reflect.TypeOf((*MockS3API)(nil).PutBucketNotification), arg0) +} + +// PutBucketNotificationConfiguration mocks base method +func (m *MockS3API) PutBucketNotificationConfiguration(arg0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketNotificationConfiguration", arg0) + ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketNotificationConfiguration indicates an expected call of PutBucketNotificationConfiguration +func (mr *MockS3APIMockRecorder) PutBucketNotificationConfiguration(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfiguration", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationConfiguration), arg0) +} + +// PutBucketNotificationConfigurationRequest mocks base method +func (m *MockS3API) PutBucketNotificationConfigurationRequest(arg0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) { + ret := m.ctrl.Call(m, "PutBucketNotificationConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketNotificationConfigurationOutput) + return ret0, ret1 +} + +// PutBucketNotificationConfigurationRequest indicates an expected call of PutBucketNotificationConfigurationRequest +func (mr *MockS3APIMockRecorder) PutBucketNotificationConfigurationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfigurationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationConfigurationRequest), arg0) +} + +// PutBucketNotificationConfigurationWithContext mocks base method +func (m *MockS3API) PutBucketNotificationConfigurationWithContext(arg0 aws.Context, arg1 *s3.PutBucketNotificationConfigurationInput, arg2 ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketNotificationConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketNotificationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketNotificationConfigurationWithContext indicates an expected call of PutBucketNotificationConfigurationWithContext +func (mr *MockS3APIMockRecorder) PutBucketNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationConfigurationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationConfigurationWithContext), varargs...) +} + +// PutBucketNotificationRequest mocks base method +func (m *MockS3API) PutBucketNotificationRequest(arg0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) { + ret := m.ctrl.Call(m, "PutBucketNotificationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketNotificationOutput) + return ret0, ret1 +} + +// PutBucketNotificationRequest indicates an expected call of PutBucketNotificationRequest +func (mr *MockS3APIMockRecorder) PutBucketNotificationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationRequest), arg0) +} + +// PutBucketNotificationWithContext mocks base method +func (m *MockS3API) PutBucketNotificationWithContext(arg0 aws.Context, arg1 *s3.PutBucketNotificationInput, arg2 ...request.Option) (*s3.PutBucketNotificationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketNotificationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketNotificationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketNotificationWithContext indicates an expected call of PutBucketNotificationWithContext +func (mr *MockS3APIMockRecorder) PutBucketNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketNotificationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketNotificationWithContext), varargs...) +} + +// PutBucketPolicy mocks base method +func (m *MockS3API) PutBucketPolicy(arg0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) { + ret := m.ctrl.Call(m, "PutBucketPolicy", arg0) + ret0, _ := ret[0].(*s3.PutBucketPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketPolicy indicates an expected call of PutBucketPolicy +func (mr *MockS3APIMockRecorder) PutBucketPolicy(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicy", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicy), arg0) +} + +// PutBucketPolicyRequest mocks base method +func (m *MockS3API) PutBucketPolicyRequest(arg0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) { + ret := m.ctrl.Call(m, "PutBucketPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketPolicyOutput) + return ret0, ret1 +} + +// PutBucketPolicyRequest indicates an expected call of PutBucketPolicyRequest +func (mr *MockS3APIMockRecorder) PutBucketPolicyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicyRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicyRequest), arg0) +} + +// PutBucketPolicyWithContext mocks base method +func (m *MockS3API) PutBucketPolicyWithContext(arg0 aws.Context, arg1 *s3.PutBucketPolicyInput, arg2 ...request.Option) (*s3.PutBucketPolicyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketPolicyWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketPolicyWithContext indicates an expected call of PutBucketPolicyWithContext +func (mr *MockS3APIMockRecorder) PutBucketPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketPolicyWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketPolicyWithContext), varargs...) +} + +// PutBucketReplication mocks base method +func (m *MockS3API) PutBucketReplication(arg0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) { + ret := m.ctrl.Call(m, "PutBucketReplication", arg0) + ret0, _ := ret[0].(*s3.PutBucketReplicationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketReplication indicates an expected call of PutBucketReplication +func (mr *MockS3APIMockRecorder) PutBucketReplication(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplication", reflect.TypeOf((*MockS3API)(nil).PutBucketReplication), arg0) +} + +// PutBucketReplicationRequest mocks base method +func (m *MockS3API) PutBucketReplicationRequest(arg0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) { + ret := m.ctrl.Call(m, "PutBucketReplicationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketReplicationOutput) + return ret0, ret1 +} + +// PutBucketReplicationRequest indicates an expected call of PutBucketReplicationRequest +func (mr *MockS3APIMockRecorder) PutBucketReplicationRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplicationRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketReplicationRequest), arg0) +} + +// PutBucketReplicationWithContext mocks base method +func (m *MockS3API) PutBucketReplicationWithContext(arg0 aws.Context, arg1 *s3.PutBucketReplicationInput, arg2 ...request.Option) (*s3.PutBucketReplicationOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketReplicationWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketReplicationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketReplicationWithContext indicates an expected call of PutBucketReplicationWithContext +func (mr *MockS3APIMockRecorder) PutBucketReplicationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketReplicationWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketReplicationWithContext), varargs...) +} + +// PutBucketRequestPayment mocks base method +func (m *MockS3API) PutBucketRequestPayment(arg0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) { + ret := m.ctrl.Call(m, "PutBucketRequestPayment", arg0) + ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketRequestPayment indicates an expected call of PutBucketRequestPayment +func (mr *MockS3APIMockRecorder) PutBucketRequestPayment(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPayment", reflect.TypeOf((*MockS3API)(nil).PutBucketRequestPayment), arg0) +} + +// PutBucketRequestPaymentRequest mocks base method +func (m *MockS3API) PutBucketRequestPaymentRequest(arg0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) { + ret := m.ctrl.Call(m, "PutBucketRequestPaymentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketRequestPaymentOutput) + return ret0, ret1 +} + +// PutBucketRequestPaymentRequest indicates an expected call of PutBucketRequestPaymentRequest +func (mr *MockS3APIMockRecorder) PutBucketRequestPaymentRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPaymentRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketRequestPaymentRequest), arg0) +} + +// PutBucketRequestPaymentWithContext mocks base method +func (m *MockS3API) PutBucketRequestPaymentWithContext(arg0 aws.Context, arg1 *s3.PutBucketRequestPaymentInput, arg2 ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketRequestPaymentWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketRequestPaymentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketRequestPaymentWithContext indicates an expected call of PutBucketRequestPaymentWithContext +func (mr *MockS3APIMockRecorder) PutBucketRequestPaymentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketRequestPaymentWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketRequestPaymentWithContext), varargs...) +} + +// PutBucketTagging mocks base method +func (m *MockS3API) PutBucketTagging(arg0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) { + ret := m.ctrl.Call(m, "PutBucketTagging", arg0) + ret0, _ := ret[0].(*s3.PutBucketTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketTagging indicates an expected call of PutBucketTagging +func (mr *MockS3APIMockRecorder) PutBucketTagging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTagging", reflect.TypeOf((*MockS3API)(nil).PutBucketTagging), arg0) +} + +// PutBucketTaggingRequest mocks base method +func (m *MockS3API) PutBucketTaggingRequest(arg0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) { + ret := m.ctrl.Call(m, "PutBucketTaggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketTaggingOutput) + return ret0, ret1 +} + +// PutBucketTaggingRequest indicates an expected call of PutBucketTaggingRequest +func (mr *MockS3APIMockRecorder) PutBucketTaggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTaggingRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketTaggingRequest), arg0) +} + +// PutBucketTaggingWithContext mocks base method +func (m *MockS3API) PutBucketTaggingWithContext(arg0 aws.Context, arg1 *s3.PutBucketTaggingInput, arg2 ...request.Option) (*s3.PutBucketTaggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketTaggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketTaggingWithContext indicates an expected call of PutBucketTaggingWithContext +func (mr *MockS3APIMockRecorder) PutBucketTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketTaggingWithContext), varargs...) +} + +// PutBucketVersioning mocks base method +func (m *MockS3API) PutBucketVersioning(arg0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) { + ret := m.ctrl.Call(m, "PutBucketVersioning", arg0) + ret0, _ := ret[0].(*s3.PutBucketVersioningOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketVersioning indicates an expected call of PutBucketVersioning +func (mr *MockS3APIMockRecorder) PutBucketVersioning(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioning", reflect.TypeOf((*MockS3API)(nil).PutBucketVersioning), arg0) +} + +// PutBucketVersioningRequest mocks base method +func (m *MockS3API) PutBucketVersioningRequest(arg0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) { + ret := m.ctrl.Call(m, "PutBucketVersioningRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketVersioningOutput) + return ret0, ret1 +} + +// PutBucketVersioningRequest indicates an expected call of PutBucketVersioningRequest +func (mr *MockS3APIMockRecorder) PutBucketVersioningRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioningRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketVersioningRequest), arg0) +} + +// PutBucketVersioningWithContext mocks base method +func (m *MockS3API) PutBucketVersioningWithContext(arg0 aws.Context, arg1 *s3.PutBucketVersioningInput, arg2 ...request.Option) (*s3.PutBucketVersioningOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketVersioningWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketVersioningOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketVersioningWithContext indicates an expected call of PutBucketVersioningWithContext +func (mr *MockS3APIMockRecorder) PutBucketVersioningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketVersioningWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketVersioningWithContext), varargs...) +} + +// PutBucketWebsite mocks base method +func (m *MockS3API) PutBucketWebsite(arg0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) { + ret := m.ctrl.Call(m, "PutBucketWebsite", arg0) + ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketWebsite indicates an expected call of PutBucketWebsite +func (mr *MockS3APIMockRecorder) PutBucketWebsite(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsite", reflect.TypeOf((*MockS3API)(nil).PutBucketWebsite), arg0) +} + +// PutBucketWebsiteRequest mocks base method +func (m *MockS3API) PutBucketWebsiteRequest(arg0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) { + ret := m.ctrl.Call(m, "PutBucketWebsiteRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutBucketWebsiteOutput) + return ret0, ret1 +} + +// PutBucketWebsiteRequest indicates an expected call of PutBucketWebsiteRequest +func (mr *MockS3APIMockRecorder) PutBucketWebsiteRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsiteRequest", reflect.TypeOf((*MockS3API)(nil).PutBucketWebsiteRequest), arg0) +} + +// PutBucketWebsiteWithContext mocks base method +func (m *MockS3API) PutBucketWebsiteWithContext(arg0 aws.Context, arg1 *s3.PutBucketWebsiteInput, arg2 ...request.Option) (*s3.PutBucketWebsiteOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutBucketWebsiteWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutBucketWebsiteOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutBucketWebsiteWithContext indicates an expected call of PutBucketWebsiteWithContext +func (mr *MockS3APIMockRecorder) PutBucketWebsiteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketWebsiteWithContext", reflect.TypeOf((*MockS3API)(nil).PutBucketWebsiteWithContext), varargs...) +} + +// PutObject mocks base method +func (m *MockS3API) PutObject(arg0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) { + ret := m.ctrl.Call(m, "PutObject", arg0) + ret0, _ := ret[0].(*s3.PutObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObject indicates an expected call of PutObject +func (mr *MockS3APIMockRecorder) PutObject(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockS3API)(nil).PutObject), arg0) +} + +// PutObjectAcl mocks base method +func (m *MockS3API) PutObjectAcl(arg0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) { + ret := m.ctrl.Call(m, "PutObjectAcl", arg0) + ret0, _ := ret[0].(*s3.PutObjectAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObjectAcl indicates an expected call of PutObjectAcl +func (mr *MockS3APIMockRecorder) PutObjectAcl(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAcl", reflect.TypeOf((*MockS3API)(nil).PutObjectAcl), arg0) +} + +// PutObjectAclRequest mocks base method +func (m *MockS3API) PutObjectAclRequest(arg0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) { + ret := m.ctrl.Call(m, "PutObjectAclRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutObjectAclOutput) + return ret0, ret1 +} + +// PutObjectAclRequest indicates an expected call of PutObjectAclRequest +func (mr *MockS3APIMockRecorder) PutObjectAclRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAclRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectAclRequest), arg0) +} + +// PutObjectAclWithContext mocks base method +func (m *MockS3API) PutObjectAclWithContext(arg0 aws.Context, arg1 *s3.PutObjectAclInput, arg2 ...request.Option) (*s3.PutObjectAclOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutObjectAclWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutObjectAclOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObjectAclWithContext indicates an expected call of PutObjectAclWithContext +func (mr *MockS3APIMockRecorder) PutObjectAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectAclWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectAclWithContext), varargs...) +} + +// PutObjectRequest mocks base method +func (m *MockS3API) PutObjectRequest(arg0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) { + ret := m.ctrl.Call(m, "PutObjectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutObjectOutput) + return ret0, ret1 +} + +// PutObjectRequest indicates an expected call of PutObjectRequest +func (mr *MockS3APIMockRecorder) PutObjectRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectRequest), arg0) +} + +// PutObjectTagging mocks base method +func (m *MockS3API) PutObjectTagging(arg0 *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) { + ret := m.ctrl.Call(m, "PutObjectTagging", arg0) + ret0, _ := ret[0].(*s3.PutObjectTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObjectTagging indicates an expected call of PutObjectTagging +func (mr *MockS3APIMockRecorder) PutObjectTagging(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTagging", reflect.TypeOf((*MockS3API)(nil).PutObjectTagging), arg0) +} + +// PutObjectTaggingRequest mocks base method +func (m *MockS3API) PutObjectTaggingRequest(arg0 *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) { + ret := m.ctrl.Call(m, "PutObjectTaggingRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.PutObjectTaggingOutput) + return ret0, ret1 +} + +// PutObjectTaggingRequest indicates an expected call of PutObjectTaggingRequest +func (mr *MockS3APIMockRecorder) PutObjectTaggingRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTaggingRequest", reflect.TypeOf((*MockS3API)(nil).PutObjectTaggingRequest), arg0) +} + +// PutObjectTaggingWithContext mocks base method +func (m *MockS3API) PutObjectTaggingWithContext(arg0 aws.Context, arg1 *s3.PutObjectTaggingInput, arg2 ...request.Option) (*s3.PutObjectTaggingOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutObjectTaggingWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutObjectTaggingOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObjectTaggingWithContext indicates an expected call of PutObjectTaggingWithContext +func (mr *MockS3APIMockRecorder) PutObjectTaggingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectTaggingWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectTaggingWithContext), varargs...) +} + +// PutObjectWithContext mocks base method +func (m *MockS3API) PutObjectWithContext(arg0 aws.Context, arg1 *s3.PutObjectInput, arg2 ...request.Option) (*s3.PutObjectOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutObjectWithContext", varargs...) + ret0, _ := ret[0].(*s3.PutObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutObjectWithContext indicates an expected call of PutObjectWithContext +func (mr *MockS3APIMockRecorder) PutObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObjectWithContext", reflect.TypeOf((*MockS3API)(nil).PutObjectWithContext), varargs...) +} + +// RestoreObject mocks base method +func (m *MockS3API) RestoreObject(arg0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) { + ret := m.ctrl.Call(m, "RestoreObject", arg0) + ret0, _ := ret[0].(*s3.RestoreObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreObject indicates an expected call of RestoreObject +func (mr *MockS3APIMockRecorder) RestoreObject(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObject", reflect.TypeOf((*MockS3API)(nil).RestoreObject), arg0) +} + +// RestoreObjectRequest mocks base method +func (m *MockS3API) RestoreObjectRequest(arg0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) { + ret := m.ctrl.Call(m, "RestoreObjectRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.RestoreObjectOutput) + return ret0, ret1 +} + +// RestoreObjectRequest indicates an expected call of RestoreObjectRequest +func (mr *MockS3APIMockRecorder) RestoreObjectRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObjectRequest", reflect.TypeOf((*MockS3API)(nil).RestoreObjectRequest), arg0) +} + +// RestoreObjectWithContext mocks base method +func (m *MockS3API) RestoreObjectWithContext(arg0 aws.Context, arg1 *s3.RestoreObjectInput, arg2 ...request.Option) (*s3.RestoreObjectOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RestoreObjectWithContext", varargs...) + ret0, _ := ret[0].(*s3.RestoreObjectOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RestoreObjectWithContext indicates an expected call of RestoreObjectWithContext +func (mr *MockS3APIMockRecorder) RestoreObjectWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreObjectWithContext", reflect.TypeOf((*MockS3API)(nil).RestoreObjectWithContext), varargs...) +} + +// SelectObjectContent mocks base method +func (m *MockS3API) SelectObjectContent(arg0 *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) { + ret := m.ctrl.Call(m, "SelectObjectContent", arg0) + ret0, _ := ret[0].(*s3.SelectObjectContentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelectObjectContent indicates an expected call of SelectObjectContent +func (mr *MockS3APIMockRecorder) SelectObjectContent(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContent", reflect.TypeOf((*MockS3API)(nil).SelectObjectContent), arg0) +} + +// SelectObjectContentRequest mocks base method +func (m *MockS3API) SelectObjectContentRequest(arg0 *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) { + ret := m.ctrl.Call(m, "SelectObjectContentRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.SelectObjectContentOutput) + return ret0, ret1 +} + +// SelectObjectContentRequest indicates an expected call of SelectObjectContentRequest +func (mr *MockS3APIMockRecorder) SelectObjectContentRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContentRequest", reflect.TypeOf((*MockS3API)(nil).SelectObjectContentRequest), arg0) +} + +// SelectObjectContentWithContext mocks base method +func (m *MockS3API) SelectObjectContentWithContext(arg0 aws.Context, arg1 *s3.SelectObjectContentInput, arg2 ...request.Option) (*s3.SelectObjectContentOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SelectObjectContentWithContext", varargs...) + ret0, _ := ret[0].(*s3.SelectObjectContentOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelectObjectContentWithContext indicates an expected call of SelectObjectContentWithContext +func (mr *MockS3APIMockRecorder) SelectObjectContentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectObjectContentWithContext", reflect.TypeOf((*MockS3API)(nil).SelectObjectContentWithContext), varargs...) +} + +// UploadPart mocks base method +func (m *MockS3API) UploadPart(arg0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) { + ret := m.ctrl.Call(m, "UploadPart", arg0) + ret0, _ := ret[0].(*s3.UploadPartOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadPart indicates an expected call of UploadPart +func (mr *MockS3APIMockRecorder) UploadPart(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPart", reflect.TypeOf((*MockS3API)(nil).UploadPart), arg0) +} + +// UploadPartCopy mocks base method +func (m *MockS3API) UploadPartCopy(arg0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) { + ret := m.ctrl.Call(m, "UploadPartCopy", arg0) + ret0, _ := ret[0].(*s3.UploadPartCopyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadPartCopy indicates an expected call of UploadPartCopy +func (mr *MockS3APIMockRecorder) UploadPartCopy(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopy", reflect.TypeOf((*MockS3API)(nil).UploadPartCopy), arg0) +} + +// UploadPartCopyRequest mocks base method +func (m *MockS3API) UploadPartCopyRequest(arg0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) { + ret := m.ctrl.Call(m, "UploadPartCopyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.UploadPartCopyOutput) + return ret0, ret1 +} + +// UploadPartCopyRequest indicates an expected call of UploadPartCopyRequest +func (mr *MockS3APIMockRecorder) UploadPartCopyRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopyRequest", reflect.TypeOf((*MockS3API)(nil).UploadPartCopyRequest), arg0) +} + +// UploadPartCopyWithContext mocks base method +func (m *MockS3API) UploadPartCopyWithContext(arg0 aws.Context, arg1 *s3.UploadPartCopyInput, arg2 ...request.Option) (*s3.UploadPartCopyOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UploadPartCopyWithContext", varargs...) + ret0, _ := ret[0].(*s3.UploadPartCopyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadPartCopyWithContext indicates an expected call of UploadPartCopyWithContext +func (mr *MockS3APIMockRecorder) UploadPartCopyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartCopyWithContext", reflect.TypeOf((*MockS3API)(nil).UploadPartCopyWithContext), varargs...) +} + +// UploadPartRequest mocks base method +func (m *MockS3API) UploadPartRequest(arg0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) { + ret := m.ctrl.Call(m, "UploadPartRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*s3.UploadPartOutput) + return ret0, ret1 +} + +// UploadPartRequest indicates an expected call of UploadPartRequest +func (mr *MockS3APIMockRecorder) UploadPartRequest(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartRequest", reflect.TypeOf((*MockS3API)(nil).UploadPartRequest), arg0) +} + +// UploadPartWithContext mocks base method +func (m *MockS3API) UploadPartWithContext(arg0 aws.Context, arg1 *s3.UploadPartInput, arg2 ...request.Option) (*s3.UploadPartOutput, error) { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UploadPartWithContext", varargs...) + ret0, _ := ret[0].(*s3.UploadPartOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UploadPartWithContext indicates an expected call of UploadPartWithContext +func (mr *MockS3APIMockRecorder) UploadPartWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadPartWithContext", reflect.TypeOf((*MockS3API)(nil).UploadPartWithContext), varargs...) +} + +// WaitUntilBucketExists mocks base method +func (m *MockS3API) WaitUntilBucketExists(arg0 *s3.HeadBucketInput) error { + ret := m.ctrl.Call(m, "WaitUntilBucketExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilBucketExists indicates an expected call of WaitUntilBucketExists +func (mr *MockS3APIMockRecorder) WaitUntilBucketExists(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketExists), arg0) +} + +// WaitUntilBucketExistsWithContext mocks base method +func (m *MockS3API) WaitUntilBucketExistsWithContext(arg0 aws.Context, arg1 *s3.HeadBucketInput, arg2 ...request.WaiterOption) error { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilBucketExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilBucketExistsWithContext indicates an expected call of WaitUntilBucketExistsWithContext +func (mr *MockS3APIMockRecorder) WaitUntilBucketExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketExistsWithContext), varargs...) +} + +// WaitUntilBucketNotExists mocks base method +func (m *MockS3API) WaitUntilBucketNotExists(arg0 *s3.HeadBucketInput) error { + ret := m.ctrl.Call(m, "WaitUntilBucketNotExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilBucketNotExists indicates an expected call of WaitUntilBucketNotExists +func (mr *MockS3APIMockRecorder) WaitUntilBucketNotExists(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketNotExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketNotExists), arg0) +} + +// WaitUntilBucketNotExistsWithContext mocks base method +func (m *MockS3API) WaitUntilBucketNotExistsWithContext(arg0 aws.Context, arg1 *s3.HeadBucketInput, arg2 ...request.WaiterOption) error { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilBucketNotExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilBucketNotExistsWithContext indicates an expected call of WaitUntilBucketNotExistsWithContext +func (mr *MockS3APIMockRecorder) WaitUntilBucketNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBucketNotExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilBucketNotExistsWithContext), varargs...) +} + +// WaitUntilObjectExists mocks base method +func (m *MockS3API) WaitUntilObjectExists(arg0 *s3.HeadObjectInput) error { + ret := m.ctrl.Call(m, "WaitUntilObjectExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilObjectExists indicates an expected call of WaitUntilObjectExists +func (mr *MockS3APIMockRecorder) WaitUntilObjectExists(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectExists), arg0) +} + +// WaitUntilObjectExistsWithContext mocks base method +func (m *MockS3API) WaitUntilObjectExistsWithContext(arg0 aws.Context, arg1 *s3.HeadObjectInput, arg2 ...request.WaiterOption) error { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilObjectExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilObjectExistsWithContext indicates an expected call of WaitUntilObjectExistsWithContext +func (mr *MockS3APIMockRecorder) WaitUntilObjectExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectExistsWithContext), varargs...) +} + +// WaitUntilObjectNotExists mocks base method +func (m *MockS3API) WaitUntilObjectNotExists(arg0 *s3.HeadObjectInput) error { + ret := m.ctrl.Call(m, "WaitUntilObjectNotExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilObjectNotExists indicates an expected call of WaitUntilObjectNotExists +func (mr *MockS3APIMockRecorder) WaitUntilObjectNotExists(arg0 interface{}) *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectNotExists", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectNotExists), arg0) +} + +// WaitUntilObjectNotExistsWithContext mocks base method +func (m *MockS3API) WaitUntilObjectNotExistsWithContext(arg0 aws.Context, arg1 *s3.HeadObjectInput, arg2 ...request.WaiterOption) error { + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "WaitUntilObjectNotExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilObjectNotExistsWithContext indicates an expected call of WaitUntilObjectNotExistsWithContext +func (mr *MockS3APIMockRecorder) WaitUntilObjectNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilObjectNotExistsWithContext", reflect.TypeOf((*MockS3API)(nil).WaitUntilObjectNotExistsWithContext), varargs...) +} diff --git a/transport/transporters/s3/transporter/transporter.go b/transport/transporters/s3/transporter/transporter.go new file mode 100644 index 00000000..39261b4f --- /dev/null +++ b/transport/transporters/s3/transporter/transporter.go @@ -0,0 +1,351 @@ +/* + Copyright 2019 Nextdoor.com, Inc. + + Licensed 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. + */ + +package transporter + +import ( + "bytes" + "compress/gzip" + "context" + "fmt" + "io/ioutil" + "strings" + "time" + + "github.com/Nextdoor/pg-bifrost.git/marshaller" + "github.com/Nextdoor/pg-bifrost.git/shutdown" + "github.com/Nextdoor/pg-bifrost.git/stats" + "github.com/Nextdoor/pg-bifrost.git/transport" + "github.com/Nextdoor/pg-bifrost.git/transport/batch" + "github.com/Nextdoor/pg-bifrost.git/utils" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/credentials" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/s3" + "github.com/aws/aws-sdk-go/service/s3/s3iface" + "github.com/cenkalti/backoff" + "github.com/cevaris/ordered_map" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" +) + +// Generate mock for s3 client +//go:generate mockgen -destination=mocks/mock_s3.go -package=mocks github.com/aws/aws-sdk-go/service/s3/s3iface S3API + +var ( + TimeSource utils.TimeSource = utils.RealTime{} +) + +// key_join is a helper to concatenate strings to form an S3 key +func key_join(strs ...string, ) string { + var sb strings.Builder + for i, str := range strs { + if str == "" || str == "/" { + continue + } + + // clean any leading and trailing slashes + str = strings.TrimRight(str, "/") + str = strings.TrimLeft(str, "/") + + // concatenate string and add trailing slash + sb.WriteString(str) + + if i != len(strs) - 1 { + sb.WriteString("/") + } + } + + sb.WriteString(".gz") + + return sb.String() +} + +type S3Transporter struct { + shutdownHandler shutdown.ShutdownHandler + + inputChan <-chan transport.Batch // receive a batch (slice) of MarshalledMessages + txnsWritten chan<- *ordered_map.OrderedMap // Map of + + statsChan chan stats.Stat + + log logrus.Entry + client s3iface.S3API + bucketName string + keySpace string + retryPolicy backoff.BackOff +} + +func NewTransporterWithInterface(shutdownHandler shutdown.ShutdownHandler, + inputChan <-chan transport.Batch, + txnsWritten chan<- *ordered_map.OrderedMap, + statsChan chan stats.Stat, + log logrus.Entry, + id int, + bucketName string, + keySpace string, + client s3iface.S3API, + retryPolicy backoff.BackOff) transport.Transporter { + + log = *log.WithField("routine", "transporter").WithField("id", id) + + return &S3Transporter{ + shutdownHandler, + inputChan, + txnsWritten, + statsChan, + log, + client, + bucketName, + keySpace, + retryPolicy, + } +} + +// NewTransporter returns a s3 transporter +func NewTransporter(shutdownHandler shutdown.ShutdownHandler, + inputChan <-chan transport.Batch, + txnsWritten chan<- *ordered_map.OrderedMap, + statsChan chan stats.Stat, + log logrus.Entry, + id int, + bucketName string, + keySpace string, + retryPolicy backoff.BackOff, + awsRegion *string, + awsAccessKeyId *string, + awsSecretAccessKey *string, + endpoint *string,) transport.Transporter { + + awsConfig := &aws.Config{ + Region: aws.String(*awsRegion), + S3ForcePathStyle: aws.Bool(true), + Endpoint: aws.String(*endpoint), + MaxRetries: aws.Int(0), // We disable the client retry policy because of our own retry logic + } + + if *awsAccessKeyId != "" || *awsSecretAccessKey != "" { + // Force static credentials from pg-bifrost configuration. + // Note: if we expect to fail and not infer credentials if only one of the ID or Key was specified + awsConfig.Credentials = credentials.NewStaticCredentials(*awsAccessKeyId, *awsSecretAccessKey, "") + } + + if *endpoint != "" { + // If specifying a custom endpoint (such as for localstack) then configure that and use Path Style + awsConfig.Endpoint = aws.String(*endpoint) + awsConfig.S3ForcePathStyle = aws.Bool(true) + } + + sess := session.Must(session.NewSession(awsConfig)) + client := s3.New(sess) + + return NewTransporterWithInterface( + shutdownHandler, + inputChan, + txnsWritten, + statsChan, + log, + id, + bucketName, + keySpace, + client, + retryPolicy) +} + +// shutdown idempotently closes the output channel +func (t *S3Transporter) shutdown() { + t.log.Info("shutting down transporter") + t.shutdownHandler.CancelFunc() // initiate shutdown on other modules as well + + if r := recover(); r != nil { + t.log.Warnf("Recovered in S3Transporter %s", r) + } + + defer func() { + // recover if channel is already closed + recover() + }() + + t.log.Debug("closing progress channel") + close(t.txnsWritten) +} + + +// transportWithRetry does a PUT on a full batch as a single key/file to S3 +func (t *S3Transporter) transportWithRetry(ctx context.Context, messagesSlice []*marshaller.MarshalledMessage) (error, bool) { + var cancelled bool + var buf bytes.Buffer + gz := gzip.NewWriter(&buf) + + select { + case <-ctx.Done(): + t.log.Debug("received terminateCtx cancellation") + cancelled = true + default: + } + + // add all messages into a gzipped buffer + for _, msg := range messagesSlice { + if _, err := gz.Write(msg.Json); err != nil { + return err, cancelled + } + gz.Write([]byte("\n")) + } + + if err := gz.Flush(); err != nil { + return err, cancelled + } + if err := gz.Close(); err != nil { + return err, cancelled + } + + gz.Reset(ioutil.Discard) + + firstWalStart := messagesSlice[0].WalStart + + // Free up messagesSlice now that we're done with it + messagesSlice = nil + + // Clear out every allocation in the conversion + byteArray := buf.Bytes() + buf.Reset() + + byteReader := bytes.NewReader(byteArray) + byteArray = nil + + // Partition the S3 keys into days + year, month, day, full := TimeSource.DateString() + baseFilename := fmt.Sprintf("%s_%d", full, firstWalStart) + + fullKey := key_join(t.keySpace, year, month, day, baseFilename) + + // An operation that may fail. + operation := func() error { + // Do the upload and let S3 handle retries + _, err := t.client.PutObjectWithContext(ctx, &s3.PutObjectInput{ + Bucket: aws.String(t.bucketName), + Key: aws.String(fullKey), + Body: byteReader, + ContentEncoding: aws.String("gzip"), + }) + + // If any errors occurred during sending the entire batch + if err != nil { + t.log.WithError(err).Errorf("%s failed to be uploaded to S3", fullKey) + t.statsChan <- stats.NewStatCount("s3_transport", "failure", 1, TimeSource.UnixNano()) + + // Rewind the reader for retries + _, seekErr := byteReader.Seek(0, 0) + if seekErr != nil { + return errors.New( + fmt.Sprintf("Seek error on io.Reader rewind when preparing for retry: %s", seekErr.Error())) + } + + return err + } + + // If there are no failures then all messages were sent + t.log.Infof("successful PUT: %s/%s", t.bucketName, fullKey) + t.statsChan <- stats.NewStatCount("s3_transport", "success", 1, TimeSource.UnixNano()) + return nil + } + + // Reset retrier + defer func() { + t.retryPolicy.Reset() + }() + + err := backoff.Retry(operation, t.retryPolicy) + if err != nil { + // Handle error. + return err, cancelled + } + + return nil, cancelled +} + + +// StartTransporting reads in message batches, outputs its data to S3 and then sends a progress report on the batch +func (t *S3Transporter) StartTransporting() { + t.log.Info("starting transporter") + defer t.shutdown() + + var b interface{} + var ok bool + + for { + select { + case <-t.shutdownHandler.TerminateCtx.Done(): + t.log.Debug("received terminateCtx cancellation") + return + + case b, ok = <-t.inputChan: + // pass + } + + select { + case <-t.shutdownHandler.TerminateCtx.Done(): + t.log.Debug("received terminateCtx cancellation") + return + default: + // pass + } + + if !ok { + t.log.Warn("input channel is closed") + return + } + + genericBatch, ok := b.(*batch.GenericBatch) + + if !ok { + panic("Batch is not a GenericBatch") + } + + messages := genericBatch.GetPayload() + messagesSlice, ok := messages.([]*marshaller.MarshalledMessage) + + if !ok { + panic("Batch payload is not a []*marshaller.MarshalledMessage") + } + + // Begin timer + start := TimeSource.UnixNano() + + // send to S3 + err, cancelled := t.transportWithRetry(t.shutdownHandler.TerminateCtx, messagesSlice) + + // End timer and send stat + total := (TimeSource.UnixNano() - start) / int64(time.Millisecond) + t.statsChan <- stats.NewStatHistogram("s3_transport", "duration", total, TimeSource.UnixNano(), "ms") + + if err != nil { + t.log.Error("max retries exceeded") + return + } + + // if transportWithRetry was cancelled, then loop back around to shutdown + if cancelled { + continue + } + + t.log.Debug("successfully wrote batch") + t.statsChan <- stats.NewStatCount("s3_transport", "written", int64(genericBatch.NumMessages()), TimeSource.UnixNano()) + + // report transactions written in this batch + t.txnsWritten <- genericBatch.GetTransactions() + } +} diff --git a/transport/transporters/s3/transporter/transporter_test.go b/transport/transporters/s3/transporter/transporter_test.go new file mode 100644 index 00000000..5326728a --- /dev/null +++ b/transport/transporters/s3/transporter/transporter_test.go @@ -0,0 +1,427 @@ +/* + Copyright 2019 Nextdoor.com, Inc. + + Licensed 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. + */ + +package transporter + +import ( + "bytes" + "compress/gzip" + "encoding/base64" + "fmt" + "io" + "testing" + "time" + + "github.com/Nextdoor/pg-bifrost.git/marshaller" + "github.com/Nextdoor/pg-bifrost.git/shutdown" + "github.com/Nextdoor/pg-bifrost.git/stats" + "github.com/Nextdoor/pg-bifrost.git/transport" + "github.com/Nextdoor/pg-bifrost.git/transport/batch" + "github.com/Nextdoor/pg-bifrost.git/transport/transporters/s3/transporter/mocks" + "github.com/Nextdoor/pg-bifrost.git/utils" + utils_mocks "github.com/Nextdoor/pg-bifrost.git/utils/mocks" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/s3" + "github.com/cenkalti/backoff" + "github.com/cevaris/ordered_map" + "github.com/golang/mock/gomock" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" + "github.com/stretchr/testify/assert" +) + +var ( + logger = logrus.New() + log = logger.WithField("package", "s3") +) + +func resetTimeSource() { + TimeSource = utils.RealTime{} +} + +// streamSeekToBytes reads from a seeker once and return a string. Note that by nature, this will be a one time +// operations. Subsequent reads off of this io.ReadSeeker will not return any data. +func streamSeekToBytes(stream io.ReadSeeker) string { + buf := new(bytes.Buffer) + buf.ReadFrom(stream) + return buf.String() +} + +// gzipAsReadSeeker converts []*marshaller.MarshalledMessage to an io.ReadSeeker with newlines between each message +func gzipAsReadSeeker(messagesSlice []*marshaller.MarshalledMessage) io.ReadSeeker { + var buf bytes.Buffer + gz := gzip.NewWriter(&buf) + + for _, msg := range messagesSlice { + gz.Write(msg.Json) + gz.Write([]byte("\n")) + } + + gz.Flush() + gz.Close() + + byteArray := buf.Bytes() + return bytes.NewReader(byteArray) +} + +// used to compare all fields of PutObjectInput while reading from the buffer for Body +type putObjectInputMatcher struct { + Bucket *string + Key *string + BodyString string + ContentEncoding *string +} + +// Matches uses putObjectInputMatcher to do a specific comparison +func (s *putObjectInputMatcher) Matches(x interface{}) bool { + actual := x.(*s3.PutObjectInput) + actualBodyString := streamSeekToBytes(actual.Body) + + if len(actualBodyString) < 1 || len(s.BodyString) < 1 { + log.Error("TEST ERROR - expected or actual putObjectInputMatcher.Body are 0") + return false + } + + actualBase64 := base64.StdEncoding.EncodeToString([]byte(actualBodyString)) + expectedBase64 := base64.StdEncoding.EncodeToString([]byte(s.BodyString)) + fmt.Println("Base64 encoding of PutObjectInput.Body Matcher test: ") + fmt.Println(fmt.Sprintf("actual: %s", actualBase64)) + fmt.Println(fmt.Sprintf("expected: %s", expectedBase64)) + + return *actual.Bucket == *s.Bucket && + *actual.Key == *s.Key && + actualBodyString == s.BodyString && + *actual.ContentEncoding == *s.ContentEncoding +} + +func (s *putObjectInputMatcher) String() string { + return fmt.Sprintf("\nBucket: %s\nKey: %s\nBody: %s\nContentEncoding: %s\n", + *s.Bucket, *s.Key, s.BodyString, *s.ContentEncoding) +} + +// EqPutObjectInputWithBufferRead is a gomock.Matcher that we can pass to matcher as arguments +func EqPutObjectInputWithBufferRead(putObject *s3.PutObjectInput) gomock.Matcher { + return &putObjectInputMatcher{ + putObject.Bucket, + putObject.Key, + streamSeekToBytes(putObject.Body), + putObject.ContentEncoding, + } +} + +func TestSinglePutOk(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + defer resetTimeSource() + + in := make(chan transport.Batch, 1000) + txns := make(chan *ordered_map.OrderedMap, 1000) + statsChan := make(chan stats.Stat, 1000) + + bucketName := "test-bucket" + keySpace := "" + mockClient := mocks.NewMockS3API(mockCtrl) + mockTime := utils_mocks.NewMockTimeSource(mockCtrl) + TimeSource = mockTime + sh := shutdown.NewShutdownHandler() + + batchSize := 1 + + retryPolicy := backoff.WithMaxRetries(backoff.NewConstantBackOff(0), 5) + transport := NewTransporterWithInterface(sh, in, txns, statsChan, *log, 0, bucketName, keySpace, mockClient, retryPolicy) + b := batch.NewGenericBatch("", batchSize) + + + marshalledMessage := marshaller.MarshalledMessage{ + Operation: "INSERT", + Json: []byte("data"), + TimeBasedKey: "123", + WalStart: 1234, + Transaction: "123", + } + b.Add(&marshalledMessage) + + // Expects + expectedInput := s3.PutObjectInput{ + Bucket: aws.String(bucketName), + Key: aws.String("2000/01/02/456_1234.gz"), + Body: gzipAsReadSeeker(b.GetPayload().([]*marshaller.MarshalledMessage)), + ContentEncoding: aws.String("gzip"), + } + + mockClient.EXPECT().PutObjectWithContext(sh.TerminateCtx, EqPutObjectInputWithBufferRead(&expectedInput)).Return(nil, nil) + + mockTime.EXPECT().DateString().Return("2000", "01", "02", "456") + + mockTime.EXPECT().UnixNano().Return(int64(0)) + mockTime.EXPECT().UnixNano().Return(int64(1000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(2000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(3000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(4000 * time.Millisecond)) + + in <- b + + // Start test + go transport.StartTransporting() + + // Wait for data to go through + time.Sleep(time.Millisecond * 25) + + // Verify stats + expected := []stats.Stat{ + stats.NewStatCount("s3_transport", "success", int64(1), int64(1000*time.Millisecond)), + stats.NewStatHistogram("s3_transport", "duration", 2000, int64(3000*time.Millisecond), "ms"), + stats.NewStatCount("s3_transport", "written", int64(1), int64(4000*time.Millisecond)), + } + stats.VerifyStats(t, statsChan, expected) +} + + +func TestSinglePutMultipleRecordsOk(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + defer resetTimeSource() + + in := make(chan transport.Batch, 1000) + txns := make(chan *ordered_map.OrderedMap, 1000) + statsChan := make(chan stats.Stat, 1000) + + bucketName := "test-bucket" + keySpace := "" + mockClient := mocks.NewMockS3API(mockCtrl) + mockTime := utils_mocks.NewMockTimeSource(mockCtrl) + TimeSource = mockTime + sh := shutdown.NewShutdownHandler() + + batchSize := 2 + + retryPolicy := backoff.WithMaxRetries(backoff.NewConstantBackOff(0), 5) + transport := NewTransporterWithInterface(sh, in, txns, statsChan, *log, 0, bucketName, keySpace, mockClient, retryPolicy) + b := batch.NewGenericBatch("", batchSize) + + + firstMarshalledMessage := marshaller.MarshalledMessage{ + Operation: "INSERT", + Json: []byte("dataOne"), + TimeBasedKey: "123", + WalStart: 1234, + Transaction: "123", + } + b.Add(&firstMarshalledMessage) + + secondMarshalledMessage := marshaller.MarshalledMessage{ + Operation: "UPDATE", + Json: []byte("dataTwo"), + TimeBasedKey: "124", + WalStart: 1235, + Transaction: "123", + } + b.Add(&secondMarshalledMessage) + + // Expects + expectedInput := s3.PutObjectInput{ + Bucket: aws.String(bucketName), + Key: aws.String("2000/01/02/456_1234.gz"), + Body: gzipAsReadSeeker(b.GetPayload().([]*marshaller.MarshalledMessage)), + ContentEncoding: aws.String("gzip"), + } + + mockClient.EXPECT().PutObjectWithContext(sh.TerminateCtx, EqPutObjectInputWithBufferRead(&expectedInput)).Return(nil, nil) + + mockTime.EXPECT().DateString().Return("2000", "01", "02", "456") + + mockTime.EXPECT().UnixNano().Return(int64(0)) + mockTime.EXPECT().UnixNano().Return(int64(1000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(2000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(3000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(4000 * time.Millisecond)) + + in <- b + + // Start test + go transport.StartTransporting() + + // Wait for data to go through + time.Sleep(time.Millisecond * 25) + + // Verify stats + expected := []stats.Stat{ + stats.NewStatCount("s3_transport", "success", int64(1), int64(1000*time.Millisecond)), + stats.NewStatHistogram("s3_transport", "duration", 2000, int64(3000*time.Millisecond), "ms"), + stats.NewStatCount("s3_transport", "written", int64(2), int64(4000*time.Millisecond)), + } + stats.VerifyStats(t, statsChan, expected) +} + +func TestSingleRecordSinglePutWithFailuresNoError(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + defer resetTimeSource() + + in := make(chan transport.Batch, 1000) + txns := make(chan *ordered_map.OrderedMap, 1000) + statsChan := make(chan stats.Stat, 1000) + + bucketName := "test-bucket" + keySpace := "" + mockClient := mocks.NewMockS3API(mockCtrl) + mockTime := utils_mocks.NewMockTimeSource(mockCtrl) + TimeSource = mockTime + sh := shutdown.NewShutdownHandler() + + batchSize := 1 + + retryPolicy := backoff.WithMaxRetries(backoff.NewConstantBackOff(0), 5) + transport := NewTransporterWithInterface(sh, in, txns, statsChan, *log, 0, bucketName, keySpace, mockClient, retryPolicy) + b := batch.NewGenericBatch("", batchSize) + + + marshalledMessage := marshaller.MarshalledMessage{ + Operation: "INSERT", + Json: []byte("data"), + TimeBasedKey: "123", + WalStart: 1234, + Transaction: "123", + } + b.Add(&marshalledMessage) + + // Expects + expectedInputOne := s3.PutObjectInput{ + Bucket: aws.String(bucketName), + Key: aws.String("2000/01/02/456_1234.gz"), + Body: gzipAsReadSeeker(b.GetPayload().([]*marshaller.MarshalledMessage)), + ContentEncoding: aws.String("gzip"), + } + + // We need two "identical" inputs because Body's io.Reader is mutable (reading again needs a Seek to rewind) + expectedInputTwo := s3.PutObjectInput{ + Bucket: aws.String(bucketName), + Key: aws.String("2000/01/02/456_1234.gz"), + Body: gzipAsReadSeeker(b.GetPayload().([]*marshaller.MarshalledMessage)), + ContentEncoding: aws.String("gzip"), + } + + mockClient.EXPECT().PutObjectWithContext(sh.TerminateCtx, EqPutObjectInputWithBufferRead(&expectedInputOne)).Return(nil, errors.New("some error")) + mockClient.EXPECT().PutObjectWithContext(sh.TerminateCtx, EqPutObjectInputWithBufferRead(&expectedInputTwo)).Return(nil, nil) + + mockTime.EXPECT().DateString().Return("2000", "01", "02", "456") + + mockTime.EXPECT().UnixNano().Return(int64(0)) + mockTime.EXPECT().UnixNano().Return(int64(1000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(2000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(3000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(4000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(5000 * time.Millisecond)) + + in <- b + + // Start test + go transport.StartTransporting() + + // Wait for data to go through + time.Sleep(time.Millisecond * 25) + + // Verify stats + expected := []stats.Stat{ + stats.NewStatCount("s3_transport", "failure", int64(1), int64(1000*time.Millisecond)), + stats.NewStatCount("s3_transport", "success", int64(1), int64(2000*time.Millisecond)), + stats.NewStatHistogram("s3_transport", "duration", 3000, int64(4000*time.Millisecond), "ms"), + stats.NewStatCount("s3_transport", "written", int64(1), int64(5000*time.Millisecond)), + } + stats.VerifyStats(t, statsChan, expected) +} + +func TestSingleRecordDoublePutRetriesExhaustedWithError(t *testing.T) { + mockCtrl := gomock.NewController(t) + defer mockCtrl.Finish() + defer resetTimeSource() + + in := make(chan transport.Batch, 1000) + txns := make(chan *ordered_map.OrderedMap, 1000) + statsChan := make(chan stats.Stat, 1000) + + bucketName := "test-bucket" + keySpace := "" + mockClient := mocks.NewMockS3API(mockCtrl) + mockTime := utils_mocks.NewMockTimeSource(mockCtrl) + TimeSource = mockTime + sh := shutdown.NewShutdownHandler() + + batchSize := 1 + + retryPolicy := backoff.WithMaxRetries(backoff.NewConstantBackOff(0), 1) + transport := NewTransporterWithInterface(sh, in, txns, statsChan, *log, 0, bucketName, keySpace, mockClient, retryPolicy) + b := batch.NewGenericBatch("", batchSize) + + + marshalledMessage := marshaller.MarshalledMessage{ + Operation: "INSERT", + Json: []byte("data"), + TimeBasedKey: "123", + WalStart: 1234, + Transaction: "123", + } + b.Add(&marshalledMessage) + + // Expects + expectedInputOne := s3.PutObjectInput{ + Bucket: aws.String(bucketName), + Key: aws.String("2000/01/02/456_1234.gz"), + Body: gzipAsReadSeeker(b.GetPayload().([]*marshaller.MarshalledMessage)), + ContentEncoding: aws.String("gzip"), + } + + // We need two "identical" inputs because Body's io.Reader is mutable (reading needs a Seek back to start offset) + expectedInputTwo := s3.PutObjectInput{ + Bucket: aws.String(bucketName), + Key: aws.String("2000/01/02/456_1234.gz"), + Body: gzipAsReadSeeker(b.GetPayload().([]*marshaller.MarshalledMessage)), + ContentEncoding: aws.String("gzip"), + } + + mockClient.EXPECT().PutObjectWithContext(sh.TerminateCtx, EqPutObjectInputWithBufferRead(&expectedInputOne)).Return(nil, errors.New("some error")) + mockClient.EXPECT().PutObjectWithContext(sh.TerminateCtx, EqPutObjectInputWithBufferRead(&expectedInputTwo)).Return(nil, errors.New("some error")) + + mockTime.EXPECT().DateString().Return("2000", "01", "02", "456") + + mockTime.EXPECT().UnixNano().Return(int64(0)) + mockTime.EXPECT().UnixNano().Return(int64(1000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(2000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(3000 * time.Millisecond)) + mockTime.EXPECT().UnixNano().Return(int64(4000 * time.Millisecond)) + + in <- b + + // Start test + go transport.StartTransporting() + + // Wait for data to go through + time.Sleep(time.Millisecond * 25) + + // Verify stats + expected := []stats.Stat{ + stats.NewStatCount("s3_transport", "failure", int64(1), int64(1000*time.Millisecond)), + stats.NewStatCount("s3_transport", "failure", int64(1), int64(2000*time.Millisecond)), + stats.NewStatHistogram("s3_transport", "duration", 3000, int64(4000*time.Millisecond), "ms"), + } + stats.VerifyStats(t, statsChan, expected) + + // Verify shutdown + _, ok := <-sh.TerminateCtx.Done() + if ok { + assert.Fail(t, "context not cancelled") + } +} diff --git a/utils/mocks/mock_timesource.go b/utils/mocks/mock_timesource.go index 541d708f..6ca0bfb1 100644 --- a/utils/mocks/mock_timesource.go +++ b/utils/mocks/mock_timesource.go @@ -32,9 +32,23 @@ func (m *MockTimeSource) EXPECT() *MockTimeSourceMockRecorder { return m.recorder } +// DateString mocks base method +func (m *MockTimeSource) DateString() (string, string, string, string) { + ret := m.ctrl.Call(m, "DateString") + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(string) + ret3, _ := ret[3].(string) + return ret0, ret1, ret2, ret3 +} + +// DateString indicates an expected call of DateString +func (mr *MockTimeSourceMockRecorder) DateString() *gomock.Call { + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DateString", reflect.TypeOf((*MockTimeSource)(nil).DateString)) +} + // UnixNano mocks base method func (m *MockTimeSource) UnixNano() int64 { - m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UnixNano") ret0, _ := ret[0].(int64) return ret0 @@ -42,6 +56,5 @@ func (m *MockTimeSource) UnixNano() int64 { // UnixNano indicates an expected call of UnixNano func (mr *MockTimeSourceMockRecorder) UnixNano() *gomock.Call { - mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnixNano", reflect.TypeOf((*MockTimeSource)(nil).UnixNano)) } diff --git a/utils/time.go b/utils/time.go index aa478698..22ca4830 100644 --- a/utils/time.go +++ b/utils/time.go @@ -16,15 +16,42 @@ package utils -import "time" +import ( + "fmt" + "strconv" + "time" +) //go:generate mockgen -destination mocks/mock_timesource.go -package=mocks github.com/Nextdoor/pg-bifrost.git/utils TimeSource type TimeSource interface { UnixNano() int64 + DateString() (string, string, string, string) } type RealTime struct{} +// UnixNano gets the current time in a Unix Nanoseconds format func (rt RealTime) UnixNano() int64 { return time.Now().UnixNano() } + +// intDateToNormalString normalizes single digit integers to a double digit string (by adding a leading zero if needed) +func intDateToNormalString(i int) string { + if i < 10 { + return fmt.Sprintf("0%d", i) + } + + return strconv.Itoa(i) +} + +// DateString return year/month/day as seperate strings and also a normalized string of datetime that is 14 characters. +// It is intended to be used to partition PUTs on transport sinks. +func (rt RealTime) DateString() (year string, month string, day string, full string) { + now := time.Now() + yearInt, timeMonth, dayInt := now.Date() + monthInt := int(timeMonth) + + fullFormat := now.Format("20060102150405") + + return strconv.Itoa(yearInt), intDateToNormalString(monthInt), intDateToNormalString(dayInt), fullFormat +}