PDBClient.h

Go to the documentation of this file.

/*****************************************************************************
 *                                                                           *
 *  Copyright 2018 Rice University                                           *
 *                                                                           *
 *  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.                                           *
 *                                                                           *
 *****************************************************************************/
#ifndef PDBCLIENT_H
#define PDBCLIENT_H

#include "CatalogClient.h"
#include "DispatcherClient.h"
#include "DistributedStorageManagerClient.h"
#include "QueryClient.h"
#include "ServerFunctionality.h"

#include "Handle.h"
#include "PDBObject.h"
#include "PDBVector.h"
#include "PartitionPolicy.h"
#include "PartitionComp.h"
#include "Partitioner.h"
#include "SimpleRequest.h"

namespace pdb {

    class PDBClient : public ServerFunctionality {

    public:
      /* Creates PDBClient
       *
       *            portIn: the port number of the PDB manager server
       *         addressIn: the IP address of the PDB manager server
       *        myLoggerIn: the logger
       *
       */

      PDBClient(int portIn, std::string addressIn);

      PDBClient();

      ~PDBClient();

      void registerHandlers(PDBServer &forMe); // no - op

      /* Returns the error message generated by a function call.*/
      string getErrorMessage();

      /****
       * Methods for invoking DistributedStorageManager-related operations
       */

      /* Creates a database */
      bool createDatabase(const std::string &databaseName);

      /* Creates a set with a given type for an existing database, no page_size
       * needed in arg. */
      bool createSet(const std::string &databaseName, const std::string &setName,
                     const std::string &typeName);

      /* Creates a set with a given type (using a template) for an existing
       * database, no page_size needed in arg. */
      template <class DataType>
      bool createSet(const std::string &databaseName, const std::string &setName);

      /* Creates a set with a given type for an existing database */
      bool createSet(const std::string &databaseName, const std::string &setName,
                     const std::string &typeName,
                     size_t pageSize = DEFAULT_PAGE_SIZE);

      /* Creates a set with a given type (using a template) for an existing
       * database with page_size value. */
      template <class DataType>
      bool createSet(const std::string &databaseName,
                                const std::string &setName, size_t pageSize);

      /* Creates a temporary set with a given type for an existing database (only
       * goes through storage) */
      bool createTempSet(const std::string &databaseName,
                         const std::string &setName, const std::string &typeName,
                         size_t pageSize = DEFAULT_PAGE_SIZE);



      /* Partitions data in a created set using a partitioner */
      /* @param inputSet: identifier to input set             
         @param outputSet: identifier to output set
         @param PartitionComp: partition comp used to partition the input set, and resulting in the output set
         @return: success or not                            
      */
      template <class KeyClass, class ValueClass>
      bool partitionSet(std::pair<std::string, std::string> inputSet, 
                        std::pair<std::string, std::string> outputSet, 
                        Handle<PartitionComp<KeyClass, ValueClass>> partitionComp);


      /* Partitions and transform data stored in a created set using a partitioner */
      /* @param inputSet: identifier to input set             
         @param outputSet: identifier to output set
         @param PartitionComp: partition comp used to partition the input set, and resulting in the output set
         @return: success or not                            
      */
      template <class KeyClass, class ValueClass>
      bool partitionAndTransformSet(std::pair<std::string, std::string> inputSet, 
                        std::pair<std::string, std::string> outputSet, 
                        Handle<PartitionTransformationComp<KeyClass, ValueClass>> partitionComp);


      /* Flushes data currently in memory into disk. */
      bool flushData();

      /* Removes a database from storage. */
      bool removeDatabase(const std::string &databaseName);

      /* Removes a set for an existing database from storage. */
      bool removeSet(const std::string &databaseName, const std::string &setName);

      /* Removes a set given a type from an existing database. */
      bool clearSet(const std::string &databaseName, const std::string &setName,
                    const std::string &typeName);

      /* Removes a temporary set given a type from an existing database (only goes
       * through storage). */
      bool removeTempSet(const std::string &databaseName,
                         const std::string &setName, const std::string &typeName);

      /* Exports the content of a set from a database into a file. Note that the
       * objects in
       * set must be instances of ExportableObject
       */
      bool exportSet(const std::string &databaseName, const std::string &setName,
                     const std::string &outputFilePath, const std::string &format);

      /****
       * Methods for invoking Catalog-related operations
       */

      /* Sends a request to the Catalog Server to register a user-defined type
       * defined
       * in a shared library. */
      bool registerType(std::string fileContainingSharedLib);

      /* Sends a request to the Catalog Server to register metadata about a node in
       * the cluster */
      bool registerNode(string &localIP, int localPort, string &nodeName,
                        string &nodeType, int nodeStatus);

      /* Prints the content of the catalog. */
      void
      printCatalogMetadata(pdb::Handle<pdb::CatalogPrintMetadata> itemToSearch);

      /* Lists all metadata registered in the catalog. */
      void listAllRegisteredMetadata();

      /* Lists the Databases registered in the catalog. */
      void listRegisteredDatabases();

      /* Lists the Sets for a given database registered in the catalog. */
      void listRegisteredSetsForADatabase(std::string databaseName);

      /* Lists the Nodes registered in the catalog. */
      void listNodesInCluster();

      /* Lists user-defined types registered in the catalog. */
      void listUserDefinedTypes();

      /****
       * Methods for invoking Dispatcher-related operations
       *
       * @param setAndDatabase
       * @return
       */
      bool registerSet(std::pair<std::string, std::string> setAndDatabase,
                       PartitionPolicy::Policy policy);

      template <class DataType>
      bool sendData(std::pair<std::string, std::string> setAndDatabase,
                    Handle<Vector<Handle<DataType>>> dataToSend);

      template <class DataType>
      bool sendBytes(std::pair<std::string, std::string> setAndDatabase,
                     char *bytes, size_t numBytes);

      /****
       * Methods for invoking Query-related operations
       */

      /* Executes some computations */
      template <class... Types>
      bool executeComputations(Handle<Computation> firstParam,
                               Handle<Types>... args);

      /* Deletes a set. */
      bool deleteSet(std::string databaseName, std::string setName);

      /* Gets a set iterator. */
      template <class Type>
      SetIterator<Type> getSetIterator(std::string databaseName,
                                       std::string setName);

    private:
      std::shared_ptr<pdb::CatalogClient> catalogClient;
      std::shared_ptr<pdb::DispatcherClient> dispatcherClient;
      std::shared_ptr<pdb::DistributedStorageManagerClient> distributedStorageClient;
      std::shared_ptr<pdb::QueryClient> queryClient;

      std::function<bool(Handle<SimpleRequestResult>)>
      generateResponseHandler(std::string description, std::string &errMsg);

      // Port of the PlinyCompute manager node
      int port;

      // IP address of the PlinyCompute manager node
      std::string address;

      // Error Message (if an error occurred)
      std::string errorMsg;

      // Message returned by a PlinyCompute function
      std::string returnedMsg;

      // Client logger
      PDBLoggerPtr logger;
    };
}

#include "PDBClientTemplate.cc"
#include "DispatcherClientTemplate.cc"
#include "StorageClientTemplate.cc"

#endif