public void TestMessageTooLong()
{
int maxMessageLength = KuduStatus.MaxMessageLength;
string abbreviation = KuduStatus.Abbreviation;
int abbreviationLength = abbreviation.Length;
// Test string that will not get abbreviated.
var str = new string('a', maxMessageLength);
var status = KuduStatus.Corruption(str);
Assert.Equal(str, status.Message);
// Test string just over the limit that will get abbreviated.
str = new string('a', maxMessageLength + 1);
status = KuduStatus.Corruption(str);
Assert.Equal(maxMessageLength, status.Message.Length);
Assert.Equal(
status.Message.Substring(maxMessageLength - abbreviationLength),
abbreviation);
// Test string that's way too big that will get abbreviated.
str = new string('a', maxMessageLength * 2);
status = KuduStatus.Corruption(str);
Assert.Equal(maxMessageLength, status.Message.Length);
Assert.Equal(
status.Message.Substring(maxMessageLength - abbreviationLength),
abbreviation);
}
public NonCoveredRangeException(
byte[] nonCoveredRangeStart,
byte[] nonCoveredRangeEnd)
: base(KuduStatus.NotFound(GetMessage(
nonCoveredRangeStart, nonCoveredRangeEnd)))
{
NonCoveredRangeStart = nonCoveredRangeStart;
NonCoveredRangeEnd = nonCoveredRangeEnd;
}
public void TestPosixCode()
{
var status = KuduStatus.NotFound("File not found", 2);
Assert.False(status.IsOk);
Assert.False(status.IsAborted);
Assert.True(status.IsNotFound);
Assert.Equal(2, status.PosixCode);
Assert.Equal("Not found: File not found (error 2)", status.ToString());
}
private static KuduStatus GetStatus(List <KuduStatus> errors)
{
var stringBuilder = new StringBuilder("Per row errors:");
foreach (var error in errors)
{
stringBuilder.Append($"{Environment.NewLine}{error.Message}");
}
return(KuduStatus.InvalidArgument(stringBuilder.ToString()));
}
public async Task <KuduConnection> GetConnectionAsync(
ServerInfo serverInfo, CancellationToken cancellationToken = default)
{
if (_disposed)
{
ThrowObjectDisposedException();
}
IPEndPoint endpoint = serverInfo.Endpoint;
Task <KuduConnection>?connectionTask;
bool newConnection = false;
lock (_connections)
{
if (!_connections.TryGetValue(endpoint, out connectionTask))
{
connectionTask = _connectionFactory.ConnectAsync(serverInfo, cancellationToken);
_connections.Add(endpoint, connectionTask);
newConnection = true;
}
}
try
{
var connection = await connectionTask.ConfigureAwait(false);
if (newConnection)
{
connection.ConnectionClosed.UnsafeRegister(
state => RemoveConnection((IPEndPoint)state !),
endpoint);
}
return(connection);
}
catch (Exception ex)
{
// Failed to negotiate a new connection.
RemoveFaultedConnection(endpoint);
_logger.UnableToConnectToServer(ex, serverInfo);
if (ex is NonRecoverableException)
{
// Always retry, except for these.
throw;
}
// The upper-level caller should handle the exception and
// retry using a new connection.
throw new RecoverableException(
KuduStatus.NetworkError(ex.Message), ex);
}
}
public void TestStatusNonPosix()
{
var status = KuduStatus.Aborted("foo");
Assert.False(status.IsOk);
Assert.True(status.IsAborted);
Assert.Equal(ErrorCode.Aborted, status.Code);
Assert.Equal("foo", status.Message);
Assert.Equal(-1, status.PosixCode);
Assert.Equal("Aborted: foo", status.ToString());
}
private static async Task <IPAddress[]> GetHostAddressesAsync(string hostName)
{
Exception?exception = null;
try
{
var ipAddresses = await Dns.GetHostAddressesAsync(hostName).ConfigureAwait(false);
if (ipAddresses.Length > 0)
{
return(ipAddresses);
}
}
catch (Exception ex)
{
exception = ex;
}
var status = KuduStatus.IOError($"Unable to resolve address for {hostName}");
throw new NonRecoverableException(status, exception);
}
public InvalidAuthzTokenException(KuduStatus status)
: base(status)
{
}
public RecoverableException(KuduStatus status)
: base(status)
{
}
public RecoverableException(KuduStatus status, Exception?innerException)
: base(status, innerException)
{
}
public FaultTolerantScannerExpiredException(KuduStatus status)
: base(status)
{
}
public NoLeaderFoundException(string message, Exception?innerException)
: base(KuduStatus.NetworkError(message), innerException)
{
}
public RpcRemoteException(KuduStatus status, ErrorStatusPB errorPb)
: base(status)
{
ErrorPb = errorPb;
}
public KuduException(KuduStatus status, Exception?innerException)
: base(status.Message, innerException)
{
Status = status;
}
public KuduException(KuduStatus status)
: base(status.Message)
{
Status = status;
}
