Merge branch 'upstream_emulator' into pr_for_google

Author: marete

google/cloud/bigtable/ci/run_integration_tests_emulator_cmake.sh

@@ -41,6 +41,12 @@ fi
 CBT_INSTANCE_ADMIN_EMULATOR_START=(
   "${BINARY_DIR}/google/cloud/bigtable/tests/instance_admin_emulator"
 )
+
+# Configure run_emulators_utils.sh to find the cbt emulator.
+CBT_EMULATOR_CMD=(
+  "${BINARY_DIR}/google/cloud/bigtable/emulator/emulator"
+)
+
 source module /google/cloud/bigtable/tools/run_emulator_utils.sh
 
 cd "${BINARY_DIR}"

google/cloud/bigtable/emulator/CMakeLists.txt

@@ -101,6 +101,8 @@ foreach (fname ${bigtable_emulator_programs})
     target_link_libraries(
         ${target}
         PRIVATE bigtable_emulator_common
+                absl::flags
+                absl::flags_parse
                 google-cloud-cpp::bigtable
                 google-cloud-cpp::bigtable_protos
                 google-cloud-cpp::grpc_utils

google/cloud/bigtable/emulator/column_family.h

@@ -375,6 +375,8 @@ class ColumnFamily {
     return rows_.upper_bound(row_key);
   }
 
+  std::size_t size() { return rows_.size(); }
+
   std::map<std::string, ColumnFamilyRow>::iterator find(
       std::string const& row_key) {
     return rows_.find(row_key);

google/cloud/bigtable/emulator/emulator.cc

@@ -13,11 +13,38 @@
 // limitations under the License.
 
 #include "google/cloud/bigtable/emulator/server.h"
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/flags/usage.h"
+#include <absl/strings/str_cat.h>
+#include <absl/strings/str_split.h>
+#include <cstdint>
+#include <cstdlib>
 #include <iostream>
+#include <string>
+
+ABSL_FLAG(std::string, host, "localhost",
+          "the address to bind to on the local machine");
+ABSL_FLAG(std::uint16_t, port, 8888,
+          "the port to bind to on the local machine");
+
+int main(int argc, char* argv[]) {
+  absl::SetProgramUsageMessage(
+      absl::StrCat("Usage: %s -h <host> -p <port>", argv[0]));
+  absl::ParseCommandLine(argc, argv);
+
+  auto maybe_server =
+      google::cloud::bigtable::emulator::CreateDefaultEmulatorServer(
+          absl::GetFlag(FLAGS_host), absl::GetFlag(FLAGS_port));
+  if (!maybe_server) {
+    std::cerr << "CreateDefaultEmulatorServer() failed. See logs for "
+                 "possible reason"
+              << std::endl;
+    return 1;
+  }
+
+  auto& server = maybe_server.value();
 
-int main() {
-  auto server = google::cloud::bigtable::emulator::CreateDefaultEmulatorServer(
-      "[::]", 8888);
   std::cout << "Server running on port " << server->bound_port() << "\n";
   server->Wait();
   return 0;

google/cloud/bigtable/emulator/filter.h

@@ -214,7 +214,7 @@ class CellStream {
   CellView const* operator->() const { return &Value(); }
   /// equivalent to `HasValue()`
   explicit operator bool() const { return HasValue(); }
-  AbstractCellStreamImpl const& impl() const { return *impl_; }
+  AbstractCellStreamImpl& impl() const { return *impl_; }
 
  private:
   void NextColumn();

google/cloud/bigtable/emulator/filter_test.cc

@@ -1918,42 +1918,23 @@ TEST(FiltersEndToEnd, ColumnRange) {
   filter.mutable_column_range_filter()->set_start_qualifier_closed("b00");
   filter.mutable_column_range_filter()->set_end_qualifier_open("b02");
 
-  struct Cell {
-    std::string row_key;
-    std::string column_family;
-    std::string column_qualifier;
-    std::int64_t timestamp_micros;
-    std::string value;
-
-    bool operator==(Cell const& other) const {
-      return this->row_key == other.row_key &&
-             this->column_family == other.column_family &&
-             this->column_qualifier == other.column_qualifier &&
-             this->timestamp_micros == other.timestamp_micros &&
-             this->value == other.value;
-    }
-  };
-
   auto maybe_stream = table->CreateCellStream(all_rows_set, filter);
   ASSERT_STATUS_OK(maybe_stream);
 
-  std::vector<Cell> expected = {
-      {row_key, "family1", "b00", 0, "bar"},
-      {row_key, "family1", "b01", 0, "bar"},
+  std::vector<TestCell> expected = {
+      {row_key, "family1", "b00", 0_ms, "bar"},
+      {row_key, "family1", "b01", 0_ms, "bar"},
   };
 
-  std::vector<Cell> actual;
+  std::vector<TestCell> actual;
   auto& stream = *maybe_stream;
   for (; stream; ++stream) {
-    actual.push_back({stream->row_key(), stream->column_family(),
-                      stream->column_qualifier(),
-                      stream->timestamp().count() * 1000, stream->value()});
+    actual.emplace_back(stream->row_key(), stream->column_family(),
+                        stream->column_qualifier(), stream->timestamp(),
+                        stream->value());
   }
 
-  ASSERT_EQ(expected.size(), actual.size());
-
-  ASSERT_TRUE(
-      std::is_permutation(expected.begin(), expected.end(), actual.begin()));
+  ASSERT_EQ(expected, actual);
 }
 
 }  // namespace emulator

google/cloud/bigtable/emulator/server.cc

@@ -332,13 +332,15 @@ class DefaultEmulatorServer : public EmulatorServer {
         table_service_(cluster_) {
     builder_.AddListeningPort(host + ":" + std::to_string(port),
                               grpc::InsecureServerCredentials(), &bound_port_);
+    builder_.SetMaxReceiveMessageSize(256 * 1024 * 1024);
     builder_.RegisterService(&bt_service_);
     builder_.RegisterService(&table_service_);
     server_ = builder_.BuildAndStart();
   }
   int bound_port() override { return bound_port_; }
   void Shutdown() override { server_->Shutdown(); }
   void Wait() override { server_->Wait(); }
+  bool HasValidServer() { return static_cast<bool>(server_); }
 
  private:
   int bound_port_;
@@ -349,9 +351,17 @@ class DefaultEmulatorServer : public EmulatorServer {
   std::unique_ptr<grpc::Server> server_;
 };
 
-std::unique_ptr<EmulatorServer> CreateDefaultEmulatorServer(
+StatusOr<std::unique_ptr<EmulatorServer>> CreateDefaultEmulatorServer(
     std::string const& host, std::uint16_t port) {
-  return std::unique_ptr<EmulatorServer>(new DefaultEmulatorServer(host, port));
+  auto* default_emulator_server = new DefaultEmulatorServer(host, port);
+  if (!default_emulator_server->HasValidServer()) {
+    return UnknownError("An unknown error occurred when starting server",
+                        GCP_ERROR_INFO()
+                            .WithMetadata("host", host)
+                            .WithMetadata("port", absl::StrCat("%d", port)));
+  }
+
+  return std::unique_ptr<EmulatorServer>(default_emulator_server);
 }
 
 }  // namespace emulator

google/cloud/bigtable/emulator/server.h

@@ -15,6 +15,7 @@
 #ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_EMULATOR_SERVER_H
 #define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_BIGTABLE_EMULATOR_SERVER_H
 
+#include "google/cloud/status_or.h"
 #include <cstdint>
 #include <memory>
 #include <string>
@@ -36,7 +37,7 @@ class EmulatorServer {
   virtual void Wait() = 0;
 };
 
-std::unique_ptr<EmulatorServer> CreateDefaultEmulatorServer(
+StatusOr<std::unique_ptr<EmulatorServer>> CreateDefaultEmulatorServer(
     std::string const& host, std::uint16_t port);
 
 }  // namespace emulator

google/cloud/bigtable/emulator/server_test.cc

@@ -13,13 +13,15 @@
 // limitations under the License.
 
 #include "google/cloud/bigtable/emulator/server.h"
+#include "google/cloud/testing_util/status_matchers.h"
 #include <google/bigtable/admin/v2/bigtable_table_admin.grpc.pb.h>
 #include <google/bigtable/admin/v2/bigtable_table_admin.pb.h>
 #include <google/bigtable/admin/v2/table.pb.h>
 #include <google/bigtable/v2/bigtable.grpc.pb.h>
 #include <google/bigtable/v2/bigtable.pb.h>
 #include <gmock/gmock.h>
 #include <grpcpp/grpcpp.h>
+#include <gtest/gtest.h>
 
 namespace google {
 namespace cloud {
@@ -33,7 +35,9 @@ class ServerTest : public ::testing::Test {
   grpc::ClientContext ctx_;
 
   void SetUp() override {
-    server_ = CreateDefaultEmulatorServer("127.0.0.1", 0);
+    auto maybe_server = CreateDefaultEmulatorServer("127.0.0.1", 0);
+    ASSERT_STATUS_OK(maybe_server);
+    server_ = std::move(maybe_server.value());
     channel_ = grpc::CreateChannel(
         "localhost:" + std::to_string(server_->bound_port()),
         grpc::InsecureChannelCredentials());
@@ -215,6 +219,12 @@ TEST_F(ServerTest, TableAdminUpdateTable) {
   EXPECT_NE(status.error_code(), grpc::StatusCode::UNIMPLEMENTED);
 }
 
+// Test that the failure path for server creation does not crash.
+TEST(ServerCreationTest, TestServerCreationFailurePath) {
+  auto maybe_server = CreateDefaultEmulatorServer("invalid_host_address", 0);
+  ASSERT_EQ(false, maybe_server.ok());
+}
+
 }  // namespace emulator
 }  // namespace bigtable
 }  // namespace cloud