#ifndef RNPCLIENTCOMM_HH
#define RNPCLIENTCOMM_HH
/*
* This file is part of rasdaman community.
*
* Rasdaman community is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Rasdaman community is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with rasdaman community. If not, see .
*
* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
rasdaman GmbH.
*
* For more information please see
* or contact Peter Baumann via .
*/
/*************************************************************
*
*
* COMMENTS:
*
************************************************************/
#include "clientcomm/clientcomm.hh"
#include "rnprotocol/rnpcommunication.hh"
#include "rnprotocol/rnprasserver.hh"
#include "clientcomm/rpcif.h"
using namespace rnp;
/**
* \defgroup Rnprotocols Rnprotocol Classes
*/
/**
* \ingroup Rnprotocols
*/
class RnpClientComm : public ClientComm, RnpBaseClientComm
{
public:
/// constructor getting the host name of the rasmgr host and it's listening port (default 7001).
RnpClientComm( const char* rasmgrHost, int rasmgrPort = RASMGRPORT ) throw( r_Error );
~RnpClientComm() throw ();
bool effectivTypeIsRNP() throw();
//@Man: Database methods
//@{
///
/// open database
int openDB( const char* database );
/// close current database
int closeDB();
/// create a database
int createDB( const char* name ) throw(r_Error);
/// destroy a database
int destroyDB( const char* name ) throw(r_Error);
///
//@}
//@Man: Transaction methods
//@{
///
/// begin transaction
int openTA( unsigned short readOnly = 0 ) throw(r_Error);
/// commit current transaction
int commitTA() throw(r_Error);
/// abort current transaction
int abortTA();
///
//@}
//@Man: MDD methods
//@{
///
/// inserts a MDD object in an existing MDD collection on the server
void insertMDD( const char* collName, r_GMarray* mar ) throw( r_Error );
/// gets MDD object by oid
r_Ref_Any getMDDByOId( const r_OId& oid ) throw( r_Error );
///
//@}
//@Man: Collection methods
//@{
///
/// creates an empty MDD collection on the server
void insertColl( const char* collName, const char* typeName, const r_OId& oid ) throw( r_Error );
/// deletes an MDD collection by name
void deleteCollByName( const char* collName ) throw( r_Error );
/// deletes an object by oid (right now, objects are collection only)
void deleteObjByOId( const r_OId& oid ) throw( r_Error );
/// removes an object from a collection
void removeObjFromColl( const char* name, const r_OId& oid ) throw ( r_Error );
/// gets collection by name
r_Ref_Any getCollByName( const char* name ) throw( r_Error );
/// gets collection by oid
r_Ref_Any getCollByOId ( const r_OId& oid ) throw( r_Error );
/// gets collection references by name
r_Ref_Any getCollOIdsByName( const char* name ) throw( r_Error );
/// gets collection references by oid
r_Ref_Any getCollOIdsByOId ( const r_OId& oid ) throw( r_Error );
///
//@}
//@Man: Query methods
//@{
///
/// query execution
void executeQuery( const r_OQL_Query& query, r_Set< r_Ref_Any >& result ) throw( r_Error );
/*@Doc:
Executes a retrieval query of type \Ref{r_OQL_Query} and returns the result. Every
MDD object of the MDD collection is fetched from the server and inserted
in the resulting \Ref{r_Set}.
*/
/// update execution
void executeQuery( const r_OQL_Query& query ) throw( r_Error );
/*@Doc:
Executes an update query of type \Ref{r_OQL_Query}.
*/
///
//@}
//@Man: System methods
//@{
///
/// get new oid
r_OId getNewOId( unsigned short objType ) throw(r_Error);
/// get oid type
unsigned short getObjectType( const r_OId& oid ) throw(r_Error);
/// get type structure
/// dallocate using delete []
char* getTypeStructure( const char* typeName, r_Type_Type typeType ) throw(r_Error);
///
//@}
/// provides read access to my clientID
unsigned long getClientID() const;
/// set the preferred transfer format
int setTransferFormat( r_Data_Format format, const char* formatParams=NULL );
/// set the preferred storage format
int setStorageFormat( r_Data_Format format, const char *formatParams=NULL );
/// get real server name (the dinamic one, assigned by the RasMGR)
const char* getServerName();
/// user identification for RasMGR
void setUserIdentification(const char *userName, const char *plainTextPassword);
/// set maximum retry to get a server
void setMaxRetry(unsigned int newMaxRetry);
/// get maximum retry to get a server
unsigned int getMaxRetry();
void setTurbo(bool turbo);
///
//@}
// obsolete, but kept because of virtual functions in base class
void triggerAliveSignal();
void sendAliveSignal();
const char *getExtendedErrorInfo() throw(r_Error);
void setTimeoutInterval(int seconds);
int getTimeoutInterval();
//#### secret, unofficial functions ###########
r_OId createCollection(const char *collName, const char *collTypeName) throw(r_Error);
r_OId createMDD(const char* collName, const char* mddTypeName, const char* definitionDomain, const char *tileDomain, bool rcindex = false) throw(r_Error);
void extendMDD(r_OId mddOId, const char *stripeDomain, const char* tileDomain) throw(r_Error);
vector getOIdsFromCollection( const char* name ) throw( r_Error );
vector getOIdsFromCollection( const r_OId& oid ) throw( r_Error );
vector getTileDomains(r_OId mddOId, const char *stripeDomain) throw( r_Error );
void preloadTiles(r_OId mddOId, const char *tileDomain) throw(r_Error);
int getTileData(r_OId mddOId, const char *tileDomain, char *&data, bool preallocated = false) throw(r_Error);
void replaceTileData(r_OId mddOId, const char *tileDomain, const char *newData, int dataLength, const char *alfaData, int alfaLength) throw(r_Error);
//#############################################
private:
/// client ID assigned to me by the server
int clientID;
/// the name of the rasmgr host
char *rasmgrHost;
/// the listening port of the rasmgr
int rasmgrPort;
/// the name of the server host
char serverHost[100]; //can't be just a pointer, it's never stored elsewhere
int serverPort;
// the name of the opened database, needed because it will be opened again and again, in a hidden operation
char databaseName[100];
// the capability
char capability[100];
/// user identification string
char identificationString[100];
/// requests a free server from the rasmgr, retrying maxRetry times
int getFreeServer(bool readwrite, bool openDB);
/// requests a free server from the rasmgr
int executeGetFreeServer(bool readwrite, bool openDB);
int readWholeMessage(int socket,char *destBuffer,int buffSize);
int writeWholeMessage(int socket,char *destBuffer,int buffSize);
// MD5 of password
int messageDigest(const char *input,char *output,const char *mdName);
/// internal function for client/server protocol handling of non-MDD collection transfer
void getElementCollection( r_Set< r_Ref_Any >& result ) throw(r_Error);
/// internal function for client/server protocol handling of MDD collection transfer
void getMDDCollection( r_Set< r_Ref_Any >& result, unsigned int isQuery ) throw(r_Error);
/// internal function for reading an MDD from the database
unsigned short getMDDCore( r_Ref &mdd, GetMDDRes *thisResult, unsigned int isQuery ) throw( r_Error );
/// concatenate data to an array, making sure there are no overflows (used by getMDDCore())
int concatArrayData( const char *source, unsigned long srcSize, char *&dest,
unsigned long &destSize, unsigned long &destLevel );
/// do transfer decompression
r_Data_Format doTransferDecompression( r_GMarray *tile, const r_Base_Type *type,
r_Data_Format fmt, unsigned long size );
/// internal function for converting a \Ref{r_GMarray} into its RPC representation
void getMarRpcRepresentation( const r_GMarray* mar, RPCMarray*& rpcMarray,
r_Data_Format initStorageFormat = r_Array,
const r_Base_Type *bt = NULL);
/// internal function for freeing data allocated by getMarRpcRepresentation()
void freeMarRpcRepresentation( const r_GMarray* mar, RPCMarray* rpcMarray );
/// endianness of client and server (0 means big endian)
int endianServer;
int endianClient;
/// data format for transfer compression
r_Data_Format transferFormat;
/// storage format for inserting new tiles
r_Data_Format storageFormat;
/// transfer format parameters
char* transferFormatParams;
/// storage format parameters
char *storageFormatParams;
/// parameter object for configuration
r_Parse_Params *clientParams;
/// policy is compress-on-server
int serverCompresses;
/// policy is exact
int exactFormat;
// functions which really do the connection stuff
void executeConnect();
void executeDisconnect();
void executeOpenDB(const char*);
void executeCloseDB();
void executeBeginTA(bool rw);
void executeCommitTA();
void executeAbortTA();
int executeExecuteQuery( const char* query, r_Set< r_Ref_Any >& result ) throw( r_Error );
GetElementRes* executeGetNextElement();
int executeEndTransfer();
GetMDDRes* executeGetNextMDD();
GetTileRes* executeGetNextTile();
void executeExecuteUpdateQuery(const char *query) throw(r_Error);
int executeStartInsertTransMDD(r_GMarray* mdd);
int executeInsertTile(bool persistent, RPCMarray* tile);
void executeEndInsertMDD(bool persistent);
int executeInitUpdate();
int executeStartInsertPersMDD( const char* collName, r_GMarray* mar );
int executeInsertMDD(const char* collName, r_GMarray* mar, RPCMarray *rpcMarray);
int executeInsertCollection( const char* collName, const char* typeName, const r_OId& oid );
r_Ref_Any executeGetCollByNameOrOId ( const char* collName, const r_OId& oid ) throw( r_Error );
r_Ref_Any executeGetCollOIdsByNameOrOId ( const char* collName, const r_OId& oid ) throw( r_Error );
int executeSetFormat( bool transferFormat, r_Data_Format format, const char* formatParams);
r_OId executeGetNewOId( unsigned short objType ) throw(r_Error);
unsigned short executeGetObjectType( const r_OId& oid ) throw(r_Error);
char* executeGetTypeStructure( const char* typeName, r_Type_Type typeType ) throw(r_Error);
vector executeGetOIdsFromCollection ( const char* collName, const r_OId& oid ) throw( r_Error );
void turboOpenDB(const char*);
void turboBeginTA(bool rw);
void turboCommitTA();
void turboAbortTA();
bool useTurbo;
// returns only if transaction is open and rw, otherwise throws
void checkForRwTransaction() throw (r_Error);
// varianta locala
void sendRequestGetAnswer() throw (r_Error);
int sendAndReturnStatus() throw (r_Error);
bool detectErrors();
// doesn't return if there is an error
void reassemble_r_Error() throw (r_Error);
// a very internal helper for some functions
void helper012d(const char* caller) throw (r_Error);
};
#endif