public void HandleFailureMessage(string code, string message)
{
DequeueMessage();
Error = ParseServerException(code, message);
CurrentResponseCollector?.DoneFailure();
_logger?.Debug("S: ", new FailureMessage(code, message));
}
public void Clear()
{
_resultBuilders.Clear();
_sentMessages.Clear();
CurrentResultBuilder = null;
Error = null;
}
public Neo4jException OnNeo4jError(Neo4jException e)
{
foreach (var handler in _handlers)
{
e = handler.OnNeo4jError(e);
}
return(e);
}
private Neo4jException OnNeo4jError(Neo4jException error)
{
if (error.IsRecoverableError())
{
_connection.AckFailure();
}
else
{
HasUnrecoverableError = true;
}
return(error);
}
public void HandleSuccessMessage(IDictionary <string, object> meta)
{
DequeueMessage();
if (meta.ContainsKey("fields"))
{
// first success
CurrentResultBuilder?.CollectFields(meta);
}
else
{
// second success
// before summary method is called
CurrentResultBuilder?.CollectSummary(meta);
}
Error = null;
_logger?.Debug("S: ", new SuccessMessage(meta));
}
private Neo4jException OnNeo4jError(Neo4jException error, Uri uri)
{
if (error.IsClusterNotALeaderError())
{
// The lead is no longer a leader, a.k.a. the write server no longer accepts writes
// However the server is still available for possible reads.
// Therefore we just remove it from ClusterView but keep it in connection pool.
_clusterView.Remove(uri);
return(new SessionExpiredException($"Server at {uri} no longer accepts writes"));
}
else if (error.IsForbiddenOnReadOnlyDatabaseError())
{
// The user was trying to run a write in a read session
// So inform the user and let him try with a proper session mode
return(new ClientException("Write queries cannot be performed in READ access mode."));
}
return(error);
}
public void HandleFailureMessage(string code, string message)
{
var parts = code.Split('.');
var classification = parts[1].ToLowerInvariant();
switch (classification)
{
case "clienterror":
Error = new ClientException(code, message);
break;
case "transienterror":
Error = new TransientException(code, message);
break;
default:
Error = new DatabaseException(code, message);
break;
}
_sentMessages.Dequeue();
_resultBuilders.Dequeue();
_logger?.Debug("S: ", new FailureMessage(code, message));
}
public void HandleFailureMessage(string code, string message)
{
DequeueMessage();
var parts = code.Split('.');
var classification = parts[1].ToLowerInvariant();
switch (classification)
{
case "clienterror":
Error = new ClientException(code, message);
break;
case "transienterror":
Error = new TransientException(code, message);
break;
default:
Error = new DatabaseException(code, message);
break;
}
CurrentResultBuilder?.InvalidateResult(); // an error received, so the result is broken
_logger?.Debug("S: ", new FailureMessage(code, message));
}
public static bool IsForbiddenOnReadOnlyDatabaseError(this Neo4jException error)
{
return(error.Code.Equals("Neo.ClientError.General.ForbiddenOnReadOnlyDatabase"));
}
public static bool IsClusterNotALeaderError(this Neo4jException error)
{
return(error.Code.Equals("Neo.ClientError.Cluster.NotALeader"));
}
public static bool IsClusterError(this Neo4jException error)
{
return(IsClusterNotALeaderError(error) ||
IsForbiddenOnReadOnlyDatabaseError(error));
}
public static bool IsRecoverableError(this Neo4jException error)
{
return((error is ClientException || error is TransientException) && !IsClusterError(error));
}
public Neo4jException OnNeo4jError(Neo4jException e)
{
return(_onNeo4jErrorFunc.Invoke(e));
}
private bool IsRecoverableError(Neo4jException error)
{
return(error is ClientException || error is TransientException);
}
