internal static async Task <DbConnection> TryOpenAsync(this DbConnection connection, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
if (connection.State == ConnectionState.Broken)
{
connection.Close();
}
if (connection.State != ConnectionState.Open)
{
try
{
var watch = Stopwatch.StartNew();
await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
Tracer.Debug($"The connection of '{connection.ConnectionString}' was opened ({watch.ElapsedMilliseconds}ms).");
}
catch (DbException exp)
{
Tracer.Error($"Opening Connection of '{connection.ConnectionString}' throw exception:{exp.Output()}");
throw ConnectionException.Throw(ConnectionState.Open, exp);
}
}
return(connection);
}
void InitializeProjectClientListener()
{
try
{
var client = Player.CreateClient(m_Project, m_User, ProjectServer.Client);
m_Listener = new ClientListener(client); // TODO Should this class also be responsible to instantiate the Client?
m_Listener.onManifestUpdated += (c, s) => manifestUpdated?.Invoke();
}
catch (ConnectionException ex)
{
var unityProject = m_Project;
string message;
if (unityProject.Host.IsLocalService)
{
message = "A connection with your local server could not be established. Make sure the Unity Reflect Service is running.";
}
else
{
if (unityProject.Host.ServerName == "Cloud")
{
message = $"A connection with Reflect Cloud could not be established.";
}
else
{
message = $"A connection with the server {unityProject.Host.ServerName} could not be established. This server may be outside your local network (LAN) or may not accept external connections due to firewall policies.";
}
}
ex = new ConnectionException(message, ex);
//completeWithError(ex);
//throw ex;
}
}
/// <summary>
/// Resets the state of this object and clears its properties.
/// </summary>
public void Reset()
{
this.Headers = null;
this.Body = string.Empty;
this.StatusCode = null;
this.Exception = null;
}
private ConnectionStatus Execute(RestRequest restRequest)
{
//RestResponse result = GetClient().execute(restRequest);
//
if (!this._resourceLock.WaitOne(this._timeout))
{
var m = "Could not start the thrift operation before the timeout of " + this._timeout + "ms completed while waiting for the semaphore";
return(new ConnectionStatus(this._connectionSettings, new TimeoutException(m)));
}
try
{
Rest.Client client = null;
if (!this._clients.TryDequeue(out client))
{
var m = string.Format("Could dequeue a thrift client from internal socket pool of size {0}", this._poolSize);
var status = new ConnectionStatus(this._connectionSettings, new Exception(m));
return(status);
}
try
{
if (!client.InputProtocol.Transport.IsOpen)
{
client.InputProtocol.Transport.Open();
}
var result = client.execute(restRequest);
if (result.Status == Status.OK || result.Status == Status.CREATED || result.Status == Status.ACCEPTED)
{
return(new ConnectionStatus(this._connectionSettings, DecodeStr(result.Body)));
}
else
{
var connectionException = new ConnectionException(
msg: Enum.GetName(typeof(Status), result.Status),
statusCode: (int)result.Status,
response: DecodeStr(result.Body)
);
return(new ConnectionStatus(this._connectionSettings, connectionException));
}
}
catch
{
throw;
}
finally
{
//make sure we make the client available again.
this._clients.Enqueue(client);
}
}
catch (Exception e)
{
return(new ConnectionStatus(this._connectionSettings, e));
}
finally
{
this._resourceLock.Release();
}
}
/// <summary>
/// Resets the state of this object and clears its properties.
/// </summary>
public void Reset()
{
this.Headers = null;
this.Body = string.Empty;
this.StatusCode = null;
this.Exception = null;
}
public async Task TryRespondAsync_Generates_Warning_On_Cache_Add_Failure(string username, int token, string query, SearchResponse searchResponse, IPEndPoint endpoint, int responseToken)
{
var value = (username, token, query, searchResponse);
var cacheEx = new Exception();
var cache = new Mock <ISearchResponseCache>();
cache.Setup(m => m.AddOrUpdate(responseToken, value))
.Throws(cacheEx);
var(responder, mocks) = GetFixture(new SoulseekClientOptions(
searchResponseCache: cache.Object,
searchResponseResolver: (u, t, q) => Task.FromResult(searchResponse)));
mocks.Client.Setup(m => m.GetUserEndPointAsync(username, It.IsAny <CancellationToken?>()))
.Returns(Task.FromResult(endpoint));
mocks.Client.Setup(m => m.GetNextToken())
.Returns(responseToken);
var ex = new ConnectionException();
mocks.PeerConnectionManager.Setup(m => m.GetOrAddMessageConnectionAsync(username, endpoint, responseToken, It.IsAny <CancellationToken>()))
.Returns(Task.FromException <IMessageConnection>(ex));
var responded = await responder.TryRespondAsync(username, token, query);
Assert.False(responded);
mocks.Diagnostic.Verify(m => m.Warning(It.Is <string>(s => s.ContainsInsensitive("Error caching undelivered search response")), cacheEx), Times.Once);
}
public async Task TryRespondAsync_Caches_Response_On_Connect_Failure(string username, int token, string query, SearchResponse searchResponse, IPEndPoint endpoint, int responseToken)
{
var cache = new Mock <ISearchResponseCache>();
var(responder, mocks) = GetFixture(new SoulseekClientOptions(
searchResponseCache: cache.Object,
searchResponseResolver: (u, t, q) => Task.FromResult(searchResponse)));
mocks.Client.Setup(m => m.GetUserEndPointAsync(username, It.IsAny <CancellationToken?>()))
.Returns(Task.FromResult(endpoint));
mocks.Client.Setup(m => m.GetNextToken())
.Returns(responseToken);
var ex = new ConnectionException();
mocks.PeerConnectionManager.Setup(m => m.GetOrAddMessageConnectionAsync(username, endpoint, responseToken, It.IsAny <CancellationToken>()))
.Returns(Task.FromException <IMessageConnection>(ex));
var responded = await responder.TryRespondAsync(username, token, query);
Assert.False(responded);
var value = (username, token, query, searchResponse);
cache.Verify(m => m.AddOrUpdate(responseToken, value), Times.Once);
}
static bool IsUnrecoverable(Exception exception)
{
return(exception switch
{
ConnectionException connectionException => !connectionException.IsTransient,
_ => false
});
internal static void OpenClose(this DbConnection connection, Action action)
{
if (action == null)
{
return;
}
if (connection.State != ConnectionState.Open)
{
try
{
connection.Open();
}
catch (DbException exp)
{
throw ConnectionException.Throw(ConnectionState.Open, exp);
}
}
action();
if (connection.State != ConnectionState.Closed)
{
try
{
connection.Close();
}
catch (DbException exp)
{
throw ConnectionException.Throw(ConnectionState.Closed, exp);
}
}
}
private void Throw(IPEndPoint endPoint, string message, Exception inner = null)
{
var ce = new ConnectionException(endPoint, message, inner);
_Logger.Error(ce.Message, ce);
throw ce;
}
/// <summary>
/// Resets the state of this object and clears its properties.
/// </summary>
public void Reset()
{
Headers = null;
Body = string.Empty;
StatusCode = null;
Exception = null;
}
public void TestSendTestFRTimeoutMaster()
{
ConnectionParameters clientParameters = new ConnectionParameters();
ConnectionParameters serverParameters = new ConnectionParameters();
clientParameters.T3 = 1;
Server server = new Server(serverParameters);
server.SetLocalPort(20213);
server.Start();
Connection connection = new Connection("127.0.0.1", 20213, clientParameters);
connection.Connect();
connection.SetRawMessageHandler(testSendTestFRTimeoutMasterRawMessageHandler, null);
ASDU asdu = new ASDU(clientParameters, CauseOfTransmission.SPONTANEOUS, false, false, 0, 1, false);
asdu.AddInformationObject(new SinglePointInformation(100, false, new QualityDescriptor()));
connection.SendASDU(asdu);
Assert.AreEqual(2, connection.GetStatistics().SentMsgCounter); /* STARTDT + ASDU */
while (connection.GetStatistics().RcvdMsgCounter < 2)
{
Thread.Sleep(1);
}
Assert.AreEqual(2, connection.GetStatistics().RcvdMsgCounter); /* STARTDT_CON + ASDU */
Thread.Sleep(6000);
// Expect connection to be closed due to three missing TESTFR_CON responses
Assert.IsFalse(connection.IsRunning);
ConnectionException ce = null;
// Connection is closed. SendASDU should fail
try {
connection.SendASDU(asdu);
}
catch (ConnectionException e) {
ce = e;
}
Assert.IsNotNull(ce);
Assert.AreEqual("not connected", ce.Message);
connection.Close();
server.Stop();
Assert.AreEqual(5, connection.GetStatistics().RcvdMsgCounter); /* STARTDT_CON + ASDU + TESTFR_CON */
Assert.AreEqual(0, connection.GetStatistics().RcvdTestFrConCounter);
}
public void Constructor_ReturnsInstance()
{
ConnectionException connectionException = new ConnectionException(HttpStatusCode.InternalServerError, "test_string");
Assert.IsNotNull(connectionException);
Assert.AreEqual("test_string", connectionException.ReasonPhrase);
Assert.AreEqual(HttpStatusCode.InternalServerError, connectionException.StatusCode);
}
public static DataphorFault ExceptionToFault(DataphorException exception)
{
DataphorFault fault = new DataphorFault();
fault.ExceptionClassName = exception.GetType().Name;
fault.Code = exception.Code;
fault.Severity = exception.Severity;
fault.Message = exception.Message;
fault.Details = exception.Details;
fault.ServerContext = exception.ServerContext;
if (exception.InnerException != null)
{
fault.InnerFault = ExceptionToFault(exception.InnerException);
}
#if !SILVERLIGHT
// Under Silverlight, a ConnectionException will come back as a DataphorException
// The statement is still present in the Details.
ConnectionException connectionException = exception as ConnectionException;
if (connectionException != null)
{
fault.Statement = connectionException.Statement;
}
#endif
SyntaxException syntaxException = exception as SyntaxException;
if (syntaxException != null)
{
fault.Locator = syntaxException.Locator;
fault.Line = syntaxException.Line;
fault.LinePos = syntaxException.LinePos;
fault.Token = syntaxException.Token;
fault.TokenType = syntaxException.TokenType;
}
CompilerException compilerException = exception as CompilerException;
if (compilerException != null)
{
fault.Locator = compilerException.Locator;
fault.Line = compilerException.Line;
fault.LinePos = compilerException.LinePos;
fault.ErrorLevel = compilerException.ErrorLevel;
}
RuntimeException runtimeException = exception as RuntimeException;
if (runtimeException != null)
{
fault.Locator = runtimeException.Locator;
fault.Line = runtimeException.Line;
fault.LinePos = runtimeException.LinePos;
fault.Context = runtimeException.Context;
}
return(fault);
}
private async Task <HttpResponseMessage> Call(string url, HttpMethod method, CancellationToken cancellationToken, object data = null)
{
using (var httpClient = new HttpClient())
{
cancellationToken.ThrowIfCancellationRequested();
if (method == HttpMethod.Get)
{
if (data != null)
{
var query = data.ToString();
url += "?" + query;
}
}
using (var request = new HttpRequestMessage {
RequestUri = new Uri(url), Method = method
})
{
cancellationToken.ThrowIfCancellationRequested();
if (!string.IsNullOrEmpty(Toke))
{
List <string> values = new List <string>();
httpClient.DefaultRequestHeaders.Clear();
values.Add(Toke);
httpClient.DefaultRequestHeaders.Add("iSystainToken", values);
// httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("bearer", this.Toke);
}
cancellationToken.ThrowIfCancellationRequested();
if (method != HttpMethod.Get)
{
var jsonContent = JsonConvert.SerializeObject(data);
request.Content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
}
HttpResponseMessage response = new HttpResponseMessage();
try
{
cancellationToken.ThrowIfCancellationRequested();
response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
var excep = new ConnectionException(ex.Message);
throw excep;
}
return(response);
}
}
}
/// <summary>
/// Helper method for functional tests where we want to record more details.
/// </summary>
/// <param name="ex">The exception containing the information to be recorded.</param>
public static void WriteConnectionExceptionDetails(ConnectionException ex)
{
System.Diagnostics.Trace.WriteLine("[WebExceptionStatus]: " + ex.WebExceptionStatus);
System.Diagnostics.Trace.WriteLine("[Request URL]: " + ex.Request.RequestUri.AbsoluteUri);
System.Diagnostics.Trace.WriteLine("[Request Headers]: " + string.Join(" ; ", ex.Request.Headers));
// Check if the exception is an HttpException. If so, log the response headers.
if (ex is HttpException)
{
System.Diagnostics.Trace.WriteLine("[Response Headers]: " + string.Join(" ; ", ((HttpException)ex).Headers));
}
System.Diagnostics.Trace.WriteLine("[Response]: " + ex.Response);
}
public void TestConnectionException()
{
// arrange
var inner = new Exception();
// act
var exception = new ConnectionException(inner);
exception.PreviousAppointmentState = AppointmentState.Modified;
// assert
Assert.That(exception.InnerException, Is.EqualTo(inner));
Assert.That(exception.PreviousAppointmentState, Is.EqualTo(AppointmentState.Modified));
}
internal static async Task TryOpenAsync(this DbConnection connection, bool autoOpen = true, CancellationToken cancellationToken = default)
{
if (autoOpen && connection.State != ConnectionState.Open)
{
try
{
await connection.OpenAsync(cancellationToken);
}
catch (DbException exp)
{
throw ConnectionException.Throw(ConnectionState.Open, exp);
}
}
}
internal static void TryClose(this DbConnection connection, bool autoOpen = true)
{
if (autoOpen && connection.State != ConnectionState.Closed)
{
try
{
connection.Close();
}
catch (DbException exp)
{
throw ConnectionException.Throw(ConnectionState.Closed, exp);
}
}
}
public void HandleLastError(string message)
{
Exception newException;
if (_lastException is WebException)
{
newException = new ConnectionException(message, _lastException);
}
else
{
newException = new InputOutputException(_lastException, message);
}
_io.HandleException(newException);
}
/// <summary>
/// Проверить подключение к БД.
/// </summary>
public bool TryConnect(out ConnectionException error)
{
error = null;
try
{
using DbConnection conn = OpenNewConnection();
return(true);
}
catch (ConnectionException ex)
{
error = ex;
return(false);
}
}
public void ConnectionException_CanBeSerialized()
{
// Arrange
const string dummyMessage = "dummyMessage";
IFormatter dummyFormatter = new BinaryFormatter();
var dummyStream = new MemoryStream();
var testSubject = new ConnectionException(dummyMessage);
// Act
dummyFormatter.Serialize(dummyStream, testSubject);
dummyStream.Position = 0;
var result = (ConnectionException)dummyFormatter.Deserialize(dummyStream);
// Assert
Assert.Equal(dummyMessage, result.Message);
}
public void ConnectionExceptionConstructors()
{
_ = new ConnectionException();
_ = new ConnectionException("exception");
_ = new ConnectionException(new Exception("bang"));
var e = new ConnectionException("exception", new Exception("bang"));
Assert.That(e.Message, Is.EqualTo("exception"));
Assert.That(e.InnerException, Is.Not.Null);
Assert.That(e.InnerException.Message, Is.EqualTo("bang"));
e = e.SerializeAndDeSerialize();
Assert.That(e.Message, Is.EqualTo("exception"));
Assert.That(e.InnerException, Is.Not.Null);
Assert.That(e.InnerException.Message, Is.EqualTo("bang"));
}
internal static DbConnection TryOpen(this DbConnection connection)
{
if (connection.State != ConnectionState.Open)
{
try
{
var watch = Stopwatch.StartNew();
connection.Open();
Tracer.Debug($"The connection of '{connection.ConnectionString}' was opened ({watch.ElapsedMilliseconds}ms).");
}
catch (DbException exp)
{
Tracer.Error($"Opening Connection of '{connection.ConnectionString}' throw exception:{exp.Output()}");
throw ConnectionException.Throw(ConnectionState.Open, exp);
}
}
return(connection);
}
public void ConnectionExceptionConstructorTest()
{
// test case 1: no parameters
ConnectionException exception = new ConnectionException();
Assert.AreEqual(null, exception.Path);
// test case 2: message parameter
exception = new ConnectionException("Exception message.");
Assert.AreEqual("Exception message.", exception.Message);
Assert.AreEqual(null, exception.Path);
// test case 3: message and path parameters
exception = new ConnectionException("Exception message.", "path");
Assert.AreEqual("Exception message.", exception.Message);
Assert.AreEqual("path", exception.Path);
// test case 4: message and innerexception parameters
Exception innerException = new Exception();
exception = new ConnectionException("Exception message.", innerException);
Assert.AreEqual("Exception message.", exception.Message);
Assert.AreEqual(null, exception.Path);
Assert.AreEqual(innerException, exception.InnerException);
// test case 5: message, path and innerexception parameters
exception = new ConnectionException("Exception message.", "path", innerException);
Assert.AreEqual("Exception message.", exception.Message);
Assert.AreEqual("path", exception.Path);
Assert.AreEqual(innerException, exception.InnerException);
}
public async Task TryRespondAsync_Generates_Debug_On_Failure(string username, int token, string query, SearchResponse searchResponse, IPEndPoint endpoint, int responseToken)
{
var(responder, mocks) = GetFixture(new SoulseekClientOptions(searchResponseResolver: (u, t, q) => Task.FromResult(searchResponse)));
mocks.Client.Setup(m => m.GetUserEndPointAsync(username, It.IsAny <CancellationToken?>()))
.Returns(Task.FromResult(endpoint));
mocks.Client.Setup(m => m.GetNextToken())
.Returns(responseToken);
var ex = new ConnectionException();
mocks.PeerConnectionManager.Setup(m => m.GetOrAddMessageConnectionAsync(username, endpoint, responseToken, It.IsAny <CancellationToken>()))
.Returns(Task.FromException <IMessageConnection>(ex));
var responded = await responder.TryRespondAsync(username, token, query);
Assert.False(responded);
mocks.Diagnostic.Verify(m => m.Debug(It.Is <string>(s => s.ContainsInsensitive("Failed to send search response")), ex), Times.Once);
}
public WhenAnErrorOccursWhenSendingAPing()
{
var clientFactory = new Mock <IClientFactory>();
_client = new Mock <IClient>();
_client
.Setup(c => c.SendAsync(It.IsAny <IRedisType>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new RedisString("PONG"));
clientFactory.SetReturnsDefault(Task.FromResult(_client.Object));
_connection = new BasicConnection(new IPEndPoint(IPAddress.Loopback, 6379), clientFactory.Object);
_connection.OpenAsync(CancellationToken.None).Wait();
_client.Reset();
_client
.Setup(c => c.SendAsync(It.IsAny <IRedisType>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new SocketException());
_ex = Assert.ThrowsAsync <ConnectionException>(() => _connection.PingAsync(CancellationToken.None)).Result;
}
//[Ignore("Ignore to save execution time")]
public void TestConnectWhileAlreadyConnected()
{
ConnectionParameters parameters = new ConnectionParameters();
Server server = new Server(parameters);
server.SetLocalPort(20213);
server.Start();
Connection connection = new Connection("127.0.0.1", 20213, parameters);
ConnectionException se = null;
try {
connection.Connect();
}
catch (ConnectionException ex) {
se = ex;
}
Assert.IsNull(se);
Thread.Sleep(100);
try {
connection.Connect();
}
catch (ConnectionException ex) {
se = ex;
}
Assert.IsNotNull(se);
Assert.AreEqual(se.Message, "already connected");
Assert.AreEqual(10056, ((SocketException)se.InnerException).ErrorCode);
connection.Close();
server.Stop();
}
protected virtual async void OnConnectionException(ConnectionException ex)
{
var requestResult = ex?.RequestResult;
if (requestResult == null || requestResult.RequestCanceled)
{
return;
}
if (requestResult.ResponseContent != null)
{
var contentAsString = await requestResult.ResponseContent.ReadAsStringAsync();
await UserDialogs.Error(contentAsString ?? requestResult.Exception?.Message);
}
MvxTrace.TaggedTrace(MvxTraceLevel.Warning, this.GetType().FullName, Newtonsoft.Json.JsonConvert.SerializeObject(requestResult, Newtonsoft.Json.Formatting.Indented));
if (ex != null)
{
MvxTrace.TaggedTrace(MvxTraceLevel.Warning, this.GetType().FullName, ex.BuildAllMessagesAndStackTrace());
}
}
/// <summary>Report a Connection Exception</summary>
/// <param name="ce"></param>
public void ReportConnectionExceptionError(ConnectionException ce)
{
var errorDescription = "";
var solutionIdea = "";
if (ce.Message == "HostNotFound")
{
errorDescription += "The server you tried connecting to doesn't exist.";
solutionIdea += "Make sure the host name for the server you tried connecting to is correct.";
}
else if (ce.Message == "NoRouteToTost")
{
errorDescription += "A socket operation was attempted to an unreachable host";
solutionIdea += "Check the host name you tried connecting to. Make sure it's correct.";
}
else if (ce.Message == "ConnectionRefused")
{
errorDescription += "No connection could be made because the target computer actively refused it. This usually results from trying to connect to a service that is inactive on the foreign host—that is, one with no server application running.";
solutionIdea += "Check the host name you tried connecting to, make sure it's correct. You can also try to report this problem to the server owners.";
}
else
{
errorDescription += "An unknown error occured.";
solutionIdea += "Please report this error in the SharpWired bug tracker at http://code.google.com/p/sharpwired/issues/list. Error message is: " + ce;
}
solutionIdea += " For now, restart SharpWired before trying again."; // TODO: Remove this once SW recovers from connection problems
Console.WriteLine("Error! " + errorDescription);
Console.WriteLine("Bookmark: " + ce.Bookmark);
if (LoginFailed != null)
{
LoginFailed(errorDescription, solutionIdea, ce.Bookmark);
}
}
internal static DbConnection TryClose(this DbConnection connection, bool allowClose = true)
{
if (!allowClose)
{
return(connection);
}
if (connection.State == ConnectionState.Open)
{
try
{
var watch = Stopwatch.StartNew();
connection.Close();
Tracer.Debug($"The connection of '{connection.ConnectionString}' was closed ({watch.ElapsedMilliseconds}ms).");
}
catch (DbException exp)
{
Tracer.Error($"Closing Connection of '{connection.ConnectionString}' throw exception:{exp.Output()}");
throw ConnectionException.Throw(ConnectionState.Open, exp);
}
}
return(connection);
}
static void updateReportScheduler2(string taskID, ConnectionException.Reason errorReason)
{
using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString))
{
conn.Open();
string sqlInsert = "INSERT INTO [db_knx].[dbo].[ReportScheduler] ([TaskID],[ErrorID],[ErrorException]) VALUES " +
" (" + taskID + ",N'" + errorReason + "',N'ConnectionException')";
using (SqlCommand sqlComm = new SqlCommand(sqlInsert, conn))
{
sqlComm.ExecuteNonQuery();
}
conn.Close();
}
}
private ElasticsearchResponse Execute(RestRequest restRequest)
{
//RestResponse result = GetClient().execute(restRequest);
//
var method = Enum.GetName(typeof (Method), restRequest.Method);
var path = restRequest.Uri.ToString();
var requestData = restRequest.Body;
if (!this._resourceLock.WaitOne(this._timeout))
{
var m = "Could not start the thrift operation before the timeout of " + this._timeout + "ms completed while waiting for the semaphore";
return ElasticsearchResponse.CreateError(this._connectionSettings, new TimeoutException(m), method, path, requestData);
}
try
{
Rest.Client client = null;
if (!this._clients.TryDequeue(out client))
{
var m = string.Format("Could dequeue a thrift client from internal socket pool of size {0}", this._poolSize);
var status = ElasticsearchResponse.CreateError(this._connectionSettings, new Exception(m), method, path, requestData);
return status;
}
try
{
if (!client.InputProtocol.Transport.IsOpen)
client.InputProtocol.Transport.Open();
var result = client.execute(restRequest);
if (result.Status == Status.OK || result.Status == Status.CREATED || result.Status == Status.ACCEPTED)
return ElasticsearchResponse.Create(this._connectionSettings, (int)result.Status, method, path, requestData, result.Body);
else
{
var connectionException = new ConnectionException((int)result.Status);
return ElasticsearchResponse.CreateError(this._connectionSettings, connectionException, method, path, requestData);
}
}
catch
{
throw;
}
finally
{
//make sure we make the client available again.
this._clients.Enqueue(client);
}
}
catch (Exception e)
{
return ElasticsearchResponse.CreateError(this._connectionSettings, e, method, path, requestData);
}
finally
{
this._resourceLock.Release();
}
}
public static PythonRemoteDebugProcess Connect(PythonRemoteDebugPort port) {
PythonRemoteDebugProcess process = null;
// Connect to the remote debugging server and obtain process information. If any errors occur, display an error dialog, and keep
// trying for as long as user clicks "Retry".
while (true) {
Stream stream = null;
ConnectionException connEx = null;
try {
// Process information is not sensitive, so ignore any SSL certificate errors, rather than bugging the user with warning dialogs.
stream = PythonRemoteProcess.Connect(port.Uri, false);
} catch (ConnectionException ex) {
connEx = ex;
}
using (stream) {
if (stream != null) {
try {
stream.Write(PythonRemoteProcess.InfoCommandBytes);
int pid = stream.ReadInt32();
string exe = stream.ReadString();
string username = stream.ReadString();
string version = stream.ReadString();
process = new PythonRemoteDebugProcess(port, pid, exe, username, version);
break;
} catch (IOException ex) {
connEx = new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
}
}
if (connEx != null) {
string errText;
switch (connEx.Error) {
case ConnErrorMessages.RemoteUnsupportedServer:
errText = Strings.RemoteUnsupportedServer_Host.FormatUI(port.Uri);
break;
case ConnErrorMessages.RemoteSecretMismatch:
errText = Strings.RemoteSecretMismatch_Host.FormatUI(new UriBuilder(port.Uri) { UserName = null, Password = null }.Uri);
break;
case ConnErrorMessages.RemoteSslError:
// User has already got a warning dialog and clicked "Cancel" on that, so no further prompts are needed.
return null;
default:
{
// Azure uses HTTP 503 (Service Unavailable) to indicate that websocket connections are not supported. Show a special error message for that.
var wsEx = connEx.InnerException as WebSocketException;
if (wsEx != null) {
var webEx = wsEx.InnerException as WebException;
if (webEx != null) {
var httpResponse = webEx.Response as HttpWebResponse;
if (httpResponse != null && httpResponse.StatusCode == HttpStatusCode.ServiceUnavailable) {
errText = Strings.RemoteAzureServiceUnavailable_Host.FormatUI(port.Uri);
break;
}
}
}
errText = Strings.RemoteServiceUnavailable_Host.FormatUI(port.Uri);
for (var ex = connEx.InnerException; ex != null; ex = ex.InnerException) {
if (ex.InnerException == null) {
errText += "\r\n\r\n{0}\r\n{1}".FormatUI(Strings.AdditionalInformation, ex.Message);
}
}
break;
}
}
DialogResult dlgRes = MessageBox.Show(errText, null, MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (dlgRes != DialogResult.Retry) {
break;
}
}
}
}
return process;
}
static void emailWaring(string _id, string _subject, DateTime _start, DateTime _end, string _channels, string _pillar, ConnectorException connectorException, ConnectionException connectionException, NoResponseReceivedException noResponseException)
{
string emailBody = string.Empty;
if (connectorException != null)
{
emailBody = "Γεια σας κ. Administrator.<br /><br />" +
"Σας ενημερώνουμε ότι η εργασία " + _id + " με την ημερομηνία έναρξης " + _start.ToString("d/M/yyyy H:mm tt") + " και την ημερομηνία λήξης " + _end.ToString("d/M/yyyy H:mm tt") + " ";
if (_subject.IndexOf("LIGHTS ON") > -1)
{
emailBody += "δεν άναψε";
}
if (_subject.IndexOf("LIGHTS OFF") > -1)
{
emailBody += "δεν έσβησε";
}
if (_channels == "0")
{
emailBody += " όλες τις ηλεκτρολογικές αναχωρήσεις";
}
else
{
emailBody += " τις ηλεκτρολογικές αναχωρήσεις " + _channels;
}
emailBody += " του πυλώνα " + getPillarName(_pillar);
switch (connectorException.ErrorReason)
{
case ConnectorException.Reason.DeviceNotFound:
emailBody += " επειδή <span style=\"color:red;\">Η συσκευή KNX δεν μπορεί να βρεθεί</span>.<br/><br/>";
break;
case ConnectorException.Reason.DeviceNotRespond:
emailBody += " επειδή <span style=\"color:red;\">Η συσκευή KNX δεν ανταποκρίνεται στο αναμενόμενο χρόνο</span>.<br/><br/>";
break;
case ConnectorException.Reason.NoMoreConnections:
emailBody += " επειδή : <span style=\"color:red;\">Η συσκευή KNX δεν μπορεί να δεχτεί τη νέα σύνδεση, διότι το ανώτατο οριο των ταυτόχρονων συνδέσεων έχει υπερβεί ήδη</span>.<br/><br/>";
break;
default:
emailBody += " επειδή <span style=\"color:red;\">" + connectorException.ErrorReason + "</span>.<br/>";
break;
}
emailBody += "Με εκτίμηση,<br/>Σύστημα Διαχείρισης Ηλεκτροφωτισμού";
}
if (connectionException != null)
{
emailBody = "Γεια σας κ. Administrator.<br /><br />" +
"Σας ενημερώνουμε ότι η εργασία " + _id + " με την ημερομηνία έναρξης " + _start.ToString("d/M/yyyy H:mm tt") + " και την ημερομηνία λήξης " + _end.ToString("d/M/yyyy H:mm tt") + " ";
if (_subject.IndexOf("LIGHTS ON") > -1)
{
emailBody += "δεν άναψε";
}
if (_subject.IndexOf("LIGHTS OFF") > -1)
{
emailBody += "δεν έσβησε";
}
if (_channels == "0")
{
emailBody += " όλες τις ηλεκτρολογικές αναχωρήσεις";
}
else
{
emailBody += " τις ηλεκτρολογικές αναχωρήσεις " + _channels;
}
emailBody += " του πυλώνα " + getPillarName(_pillar);
switch (connectionException.ErrorReason)
{
case ConnectionException.Reason.NotConnected:
emailBody += " επειδή <span style=\"color:red;\">Η σύνδεση δεν εγκαθιδρύθηκε</span>.<br/><br/>";
break;
case ConnectionException.Reason.NoMoreConnections:
emailBody += " επειδή <span style=\"color:red;\">Η συσκευή δεν μπορεί να δεχθεί τη νέα σύνδεση, διότι το ανώτατο ποσό των ταυτόχρονων συνδέσεων χρησιμοποιείται ήδη.</span>.<br/><br/>";
break;
case ConnectionException.Reason.ConnectionRefused:
emailBody += " επειδή <span style=\"color:red;\">Η σύνδεση αρνήθηκε από τη συσκευή προορισμού</span>.<br/><br/>";
break;
default:
emailBody += " επειδή <span style=\"color:red;\">" + connectionException.ErrorReason + "</span>.<br/>";
break;
}
emailBody += "Με εκτίμηση,<br/>Σύστημα Διαχείρισης Ηλεκτροφωτισμού";
}
if (noResponseException != null)
{
emailBody = "Γεια σας κ. Administrator.<br /><br />" +
"Σας ενημερώνουμε ότι η εργασία " + _id + " με την ημερομηνία έναρξης " + _start.ToString("d/M/yyyy H:mm tt") + " και την ημερομηνία λήξης " + _end.ToString("d/M/yyyy H:mm tt") + " ";
if (_subject.IndexOf("LIGHTS ON") > -1)
{
emailBody += "δεν άναψε";
}
if (_subject.IndexOf("LIGHTS OFF") > -1)
{
emailBody += "δεν έσβησε";
}
if (_channels == "0")
{
emailBody += " όλες τις ηλεκτρολογικές αναχωρήσεις";
}
else
{
emailBody += " τις ηλεκτρολογικές αναχωρήσεις " + _channels;
}
emailBody += " του πυλώνα " + getPillarName(_pillar);
switch (noResponseException.ErrorReason)
{
case NoResponseReceivedException.Reason.Confirmation:
emailBody += " επειδή <span style=\"color:red;\">Δεν λήφθηκε επιβεβαίωση για το τηλεγράφημα</span>.<br/><br/>";
break;
case NoResponseReceivedException.Reason.NegativeConfirmation:
emailBody += " επειδή <span style=\"color:red;\">Λήφθηκε μια αρνητική επιβεβαίωση για το τηλεγράφημα</span>.<br/><br/>";
break;
case NoResponseReceivedException.Reason.Indication:
emailBody += " επειδή <span style=\"color:red;\">Καμία ένδειξη για το τηλεγράφημα</span>.<br/><br/>";
break;
default:
emailBody += " επειδή <span style=\"color:red;\">" + noResponseException.ErrorReason + "</span>.<br/>";
break;
}
emailBody += "Με εκτίμηση,<br/>Σύστημα Διαχείρισης Ηλεκτροφωτισμού";
}
if(connectorException == null && connectionException == null && noResponseException == null)
{
emailBody = "Γεια σας κ. Administrator.<br /><br />" +
"Σας ενημερώνουμε ότι η εργασία " + _id + " με την ημερομηνία έναρξης " + _start.ToString("d/M/yyyy H:mm tt") + " και την ημερομηνία λήξης " + _end.ToString("d/M/yyyy H:mm tt")+" ";
if (_subject.IndexOf("LIGHTS ON") > -1)
{
emailBody += "άναψε";
}
if (_subject.IndexOf("LIGHTS OFF") > -1)
{
emailBody += "έσβησε";
}
if (_channels == "0")
{
emailBody += " όλες τις ηλεκτρολογικές αναχωρήσεις";
}
else
{
emailBody += " τις ηλεκτρολογικές αναχωρήσεις " + _channels;
}
emailBody += " του πυλώνα "+getPillarName(_pillar) + ".<br/><br/>";
emailBody += "Με εκτίμηση,<br/>Σύστημα Διαχείρισης Ηλεκτροφωτισμού";
}
// Send email report to system administrator
try
{
SmtpClient ob = new SmtpClient("smtp.office365.com");
ob.UseDefaultCredentials = false;
ob.EnableSsl = true;
ob.Credentials = new NetworkCredential("*****@*****.**", "83Ruid1987!");
MailMessage obMsg = new MailMessage();
obMsg.From = new MailAddress("*****@*****.**", "Σύστημα Διαχείρισης Ηλεκτροφωτισμού (Do not reply)");
obMsg.To.Add(new MailAddress("*****@*****.**", "Διαχειριστής συστήματος διαχείρισης ηλεκτροφωτισμού"));
obMsg.Subject = "Ενημέρωση για την εργασία "+_id+".";
obMsg.IsBodyHtml = true;
obMsg.Body = emailBody;
ob.Send(obMsg);
}
catch (Exception ex)
{
string msg = ex.ToString();
}
// Send email report to system administrator
}
/// <summary>
/// Executing API calls
/// </summary>
/// <param name="payLoad"></param>
/// <param name="httpRequest"></param>
/// <returns>A string containing the response from the remote host.</returns>
public string Execute(string payLoad, HttpWebRequest httpRequest)
{
int retriesConfigured = config.ContainsKey(BaseConstants.HttpConnectionRetryConfig) ?
Convert.ToInt32(config[BaseConstants.HttpConnectionRetryConfig]) : 0;
int retries = 0;
// Reset the request & response details
this.RequestDetails.Reset();
this.ResponseDetails.Reset();
// Store the request details
this.RequestDetails.Body = payLoad;
this.RequestDetails.Headers = httpRequest.Headers;
this.RequestDetails.Url = httpRequest.RequestUri.AbsoluteUri;
this.RequestDetails.Method = httpRequest.Method;
try
{
do
{
if (retries > 0)
{
logger.Info("Retrying....");
httpRequest = CopyRequest(httpRequest, config, httpRequest.RequestUri.ToString());
this.RequestDetails.RetryAttempts++;
}
try
{
switch (httpRequest.Method)
{
case "POST":
case "PUT":
case "PATCH":
using (StreamWriter writerStream = new StreamWriter(httpRequest.GetRequestStream()))
{
writerStream.Write(payLoad);
writerStream.Flush();
writerStream.Close();
if (ConfigManager.IsLiveModeEnabled(config))
{
logger.Debug("Request details are hidden in live mode.");
}
else
{
logger.Debug(payLoad);
}
}
break;
default:
break;
}
using (WebResponse responseWeb = httpRequest.GetResponse())
{
// Store the response information
this.ResponseDetails.Headers = responseWeb.Headers;
if(responseWeb is HttpWebResponse)
{
this.ResponseDetails.StatusCode = ((HttpWebResponse)responseWeb).StatusCode;
}
using (StreamReader readerStream = new StreamReader(responseWeb.GetResponseStream()))
{
this.ResponseDetails.Body = readerStream.ReadToEnd().Trim();
if (ConfigManager.IsLiveModeEnabled(config))
{
logger.Debug("Response details are hidden in live mode.");
}
else
{
logger.Debug("Service response: ");
logger.Debug(this.ResponseDetails.Body);
}
return this.ResponseDetails.Body;
}
}
}
catch (WebException ex)
{
// If provided, get and log the response from the remote host.
var response = string.Empty;
if (ex.Response != null)
{
using (var readerStream = new StreamReader(ex.Response.GetResponseStream()))
{
response = readerStream.ReadToEnd().Trim();
logger.Error("Error response:");
logger.Error(response);
}
}
logger.Error(ex.Message);
ConnectionException rethrowEx = null;
// Protocol errors indicate the remote host received the
// request, but responded with an error (usually a 4xx or
// 5xx error).
if (ex.Status == WebExceptionStatus.ProtocolError)
{
var httpWebResponse = (HttpWebResponse)ex.Response;
// If the HTTP status code is flagged as one where we
// should continue retrying, then ignore the exception
// and continue with the retry attempt.
if(httpWebResponse.StatusCode == HttpStatusCode.GatewayTimeout ||
httpWebResponse.StatusCode == HttpStatusCode.RequestTimeout ||
httpWebResponse.StatusCode == HttpStatusCode.BadGateway)
{
continue;
}
rethrowEx = new HttpException(ex.Message, response, httpWebResponse.StatusCode, ex.Status, httpWebResponse.Headers, httpRequest);
}
else if(ex.Status == WebExceptionStatus.ReceiveFailure ||
ex.Status == WebExceptionStatus.ConnectFailure ||
ex.Status == WebExceptionStatus.KeepAliveFailure)
{
logger.Debug("There was a problem connecting to the server: " + ex.Status.ToString());
continue;
}
else if (ex.Status == WebExceptionStatus.Timeout)
{
// For connection timeout errors, include the connection timeout value that was used.
var message = string.Format("{0} (HTTP request timeout was set to {1}ms)", ex.Message, httpRequest.Timeout);
rethrowEx = new ConnectionException(message, response, ex.Status, httpRequest);
}
else
{
// Non-protocol errors indicate something happened with the underlying connection to the server.
rethrowEx = new ConnectionException("Invalid HTTP response: " + ex.Message, response, ex.Status, httpRequest);
}
if(ex.Response != null && ex.Response is HttpWebResponse)
{
var httpWebResponse = ex.Response as HttpWebResponse;
this.ResponseDetails.StatusCode = httpWebResponse.StatusCode;
this.ResponseDetails.Headers = httpWebResponse.Headers;
}
this.ResponseDetails.Exception = rethrowEx;
throw rethrowEx;
}
} while (retries++ < retriesConfigured);
}
catch (PayPalException)
{
// Rethrow any PayPalExceptions since they already contain the
// details of the exception.
throw;
}
catch (System.Exception ex)
{
// Repackage any other exceptions to give a bit more context to
// the caller.
throw new PayPalException("Exception in PayPal.HttpConnection.Execute(): " + ex.Message, ex);
}
// If we've gotten this far, it means all attempts at sending the
// request resulted in a failed attempt.
throw new PayPalException("Retried " + retriesConfigured + " times.... Exception in PayPal.HttpConnection.Execute(). Check log for more details.");
}
public static PythonRemoteDebugProcess Connect(PythonRemoteDebugPort port) {
PythonRemoteDebugProcess process = null;
// Connect to the remote debugging server and obtain process information. If any errors occur, display an error dialog, and keep
// trying for as long as user clicks "Retry".
while (true) {
Stream stream = null;
ConnectionException connEx = null;
try {
// Process information is not sensitive, so ignore any SSL certificate errors, rather than bugging the user with warning dialogs.
stream = PythonRemoteProcess.Connect(port.Uri, false);
} catch (ConnectionException ex) {
connEx = ex;
}
using (stream) {
if (stream != null) {
try {
stream.Write(PythonRemoteProcess.InfoCommandBytes);
int pid = stream.ReadInt32();
string exe = stream.ReadString();
string username = stream.ReadString();
string version = stream.ReadString();
process = new PythonRemoteDebugProcess(port, pid, exe, username, version);
break;
} catch (IOException ex) {
connEx = new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
}
}
if (connEx != null) {
string errText;
switch (connEx.Error) {
case ConnErrorMessages.RemoteUnsupportedServer:
errText = string.Format("Remote server at {0} is not a Python Tools for Visual Studio remote debugging server, or its version is not supported.", port.Uri);
break;
case ConnErrorMessages.RemoteSecretMismatch:
errText = string.Format("Secret '{0}' did not match the server secret at {1}. Make sure that the secret is specified correctly in the Qualifier textbox, e.g. tcp://secret@localhost.",
port.Uri.UserInfo, new UriBuilder(port.Uri) { UserName = null, Password = null }.Uri);
break;
case ConnErrorMessages.RemoteSslError:
// User has already got a warning dialog and clicked "Cancel" on that, so no further prompts are needed.
return null;
default:
{
// Azure uses HTTP 503 (Service Unavailable) to indicate that websocket connections are not supported. Show a special error message for that.
var wsEx = connEx.InnerException as WebSocketException;
if (wsEx != null) {
var webEx = wsEx.InnerException as WebException;
if (webEx != null) {
var httpResponse = webEx.Response as HttpWebResponse;
if (httpResponse != null && httpResponse.StatusCode == HttpStatusCode.ServiceUnavailable) {
errText = string.Format("Could not connect to remote Python process at {0}. Make sure that web sockets are enabled for the corresponding web site in Azure portal.", port.Uri);
break;
}
}
}
errText = string.Format("Could not connect to remote Python process at {0}. Make sure that the process is running, and has called ptvsd.enable_attach().", port.Uri);
for (var ex = connEx.InnerException; ex != null; ex = ex.InnerException) {
if (ex.InnerException == null) {
errText += "\r\n\r\nAdditional information:\r\n" + ex.Message;
}
}
break;
}
}
DialogResult dlgRes = MessageBox.Show(errText, null, MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (dlgRes != DialogResult.Retry) {
break;
}
}
}
}
return process;
}
protected override Exception ThrowExceptionHelper(DbConnection conn, DbCommand comm, Exception innerException)
{
if (innerException is SQLiteException)
{
SQLException sqlEx;
var ex = innerException as SQLiteException;
#if Mono
var errorCode = ex.ErrorCode;
#else
var errorCode = ex.ResultCode;
#endif
switch (errorCode)
{
case SQLiteErrorCode.Corrupt:
#if Mono
case SQLiteErrorCode.NotADatabase:
#else
case SQLiteErrorCode.NotADb:
#endif
case SQLiteErrorCode.Perm:
#if Mono
case SQLiteErrorCode.IOErr:
#else
case SQLiteErrorCode.IoErr:
#endif
case SQLiteErrorCode.CantOpen:
case SQLiteErrorCode.Full:
case SQLiteErrorCode.Auth:
{
return new FileAccessException(errorCode.ToString(), innerException);
}
case SQLiteErrorCode.ReadOnly:
{
sqlEx = new ReadOnlyException(null, innerException);
break;
}
case SQLiteErrorCode.Locked:
{
sqlEx = new ConnectionException("file is locked", ex);
break;
}
case SQLiteErrorCode.Constraint:
{
if (innerException.Message.IndexOf("UNIQUE constraint failed", StringComparison.OrdinalIgnoreCase) >= 0)
{
sqlEx = new UniqueConstraintException(null, innerException);
}
else
{
sqlEx = new ConstraintException(null, innerException);
}
break;
}
default:
{
sqlEx = new SQLException(null, innerException);
break;
}
}
if (conn != null)
{
try
{
sqlEx.ConnectionString = conn.ConnectionString;
sqlEx.ConnectionState = conn.State.ToString();
}
catch (ObjectDisposedException)
{
sqlEx.ConnectionState = "Disposed";
}
}
if (comm != null)
{
sqlEx.CommandText = comm.CommandText;
//newEx.Data.Add("CommandText", comm.CommandText);
}
return sqlEx;
}
else
{
return new ORMException(null, innerException);
}
}
