@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/deps/librdkafka/tests/8001-fetch_from_follower_mock_manual.c

@@ -0,0 +1,113 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2023, Confluent Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "test.h"
+
+#include "../src/rdkafka_proto.h"
+
+/**
+ * @brief Test that the #4195 segfault doesn't happen when preferred replica
+ *        lease expires and the rktp is in fetch state
+ *        RD_KAFKA_TOPPAR_FETCH_OFFSET_WAIT.
+ */
+static void do_test_fetch_from_follower_offset_retry(void) {
+        const char *bootstraps;
+        rd_kafka_mock_cluster_t *mcluster;
+        rd_kafka_conf_t *conf;
+        rd_kafka_t *c;
+        const char *topic = "test";
+        rd_kafka_topic_partition_t *rktpar;
+        rd_kafka_topic_partition_list_t *seek;
+        int i;
+
+        SUB_TEST_QUICK();
+        test_timeout_set(600);
+
+        mcluster = test_mock_cluster_new(3, &bootstraps);
+        /* Set partition leader to broker 1. */
+        rd_kafka_mock_partition_set_leader(mcluster, topic, 0, 1);
+        rd_kafka_mock_partition_set_follower(mcluster, topic, 0, 2);
+
+        test_conf_init(&conf, NULL, 0);
+        test_conf_set(conf, "bootstrap.servers", bootstraps);
+        test_conf_set(conf, "client.rack", "myrack");
+        test_conf_set(conf, "auto.offset.reset", "earliest");
+        test_conf_set(conf, "fetch.error.backoff.ms", "1000");
+        test_conf_set(conf, "fetch.message.max.bytes", "10");
+        test_conf_set(conf, "session.timeout.ms", "600000");
+        test_conf_set(conf, "topic.metadata.refresh.interval.ms", "600000");
+
+        c = test_create_consumer("mygroup", NULL, conf, NULL);
+
+        test_consumer_assign_partition(
+            "do_test_fetch_from_follower_offset_retry", c, topic, 0,
+            RD_KAFKA_OFFSET_INVALID);
+
+        /* Since there are no messages, this poll only waits for metadata, and
+         * then sets the preferred replica after the first fetch request.
+         * Subsequent polls are for waiting up to 5 minutes. */
+        for (i = 0; i < 7; i++) {
+                test_consumer_poll_no_msgs(
+                    "initial metadata and preferred replica set", c, 0, 40000);
+        }
+
+
+        /* Seek to end to trigger ListOffsets */
+        seek           = rd_kafka_topic_partition_list_new(1);
+        rktpar         = rd_kafka_topic_partition_list_add(seek, topic, 0);
+        rktpar->offset = RD_KAFKA_OFFSET_END;
+
+        /* Increase RTT for this ListOffsets */
+        rd_kafka_mock_broker_push_request_error_rtts(
+            mcluster, 2, RD_KAFKAP_ListOffsets, 1, RD_KAFKA_RESP_ERR_NO_ERROR,
+            40 * 1000);
+
+        rd_kafka_seek_partitions(c, seek, -1);
+        rd_kafka_topic_partition_list_destroy(seek);
+
+        /* Wait lease expiry */
+        rd_sleep(50);
+
+        test_consumer_close(c);
+
+        rd_kafka_destroy(c);
+
+        test_mock_cluster_destroy(mcluster);
+
+        SUB_TEST_PASS();
+}
+
+
+int main_8001_fetch_from_follower_mock_manual(int argc, char **argv) {
+
+        TEST_SKIP_MOCK_CLUSTER(0);
+
+        do_test_fetch_from_follower_offset_retry();
+
+        return 0;
+}

package/deps/librdkafka/tests/CMakeLists.txt

@@ -0,0 +1,193 @@
+set(
+    sources
+    0000-unittests.c
+    0001-multiobj.c
+    0002-unkpart.c
+    0003-msgmaxsize.c
+    0004-conf.c
+    0005-order.c
+    0006-symbols.c
+    0007-autotopic.c
+    0008-reqacks.c
+    0009-mock_cluster.c
+    0011-produce_batch.c
+    0012-produce_consume.c
+    0013-null-msgs.c
+    0014-reconsume-191.c
+    0015-offset_seeks.c
+    0016-client_swname.c
+    0017-compression.c
+    0018-cgrp_term.c
+    0019-list_groups.c
+    0020-destroy_hang.c
+    0021-rkt_destroy.c
+    0022-consume_batch.c
+    0025-timers.c
+    0026-consume_pause.c
+    0028-long_topicnames.c
+    0029-assign_offset.c
+    0030-offset_commit.c
+    0031-get_offsets.c
+    0033-regex_subscribe.c
+    0034-offset_reset.c
+    0035-api_version.c
+    0036-partial_fetch.c
+    0037-destroy_hang_local.c
+    0038-performance.c
+    0039-event.c
+    0040-io_event.c
+    0041-fetch_max_bytes.c
+    0042-many_topics.c
+    0043-no_connection.c
+    0044-partition_cnt.c
+    0045-subscribe_update.c
+    0046-rkt_cache.c
+    0047-partial_buf_tmout.c
+    0048-partitioner.c
+    0049-consume_conn_close.c
+    0050-subscribe_adds.c
+    0051-assign_adds.c
+    0052-msg_timestamps.c
+    0053-stats_cb.cpp
+    0054-offset_time.cpp
+    0055-producer_latency.c
+    0056-balanced_group_mt.c
+    0057-invalid_topic.cpp
+    0058-log.cpp
+    0059-bsearch.cpp
+    0060-op_prio.cpp
+    0061-consumer_lag.cpp
+    0062-stats_event.c
+    0063-clusterid.cpp
+    0064-interceptors.c
+    0065-yield.cpp
+    0066-plugins.cpp
+    0067-empty_topic.cpp
+    0068-produce_timeout.c
+    0069-consumer_add_parts.c
+    0070-null_empty.cpp
+    0072-headers_ut.c
+    0073-headers.c
+    0074-producev.c
+    0075-retry.c
+    0076-produce_retry.c
+    0077-compaction.c
+    0078-c_from_cpp.cpp
+    0079-fork.c
+    0080-admin_ut.c
+    0081-admin.c
+    0082-fetch_max_bytes.cpp
+    0083-cb_event.c
+    0084-destroy_flags.c
+    0085-headers.cpp
+    0086-purge.c
+    0088-produce_metadata_timeout.c
+    0089-max_poll_interval.c
+    0090-idempotence.c
+    0091-max_poll_interval_timeout.c
+    0092-mixed_msgver.c
+    0093-holb.c
+    0094-idempotence_msg_timeout.c
+    0095-all_brokers_down.cpp
+    0097-ssl_verify.cpp
+    0098-consumer-txn.cpp
+    0099-commit_metadata.c
+    0100-thread_interceptors.cpp
+    0101-fetch-from-follower.cpp
+    0102-static_group_rebalance.c
+    0103-transactions.c
+    0104-fetch_from_follower_mock.c
+    0105-transactions_mock.c
+    0106-cgrp_sess_timeout.c
+    0107-topic_recreate.c
+    0109-auto_create_topics.cpp
+    0110-batch_size.cpp
+    0111-delay_create_topics.cpp
+    0112-assign_unknown_part.c
+    0113-cooperative_rebalance.cpp
+    0114-sticky_partitioning.cpp
+    0115-producer_auth.cpp
+    0116-kafkaconsumer_close.cpp
+    0117-mock_errors.c
+    0118-commit_rebalance.c
+    0119-consumer_auth.cpp
+    0120-asymmetric_subscription.c
+    0121-clusterid.c
+    0122-buffer_cleaning_after_rebalance.c
+    0123-connections_max_idle.c
+    0124-openssl_invalid_engine.c
+    0125-immediate_flush.c
+    0126-oauthbearer_oidc.c
+    0127-fetch_queue_backoff.cpp
+    0128-sasl_callback_queue.cpp
+    0129-fetch_aborted_msgs.c
+    0130-store_offsets.c
+    0131-connect_timeout.c
+    0132-strategy_ordering.c
+    0133-ssl_keys.c
+    0134-ssl_provider.c
+    0135-sasl_credentials.cpp
+    0136-resolve_cb.c
+    0137-barrier_batch_consume.c
+    0138-admin_mock.c
+    0139-offset_validation_mock.c
+    0140-commit_metadata.cpp
+    0142-reauthentication.c
+    0143-exponential_backoff_mock.c
+    0144-idempotence_mock.c
+    0145-pause_resume_mock.c
+    0146-metadata_mock.c
+    0147-consumer_group_consumer_mock.c
+    0148-offset_fetch_commit_error_mock.c
+    0149-broker-same-host-port.c
+    0150-telemetry_mock.c
+    0151-purge-brokers.c
+    0152-rebootstrap.c
+    0153-memberid.c
+    0155-share_group_heartbeat_mock.c
+    0156-share_consumer_fetch_mock.c
+    0157-share_consumer_ack_mock.c
+    0158-share_consumer_transactions_mock.c
+    0170-share_consumer_subscription.c
+    0171-share_consumer_consume.c
+    0172-share_consumer_acknowledge.c
+    0173-share_consumer_commit_async.c
+    0174-share_consumer_concurrency.c
+    0175-share_consumer_groups.c
+    0176-share_consumer_commit_sync.c
+    0177-share_consumer_transactions.c
+    0178-share_consumer_close.c
+    0179-share_consumer_destroy.c
+    0180-share_consumer_config.c
+    0181-share_consumer_topic_delete.c
+    0182-share_consumer_error_handling_mock.c
+    0183-share_consumer_leader_change_mock.c
+    0184-share_consumer_topic_recreate.c
+    0185-share_consumer_max_poll_interval.c
+    0186-share_consumer_fatal_error.c
+    0190-share_consumer_telemetry.c
+    8000-idle.cpp
+    8001-fetch_from_follower_mock_manual.c
+    test.c
+    testcpp.cpp
+    rusage.c
+)
+
+if(NOT WIN32)
+    list(APPEND sources sockem.c sockem_ctrl.c)
+else()
+    list(APPEND sources ../src/tinycthread.c ../src/tinycthread_extra.c)
+endif()
+
+add_executable(test-runner ${sources})
+target_link_libraries(test-runner PUBLIC rdkafka++)
+
+add_test(NAME RdKafkaTestInParallel COMMAND test-runner -p5)
+add_test(NAME RdKafkaTestSequentially COMMAND test-runner -p1)
+add_test(NAME RdKafkaTestBrokerLess COMMAND test-runner -p5 -l)
+add_test(NAME RdKafkaTestBrokerLessQuick COMMAND test-runner -p5 -l -Q)
+
+if(NOT WIN32 AND NOT APPLE)
+  set(tests_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+  add_subdirectory(interceptor_test)
+endif()

package/deps/librdkafka/tests/LibrdkafkaTestApp.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+#
+# librdkafka test trivup app module
+#
+# Requires:
+#  trivup python module
+#  gradle in your PATH
+
+from trivup.trivup import App, UuidAllocator
+from trivup.apps.ZookeeperApp import ZookeeperApp
+from trivup.apps.KafkaBrokerApp import KafkaBrokerApp
+from trivup.apps.KerberosKdcApp import KerberosKdcApp
+from trivup.apps.OauthbearerOIDCApp import OauthbearerOIDCApp
+
+import os
+import json
+
+
+class LibrdkafkaTestApp(App):
+    """ Sets up and executes the librdkafka regression tests.
+        Assumes tests are in the current directory.
+        Must be instantiated after ZookeeperApp and KafkaBrokerApp """
+
+    def __init__(self, cluster, version, conf=None,
+                 tests=None, scenario="default"):
+        super(LibrdkafkaTestApp, self).__init__(cluster, conf=conf)
+
+        self.appid = UuidAllocator(self.cluster).next(self, trunc=8)
+        self.autostart = False
+        self.local_tests = True
+        self.test_mode = conf.get('test_mode', 'bare')
+        self.version = version
+
+        # Generate test config file
+        conf_blob = list()
+        self.security_protocol = 'PLAINTEXT'
+
+        f, self.test_conf_file = self.open_file('test.conf', 'perm')
+        f.write('broker.address.family=v4\n'.encode('ascii'))
+        f.write(('test.sql.command=sqlite3 rdktests\n').encode('ascii'))
+        f.write('test.timeout.multiplier=2\n'.encode('ascii'))
+
+        sparse = conf.get('sparse_connections', None)
+        if sparse is not None:
+            f.write('enable.sparse.connections={}\n'.format(
+                sparse).encode('ascii'))
+
+        if version.startswith('0.9') or version.startswith('0.8'):
+            conf_blob.append('api.version.request=false')
+            conf_blob.append('broker.version.fallback=%s' % version)
+
+        # SASL (only one mechanism supported at a time)
+        mech = self.conf.get('sasl_mechanisms', '').split(',')[0]
+        if mech != '':
+            conf_blob.append('sasl.mechanisms=%s' % mech)
+            if mech == 'PLAIN' or mech.find('SCRAM-') != -1:
+                self.security_protocol = 'SASL_PLAINTEXT'
+                # Use first user as SASL user/pass
+                for up in self.conf.get('sasl_users', '').split(','):
+                    u, p = up.split('=')
+                    conf_blob.append('sasl.username=%s' % u)
+                    conf_blob.append('sasl.password=%s' % p)
+                    break
+
+            elif mech == 'OAUTHBEARER':
+                self.security_protocol = 'SASL_PLAINTEXT'
+                oidc = cluster.find_app(OauthbearerOIDCApp)
+                if oidc is not None:
+                    conf_blob.append('sasl.oauthbearer.method=%s\n' %
+                                     oidc.conf.get('sasl_oauthbearer_method'))
+                    conf_blob.append('sasl.oauthbearer.client.id=%s\n' %
+                                     oidc.conf.get(
+                                         'sasl_oauthbearer_client_id'))
+                    conf_blob.append('sasl.oauthbearer.client.secret=%s\n' %
+                                     oidc.conf.get(
+                                         'sasl_oauthbearer_client_secret'))
+                    conf_blob.append('sasl.oauthbearer.extensions=%s\n' %
+                                     oidc.conf.get(
+                                         'sasl_oauthbearer_extensions'))
+                    conf_blob.append('sasl.oauthbearer.scope=%s\n' %
+                                     oidc.conf.get('sasl_oauthbearer_scope'))
+                    conf_blob.append('sasl.oauthbearer.token.endpoint.url=%s\n'
+                                     % oidc.conf.get('valid_url'))
+                    self.env_add('VALID_OIDC_URL', oidc.conf.get('valid_url'))
+                    self.env_add(
+                        'INVALID_OIDC_URL',
+                        oidc.conf.get('badformat_url'))
+                    self.env_add(
+                        'EXPIRED_TOKEN_OIDC_URL',
+                        oidc.conf.get('expired_url'))
+                    self.env_add(
+                        'EXPIRED_TOKEN_OIDC_URL',
+                        oidc.conf.get('expired_url'))
+                    self.env['OAUTHBEARER_CLIENT_PRIVATE_KEY'] = \
+                        oidc.conf['sasl_oauthbearer_client_private_key_path']
+                    self.env['OAUTHBEARER_CLIENT_PRIVATE_KEY_ENCRYPTED'] = \
+                        oidc.conf[
+                            'sasl_oauthbearer_client_private_key_encrypted_path']  # noqa: E501
+                    self.env['OAUTHBEARER_CLIENT_PRIVATE_KEY_PASSWORD'] = \
+                        oidc.conf[
+                            'sasl_oauthbearer_client_private_key_password']
+                else:
+                    conf_blob.append(
+                        'enable.sasl.oauthbearer.unsecure.jwt=true\n')
+                    if not self.conf.get('sasl_oauthbearer_config'):
+                        conf_blob.append(
+                            'sasl.oauthbearer.config=scope=requiredScope'
+                            ' principal=admin\n')
+                    else:
+                        conf_blob.append(
+                            'sasl.oauthbearer.config=%s\n' %
+                            self.conf.get('sasl_oauthbearer_config'))
+
+            elif mech == 'GSSAPI':
+                self.security_protocol = 'SASL_PLAINTEXT'
+                kdc = cluster.find_app(KerberosKdcApp)
+                if kdc is None:
+                    self.log(
+                        'WARNING: sasl_mechanisms is GSSAPI set but no '
+                        'KerberosKdcApp available: client SASL config will '
+                        'be invalid (which might be intentional)')
+                else:
+                    self.env_add('KRB5_CONFIG', kdc.conf['krb5_conf'])
+                    self.env_add('KRB5_KDC_PROFILE', kdc.conf['kdc_conf'])
+                    principal, keytab = kdc.add_principal(
+                        self.name,
+                        conf.get('advertised_hostname', self.node.name))
+                    conf_blob.append('sasl.kerberos.service.name=%s' %
+                                     self.conf.get('sasl_servicename',
+                                                   'kafka'))
+                    conf_blob.append('sasl.kerberos.keytab=%s' % keytab)
+                    conf_blob.append(
+                        'sasl.kerberos.principal=%s' %
+                        principal.split('@')[0])
+
+            else:
+                self.log(
+                    'WARNING: FIXME: SASL %s client config not written to %s: unhandled mechanism' %  # noqa: E501
+                    (mech, self.test_conf_file))
+
+        # SSL config
+        if getattr(cluster, 'ssl', None) is not None:
+            ssl = cluster.ssl
+            ssl_intermediate_ca = cluster.conf.get(
+                'ssl_intermediate_ca', False)
+
+            key = ssl.create_cert('librdkafka%s' % self.appid,
+                                  through_intermediate=ssl_intermediate_ca)
+
+            conf_blob.append('ssl.ca.location=%s' % ssl.ca['pem'])
+            conf_blob.append('ssl.certificate.location=%s' % key['pub']['pem'])
+            conf_blob.append('ssl.key.location=%s' % key['priv']['pem'])
+            conf_blob.append('ssl.key.password=%s' % key['password'])
+
+            # Some tests need fine-grained access to various cert files,
+            # set up the env vars accordingly.
+            for k, v in ssl.ca.items():
+                self.env_add('SSL_ca_{}'.format(k), v)
+
+            for k, v in ssl.unused_ca.items():
+                self.env['SSL_unused_ca_{}'.format(k)] = v
+
+            self.env['SSL_all_cas_pem'] = ssl.all_cas['pem']
+            self.env['SSL_client_auth'] = cluster.conf.get(
+                'ssl_client_auth', 'required')
+
+            # Set envs for all generated keys so tests can find them.
+            for k, v in key.items():
+                if isinstance(v, dict):
+                    for k2, v2 in v.items():
+                        # E.g. "SSL_priv_der=path/to/librdkafka-priv.der"
+                        self.env_add('SSL_{}_{}'.format(k, k2), v2)
+                else:
+                    self.env_add('SSL_{}'.format(k), v)
+
+            if 'SASL' in self.security_protocol:
+                self.security_protocol = 'SASL_SSL'
+            else:
+                self.security_protocol = 'SSL'
+
+        # Define bootstrap brokers based on selected security protocol
+        self.dbg('Using client security.protocol=%s' % self.security_protocol)
+        all_listeners = (
+            ','.join(
+                cluster.get_all(
+                    'advertised.listeners',
+                    '',
+                    KafkaBrokerApp))).split(',')
+        bootstrap_servers = ','.join(
+            [x for x in all_listeners if x.startswith(self.security_protocol)])
+        if len(bootstrap_servers) == 0:
+            bootstrap_servers = all_listeners[0]
+            self.log(
+                'WARNING: No eligible listeners for security.protocol=%s in %s: falling back to first listener: %s: tests will fail (which might be the intention)' %  # noqa: E501
+                (self.security_protocol, all_listeners, bootstrap_servers))
+
+        self.bootstrap_servers = bootstrap_servers
+
+        conf_blob.append('bootstrap.servers=%s' % bootstrap_servers)
+        conf_blob.append('security.protocol=%s' % self.security_protocol)
+
+        f.write(('\n'.join(conf_blob)).encode('ascii'))
+        f.close()
+
+        self.env_add('TEST_SCENARIO', scenario)
+        self.env_add('RDKAFKA_TEST_CONF', self.test_conf_file)
+        test_kafka_version = version
+        if 'TEST_KAFKA_VERSION' not in os.environ:
+            self.env_add('TEST_KAFKA_VERSION', test_kafka_version, False)
+        self.env_add('TRIVUP_ROOT', cluster.instance_path())
+
+        if self.test_mode != 'bash':
+            self.test_report_file = self.mkpath('test_report', pathtype='perm')
+            self.env_add('TEST_REPORT', self.test_report_file)
+
+            if tests is not None:
+                self.env_add('TESTS', ','.join(tests))
+
+    def finalize_env(self):
+        self.env_add(
+            'KAFKA_PATH',
+            self.cluster.get_all(
+                'destdir',
+                '',
+                KafkaBrokerApp)[0],
+            False)
+
+        zookeeper = self.cluster.get_all(
+            'address',
+            '',
+            ZookeeperApp)
+        if len(zookeeper):
+            self.env_add(
+                'ZK_ADDRESS',
+                zookeeper[0],
+                False)
+        self.env_add('BROKERS', self.cluster.bootstrap_servers(), False)
+
+        # Provide a HTTPS REST endpoint for the HTTP client tests.
+        self.env_add(
+            'RD_UT_HTTP_URL',
+            'https://jsonplaceholder.typicode.com/users',
+            False)
+
+        # Per broker env vars
+        for b in [x for x in self.cluster.apps if isinstance(
+                x, KafkaBrokerApp)]:
+            self.env_add('BROKER_ADDRESS_%d' % b.appid,
+                         ','.join([x for x in
+                                   b.conf['listeners'].split(',')
+                                   if x.startswith(self.security_protocol)]),
+                         False)
+            # Add each broker pid as an env so they can be killed
+            # indivdidually.
+            self.env_add('BROKER_PID_%d' % b.appid, str(b.proc.pid), False)
+            # JMX port, if available
+            jmx_port = b.conf.get('jmx_port', None)
+            if jmx_port is not None:
+                self.env_add(
+                    'BROKER_JMX_PORT_%d' %
+                    b.appid, str(jmx_port), False)
+
+    def start_cmd(self):
+        self.finalize_env()
+
+        extra_args = list()
+        if not self.local_tests:
+            extra_args.append('-L')
+        if self.conf.get('args', None) is not None:
+            extra_args.append(self.conf.get('args'))
+        extra_args.append('-E')
+        return './run-test.sh -p%d -K %s %s' % (
+            int(self.conf.get('parallel', 5)), ' '.join(extra_args),
+            self.test_mode)
+
+    def report(self):
+        if self.test_mode == 'bash':
+            return None
+
+        try:
+            with open(self.test_report_file, 'r') as f:
+                res = json.load(f)
+        except Exception as e:
+            self.log(
+                'Failed to read report %s: %s' %
+                (self.test_report_file, str(e)))
+            return {'root_path': self.root_path(), 'error': str(e)}
+        return res
+
+    def deploy(self):
+        pass