/// <summary>
/// Constructs a new <c>HsqlTcpClient</c> instance
/// with the given host, port, etc.
/// </summary>
/// <param name="host">The server host name or IP address.</param>
/// <param name="port">The server listen port.</param>
/// <param name="path">The database remote open path. (presently unused/unsupported)</param>
/// <param name="database">The server alias for one of its mounted databases</param>
/// <param name="tls">The Transport Layer Security flag</param>
/// <param name="user">The initial database user name.</param>
/// <param name="password">The initial database user password.</param>
/// <exception cref="HsqlException">
/// </exception>
internal HsqlTcpClient(
string host,
int port,
string path,
string database,
bool tls,
string user,
string password)
{
m_host = host;
m_port = port;
m_path = path;
m_database = database;
m_tls = tls;
InitializeInstance();
InitializeConnection(host, port, tls);
Request loginRequest = m_Protocol.CreateTcpClientLoginRequest(
user,
password,
database);
Response loginResponse = Session.execute(loginRequest);
if (loginResponse.isError())
{
throw Trace.error(loginResponse);
}
m_sessionId = m_Protocol.GetSessionId(loginResponse);
m_databaseId = m_Protocol.GetDatabaseId(loginResponse);
}
/// <summary>
/// Checks if row data is available.
/// </summary>
internal void CheckAvailable()
{
if (!m_isInitialized ||
(m_currentRecord == null) ||
(m_result == null))
{
throw new HsqlDataSourceException(Trace.error(
Trace.NO_DATA_IS_AVAILABLE));
}
}
/// <summary>
/// Opens the connection.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="port">The port.</param>
/// <param name="tls">
/// if set to <c>true</c>, use transport layer security.
/// </param>
/// <exception cref="HsqlException">
/// </exception>
protected virtual void OpenConnection(
string host,
int port,
bool tls)
{
if (m_tcpClient != null)
{
throw new System.InvalidOperationException(
"The connection is already open.");
}
HsqlDiagnostics.Debug("...");
try
{
HsqlDiagnostics.Debug("Entered with arguments ({0},{1},{2})",
host, port, tls);
m_tcpClient = new TcpClient(host, port);
HsqlDiagnostics.Debug("Created TcpClient({0},{1})", host, port);
Stream stream = m_tcpClient.GetStream();
HsqlDiagnostics.Debug("Got client stream from TcpClient");
if (m_tls)
{
HsqlDiagnostics.Debug("Initializing Client TLS...");
SslStream sslStream = new SslStream(
stream,
false,
ValidateRemoteCertificate,
null);
HsqlDiagnostics.Debug("Invoking sslStream.AuthenticateAsClient({0})",
host);
sslStream.AuthenticateAsClient(host);
stream = sslStream;
}
JavaInputStreamAdapter input = new JavaInputStreamAdapter(stream);
JavaOutputStreamAdapter output = new JavaOutputStreamAdapter(stream);
m_dataInput = new DataInputStream(new BufferedInputStream(input));
m_dataOutput = new BufferedOutputStream(output);
}
catch (System.Exception e)
{
throw Trace.error(Trace.SOCKET_ERROR, e);
}
}
/// <summary>
/// Gets the value of the session attribute with the given identifier.
/// </summary>
/// <param name="attributeId">The attribute identifier.</param>
/// <returns>The attribute value</returns>
private object GetAttribute(int attributeId)
{
m_Protocol.SetType(m_request, RequestType.GETSESSIONATTR);
Response response = Session.execute(m_request);
if (response.isError())
{
throw Trace.error(response);
}
switch (attributeId)
{
case SessionInfo.INFO_AUTOCOMMIT:
{
return(m_Protocol.GetAttributeAutoCommit(response));
}
case SessionInfo.INFO_CONNECTION_READONLY:
{
return(m_Protocol.GetAttributeConnectionReadOnly(
response));
}
case SessionInfo.INFO_DATABASE:
{
return(m_Protocol.GetAttributeDatabase(response));
}
case SessionInfo.INFO_DATABASE_READONLY:
{
return(m_Protocol.GetAttributeDatabaseReadOnly(
response));
}
case SessionInfo.INFO_ISOLATION:
{
return(m_Protocol.GetAttributeIsolation(response));
}
case SessionInfo.INFO_USER:
{
return(m_Protocol.GetAttributeUser(response));
}
default:
{
throw new ArgumentException(
"attributeId",
"Unknown Attribute Id: " + attributeId);
}
}
}
/// <summary>
/// Sets the value of the attribute denoted by the given identifier.
/// </summary>
/// <param name="value">The attribute value.</param>
/// <param name="attributeId">The attribute identifier.</param>
/// <exception cref="HsqlException">
/// </exception>
private void SetAttribute(object value, int attributeId)
{
m_Protocol.SetType(m_request, RequestType.SETSESSIONATTR);
m_Protocol.ClearAttributes(m_request);
switch (attributeId)
{
case SessionInfo.INFO_AUTOCOMMIT:
{
m_Protocol.SetAttributeAutoCommit(
m_request,
(bool)value);
break;
}
case SessionInfo.INFO_CONNECTION_READONLY:
{
m_Protocol.SetAttributeConnectionReadOnly(
m_request,
(bool)value);
break;
}
case SessionInfo.INFO_ISOLATION:
{
m_Protocol.SetAttributeIsolation(
m_request,
(int)value);
break;
}
default:
{
throw new System.ArgumentException(
"attributeId",
"Invalid Attribute Id: "
+ attributeId);
}
}
Response response = Session.execute(m_request);
if (response.isError())
{
throw Trace.error(response);
}
}
/// <summary>
/// Resets this session.
/// </summary>
/// <remarks>
/// Used to reset the remote session object. In case of
/// failure, the underlying TPC connection is physically
/// closed. When a pooled database connection's close()
/// method is called, it should delegate to this method
/// instead of ISession.close() and return this object
/// to the pool upon success. In this way, a remote session
/// proxy object can be reused with no further
/// initialisation.
/// </remarks>
/// <exception cref="HsqlException">
/// </exception>
void ISession.resetSession()
{
Request request = new Request(RequestType.HSQLRESETSESSION);
Response response = Session.execute(request);
if (response.isError())
{
m_closed = true;
CloseConnection();
throw Trace.error(response);
}
m_sessionId = m_Protocol.GetSessionId(response);
m_databaseId = m_Protocol.GetDatabaseId(response);
}
/// <summary>
/// Executes the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
/// <exception cref="HsqlException">
/// </exception>
Response ISession.execute(Request request)
{
lock (this)
{
try
{
m_Protocol.SetSessionId(request, m_sessionId);
m_Protocol.SetDatabaseId(request, m_databaseId);
WriteRequest(request);
return(ReadResponse());
}
catch (System.Exception e)
{
throw Trace.error(
Trace.CONNECTION_IS_BROKEN,
e.ToString());
}
}
}
/// <summary>
/// Constructs a new <c>HsqlDataSourceException</c> instance
/// with the specified error message and code.
/// </summary>
/// <remarks>
/// If possible, <c>SQLState</c> is derived from <c>errorCode</c>;
/// otherwise, <c>SQLState</c> will be <c>null</c>.
/// </remarks>
/// <param name="message">
/// The error message that explains the reason for the exception.
/// </param>
/// <param name="errorCode">
/// The error code for the exception.
/// </param>
public HsqlDataSourceException(string message, int errorCode)
: this(HsqlTrace.error(errorCode, message))
{
}
