Remove cluster from bindings

.gitignore

@@ -16,7 +16,9 @@ packaging/msi/FDBInstaller.msi
 *.pom
 bindings/java/pom*.xml
 bindings/java/src*/main/overview.html
-bindings/java/src*/main/com/apple/foundationdb/*Options.java
+bindings/java/src*/main/com/apple/foundationdb/NetworkOptions.java
+bindings/java/src*/main/com/apple/foundationdb/DatabaseOptions.java
+bindings/java/src*/main/com/apple/foundationdb/TransactionOptions.java
 bindings/java/src*/main/com/apple/foundationdb/StreamingMode.java
 bindings/java/src*/main/com/apple/foundationdb/MutationType.java
 bindings/java/src*/main/com/apple/foundationdb/ConflictRangeType.java

bindings/c/fdb_c.cpp

@@ -19,6 +19,7 @@
  */
 
 #define FDB_API_VERSION 610
+#define FDB_INCLUDE_LEGACY_TYPES
 
 #include "fdbclient/MultiVersionTransaction.h"
 #include "foundationdb/fdb_c.h"
@@ -31,17 +32,18 @@ int g_api_version = 0;
  *
  * type mapping:
  *   FDBFuture -> ThreadSingleAssignmentVarBase
- *   FDBCluster -> char
  *   FDBDatabase -> IDatabase
  *   FDBTransaction -> ITransaction
  */
 #define TSAVB(f) ((ThreadSingleAssignmentVarBase*)(f))
 #define TSAV(T, f) ((ThreadSingleAssignmentVar<T>*)(f))
 
-#define CLUSTER(c) ((char*)c)
 #define DB(d) ((IDatabase*)d)
 #define TXN(t) ((ITransaction*)t)
 
+// Legacy (pre API version 610)
+#define CLUSTER(c) ((char*)c)
+
 /* 
  * While we could just use the MultiVersionApi instance directly, this #define allows us to swap in any other IClientApi instance (e.g. from ThreadSafeApi)
  */
@@ -132,16 +134,6 @@ fdb_error_t fdb_add_network_thread_completion_hook(void (*hook)(void*), void *ho
 	CATCH_AND_RETURN( API->addNetworkThreadCompletionHook(hook, hook_parameter); );
 }
 
-
-extern "C" DLLEXPORT
-FDBFuture* fdb_cluster_configure_database( FDBCluster* c, int config_type,
-											   int config_mode, uint8_t const* db_name,
-											   int db_name_length )
-{
-	// Obsolete, but needed for linker compatibility with api version 12 and below
-	return (FDBFuture*)ThreadFuture<Void>(client_invalid_operation()).extractPtr();
-}
-
 extern "C" DLLEXPORT
 void fdb_future_cancel( FDBFuture* f ) {
 	CATCH_AND_DIE(
@@ -235,14 +227,14 @@ fdb_error_t fdb_future_get_key( FDBFuture* f, uint8_t const** out_key,
 }
 
 extern "C" DLLEXPORT
-fdb_error_t fdb_future_get_cluster( FDBFuture* f, FDBCluster** out_cluster ) {
+fdb_error_t fdb_future_get_cluster_v609( FDBFuture* f, FDBCluster** out_cluster ) {
 	CATCH_AND_RETURN(
 		*out_cluster = (FDBCluster*)
 		( (TSAV( char*, f )->get() ) ); );
 }
 
 extern "C" DLLEXPORT
-fdb_error_t fdb_future_get_database( FDBFuture* f, FDBDatabase** out_database ) {
+fdb_error_t fdb_future_get_database_v609( FDBFuture* f, FDBDatabase** out_database ) {
 	CATCH_AND_RETURN(
 		*out_database = (FDBDatabase*)
 		( (TSAV( Reference<IDatabase>, f )->get() ).extractPtr() ); );
@@ -294,7 +286,7 @@ fdb_error_t fdb_future_get_string_array(
 }
 
 extern "C" DLLEXPORT
-FDBFuture* fdb_create_cluster( const char* cluster_file_path ) {
+FDBFuture* fdb_create_cluster_v609( const char* cluster_file_path ) {
 	char *path;
 	if(cluster_file_path) {
 		path = new char[strlen(cluster_file_path) + 1];
@@ -308,7 +300,7 @@ FDBFuture* fdb_create_cluster( const char* cluster_file_path ) {
 }
 
 extern "C" DLLEXPORT
-fdb_error_t fdb_cluster_set_option( FDBCluster* c,
+fdb_error_t fdb_cluster_set_option_v609( FDBCluster* c,
 							 FDBClusterOption option,
 							 uint8_t const* value,
 							 int value_length )
@@ -318,19 +310,32 @@ fdb_error_t fdb_cluster_set_option( FDBCluster* c,
 }
 
 extern "C" DLLEXPORT
-void fdb_cluster_destroy( FDBCluster* c ) {
+void fdb_cluster_destroy_v609( FDBCluster* c ) {
 	CATCH_AND_DIE( delete[] CLUSTER(c); );
 }
 
 extern "C" DLLEXPORT
-FDBFuture* fdb_cluster_create_database( FDBCluster* c, uint8_t const* db_name,
+FDBFuture* fdb_cluster_create_database_v609( FDBCluster* c, uint8_t const* db_name,
 											int db_name_length ) 
 {
 	if(strncmp((const char*)db_name, "DB", db_name_length) != 0) {
 		return (FDBFuture*)ThreadFuture<Reference<IDatabase>>(invalid_database_name()).extractPtr();
 	}
 
-	return (FDBFuture*) API->createDatabase(CLUSTER(c)).extractPtr();
+	FDBDatabase *db;
+	fdb_error_t err = fdb_create_database(CLUSTER(c), &db);
+	if(err) {
+		return (FDBFuture*)ThreadFuture<Reference<IDatabase>>(Error(err)).extractPtr();
+	}
+
+	return (FDBFuture*)ThreadFuture<Reference<IDatabase>>(Reference<IDatabase>(DB(db))).extractPtr();
+}
+
+extern "C" DLLEXPORT
+fdb_error_t fdb_create_database( const char* cluster_file_path, FDBDatabase** out_database ) {
+	CATCH_AND_RETURN(
+		*out_database = (FDBDatabase*)API->createDatabase( cluster_file_path ? cluster_file_path : "" ).extractPtr();
+	);
 }
 
 extern "C" DLLEXPORT
@@ -663,6 +668,12 @@ fdb_error_t fdb_select_api_version_impl( int runtime_version, int header_version
 	// Versioned API changes -- descending order by version (new changes at top)
 	// FDB_API_CHANGED( function, ver ) means there is a new implementation as of ver, and a function function_(ver-1) is the old implementation
 	// FDB_API_REMOVED( function, ver ) means the function was removed as of ver, and function_(ver-1) is the old implementation
+	FDB_API_REMOVED( fdb_create_cluster, 610 );
+	FDB_API_REMOVED( fdb_cluster_create_database, 610 );
+	FDB_API_REMOVED( fdb_cluster_set_option, 610 );
+	FDB_API_REMOVED( fdb_cluster_destroy, 610 );
+	FDB_API_REMOVED( fdb_future_get_cluster, 610 );
+	FDB_API_REMOVED( fdb_future_get_database, 610 );
 	FDB_API_CHANGED( fdb_future_get_error, 23 );
 	FDB_API_REMOVED( fdb_future_is_error, 23 );
 	FDB_API_CHANGED( fdb_future_get_keyvalue_array, 14 );

bindings/c/foundationdb/fdb_c.h

@@ -62,7 +62,6 @@ extern "C" {
 
     /* Pointers to these opaque types represent objects in the FDB API */
     typedef struct FDB_future FDBFuture;
-    typedef struct FDB_cluster FDBCluster;
     typedef struct FDB_database FDBDatabase;
     typedef struct FDB_transaction FDBTransaction;
 
@@ -128,12 +127,6 @@ extern "C" {
     fdb_future_get_key( FDBFuture* f, uint8_t const** out_key,
                         int* out_key_length );
 
-    DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
-    fdb_future_get_cluster( FDBFuture* f, FDBCluster** out_cluster );
-
-    DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
-    fdb_future_get_database( FDBFuture* f, FDBDatabase** out_database );
-
     DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
     fdb_future_get_value( FDBFuture* f, fdb_bool_t *out_present,
                           uint8_t const** out_value,
@@ -148,17 +141,8 @@ extern "C" {
     DLLEXPORT WARN_UNUSED_RESULT fdb_error_t fdb_future_get_string_array(FDBFuture* f,
                             const char*** out_strings, int* out_count);
 
-    DLLEXPORT WARN_UNUSED_RESULT FDBFuture* fdb_create_cluster( const char* cluster_file_path );
-
-    DLLEXPORT void fdb_cluster_destroy( FDBCluster* c );
-
     DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
-    fdb_cluster_set_option( FDBCluster* c, FDBClusterOption option,
-                            uint8_t const* value, int value_length );
-
-    DLLEXPORT WARN_UNUSED_RESULT FDBFuture*
-    fdb_cluster_create_database( FDBCluster* c, uint8_t const* db_name,
-                                 int db_name_length );
+    fdb_create_database( const char* cluster_file_path, FDBDatabase** out_database );
 
     DLLEXPORT void fdb_database_destroy( FDBDatabase* d );
 
@@ -269,6 +253,35 @@ extern "C" {
 
     /* LEGACY API VERSIONS */
 
+#if FDB_API_VERSION < 610 || defined FDB_INCLUDE_LEGACY_TYPES
+    typedef struct FDB_cluster FDBCluster;
+
+    typedef enum {
+        // This option is only a placeholder for C compatibility and should not be used
+        FDB_CLUSTER_OPTION_DUMMY_DO_NOT_USE=-1
+    } FDBClusterOption;
+#endif
+
+#if FDB_API_VERSION < 610
+    DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
+    fdb_future_get_cluster( FDBFuture* f, FDBCluster** out_cluster );
+
+    DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
+    fdb_future_get_database( FDBFuture* f, FDBDatabase** out_database );
+
+    DLLEXPORT WARN_UNUSED_RESULT FDBFuture* fdb_create_cluster( const char* cluster_file_path );
+
+    DLLEXPORT void fdb_cluster_destroy( FDBCluster* c );
+
+    DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
+    fdb_cluster_set_option( FDBCluster* c, FDBClusterOption option,
+                            uint8_t const* value, int value_length );
+
+    DLLEXPORT WARN_UNUSED_RESULT FDBFuture*
+    fdb_cluster_create_database( FDBCluster* c, uint8_t const* db_name,
+                                 int db_name_length );
+#endif
+
 #if FDB_API_VERSION < 23
     DLLEXPORT WARN_UNUSED_RESULT fdb_error_t
     fdb_future_get_error( FDBFuture* f,

bindings/c/test/test.h

@@ -236,22 +236,8 @@ FDBDatabase* openDatabase(struct ResultSet *rs, pthread_t *netThread) {
 	checkError(fdb_setup_network(), "setup network", rs);
 	pthread_create(netThread, NULL, &runNetwork, NULL);
 
-	FDBFuture *f = fdb_create_cluster(NULL);
-	checkError(fdb_future_block_until_ready(f), "block for cluster", rs);
-
-	FDBCluster *cluster;
-	checkError(fdb_future_get_cluster(f, &cluster), "get cluster", rs);
-
-	fdb_future_destroy(f);
-
-	f = fdb_cluster_create_database(cluster, (uint8_t*)"DB", 2);
-	checkError(fdb_future_block_until_ready(f), "block for database", rs);
-
 	FDBDatabase *db;
-	checkError(fdb_future_get_database(f, &db), "get database", rs);
-
-	fdb_future_destroy(f);
-	fdb_cluster_destroy(cluster);
+	checkError(fdb_create_database(NULL, &db), "create database", rs);
 
 	return db;
 }

bindings/flow/fdb_flow.actor.cpp

@@ -34,8 +34,7 @@ THREAD_FUNC networkThread(void* fdb) {
 
 ACTOR Future<Void> _test() {
 	API *fdb = FDB::API::selectAPIVersion(610);
-	auto c = fdb->createCluster( std::string() );
-	auto db = c->createDatabase();
+	auto db = fdb->createDatabase();
 	state Reference<Transaction> tr( new Transaction(db) );
 
 	// tr->setVersion(1);
@@ -189,28 +188,21 @@ namespace FDB {
 	}
 
 	Reference<Cluster> API::createCluster( std::string const& connFilename ) {
-		CFuture f( fdb_create_cluster( connFilename.c_str() ) );
-		f.blockUntilReady();
-
-		FDBCluster* c;
-		throw_on_error( fdb_future_get_cluster( f.f, &c ) );
+		return Reference<Cluster>(new Cluster(connFilename));
+	}
 
-		return Reference<Cluster>( new Cluster(c) );
+	Reference<DatabaseContext> API::createDatabase(std::string const& connFilename) {
+		FDBDatabase *db;
+		throw_on_error(fdb_create_database(connFilename.c_str(), &db));
+		return Reference<DatabaseContext>(new DatabaseContext(db));
 	}
 
 	int API::getAPIVersion() const {
 		return version;
 	}
 
 	Reference<DatabaseContext> Cluster::createDatabase() {
-		const char *dbName = "DB";
-		CFuture f( fdb_cluster_create_database( c, (uint8_t*)dbName, (int)strlen(dbName) ) );
-		f.blockUntilReady();
-
-		FDBDatabase* db;
-		throw_on_error( fdb_future_get_database( f.f, &db ) );
-
-		return Reference<DatabaseContext>( new DatabaseContext(db) );
+		return API::getInstance()->createDatabase(connFilename.c_str());
 	}
 
 	void DatabaseContext::setDatabaseOption(FDBDatabaseOption option, Optional<StringRef> value) {

bindings/flow/fdb_flow.h

@@ -44,20 +44,21 @@ namespace FDB {
 	private:
 		FDBDatabase* db;
 		explicit DatabaseContext( FDBDatabase* db ) : db(db) {}
+
+		friend class API;
 	};
 
+	// Deprecated: Use createDatabase instead.
 	class Cluster : public ReferenceCounted<Cluster>, NonCopyable {
 	public:
-		~Cluster() {
-			fdb_cluster_destroy( c );
-		}
+		~Cluster() {}
 
 		Reference<DatabaseContext> createDatabase();
 
 	private:
-		explicit Cluster( FDBCluster* c ) : c(c) {}
-		FDBCluster* c;
+		explicit Cluster( std::string connFilename ) : connFilename(connFilename) {}
 
+		std::string connFilename;
 		friend class API;
 	};
 
@@ -73,8 +74,11 @@ namespace FDB {
 		void runNetwork();
 		void stopNetwork();
 
+		// Deprecated: Use createDatabase instead.
 		Reference<Cluster> createCluster( std::string const& connFilename );
 
+		Reference<DatabaseContext> createDatabase( std::string const& connFilename="" );
+
 		bool evaluatePredicate(FDBErrorPredicate pred, Error const& e);
 		int getAPIVersion() const;
 

bindings/flow/tester/Tester.actor.cpp

@@ -28,7 +28,7 @@
 #include <string.h>
 #endif
 
-// Otherwise we have to type setupNetwork(), Cluster::createCluster(), etc.
+// Otherwise we have to type setupNetwork(), FDB::open(), etc.
 using namespace FDB;
 
 std::map<std::string, FDBMutationType> optionInfo;
@@ -1714,8 +1714,7 @@ ACTOR void startTest(std::string clusterFilename, StringRef prefix, int apiVersi
 		startThread(networkThread, fdb);
 
 		// Connect to the default cluster/database, and create a transaction
-		auto cluster = fdb->createCluster(clusterFilename);
-		Reference<DatabaseContext> db = cluster->createDatabase();
+		auto db = fdb->createDatabase(clusterFilename);
 
 		Reference<FlowTesterData> data = Reference<FlowTesterData>(new FlowTesterData(fdb));
 		wait(runTest(data, db, prefix));
@@ -1744,8 +1743,7 @@ ACTOR void _test_versionstamp() {
 		fdb->setupNetwork();
 		startThread(networkThread, fdb);
 
-		auto c = fdb->createCluster(std::string());
-		auto db = c->createDatabase();
+		auto db = fdb->createDatabase();
 		state Reference<Transaction> tr(new Transaction(db));
 
 		state Future<FDBStandalone<StringRef>> ftrVersion = tr->getVersionstamp();

bindings/go/src/_stacktester/stacktester.go

@@ -893,7 +893,7 @@ func main() {
 		log.Fatal("API version not equal to value selected")
 	}
 
-	db, e = fdb.Open(clusterFile, []byte("DB"))
+	db, e = fdb.OpenDatabase(clusterFile)
 	if e != nil {
 		log.Fatal(e)
 	}