public virtual Stream ProcessAsynchronously(Stream requestStream)
{
DateTime now = DateTime.Now;
string asyncToken = now.Ticks.ToString(CultureInfo.InvariantCulture);
AsyncTask asyncTask = null;
if (requestStream == null)
{
asyncTask = new AsyncTask(this, this.CreateRequestMessage(null), now.AddSeconds(AsyncTask.DefaultDuration));
}
else
{
StreamPipe requestPipe = new StreamPipe();
using (requestPipe.WriteStream)
{
requestStream.CopyTo(requestPipe.WriteStream); // read the input stream to memory
}
var requestMessage = this.CreateRequestMessage(requestPipe.ReadStream);
asyncTask = new AsyncTask(this, requestMessage, now.AddSeconds(AsyncTask.DefaultDuration));
}
AsyncTask.AddTask(asyncToken, asyncTask);
StreamPipe responsePipe = new StreamPipe();
var responseMessage = new ODataResponseMessage(responsePipe.WriteStream, 202); //202 Accepted
responseMessage.PreferenceAppliedHeader().RespondAsync = true;
ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken);
return(responsePipe.ReadStream);
}
/// <summary>
/// Метод чтения данных из канала в потоке
/// </summary>
/// <param name="data"></param>
protected override void ThreadRead(object data)
{
int err = 0;
while (err < 50)
{
int errRead = 0;
string stat = m_ss.ReadString(out errRead);//Чтение из канала
if (errRead > 0)
{
err++;
}
else
{
string[] main_com = stat.Split(';'); //Разбор сообщения
string[] message = new string[0];
switch (main_com[0]) //Переход по основной команде
{
case "Disconnect":
message = main_com[1].Split('='); //Получаем имя канала от клиента
dictServ[message[1]].StartPipe(); //Запускаем канал по имени клиента
if (ConnectClient != null)
{
ConnectClient(this, new ConnectClientEventArgs(message[1]));
}
m_ErrServ = true; //Завершаем цикл и перезапускаем основной канал
break;
case "Connect":
message = main_com[1].Split('='); //Получаем имя клиента
string new_pipe = message[1] + "_" + (dictServ.Count + 1); //добавляем номер п\п
m_ss.WriteString(new_pipe); //отправляем клиенту имя канала для работы
StreamPipe stream = new StreamPipe(new_pipe); //Создаём новый канал для клиента
dictServ.Add(new_pipe, stream); //Добавляем в словарь клиента и поток
//Подписываемся на события
dictServ[new_pipe].ReadMessage += new ReadMessageEventHandler(readMessage);
dictServ[new_pipe].ResServ += new ResServEventHandler(resServ);
break;
default:
//Не известна команда
m_pipeServer.Flush();
m_ss.WriteString("Non command");
break;
}
if (m_ErrServ == true)
{
break;
}
}
}
m_ErrServ = true;
if (ResServ != null)
{
ResServ(this, new ResServEventArgs(m_NamePipe));
}
}
public void AddPipe(StreamPipe connection)
{
if (this._Connections.Add(connection))
{
connection.Start();
}
;
}
public void RemovePipe(StreamPipe connection)
{
if (this._Connections.Remove(connection))
{
connection.Stop();
}
;
}
/// <summary>
/// Uploads the specified file name.
/// </summary>
/// <param name="fileName">Name of the file.</param>
public void Upload(string fileName)
{
tryAgain:
FtpWebResponse response = null;
try
{
Uri url = GetUrl(fileName);
Console.WriteLine("Upload url: " + url);
FtpWebRequest request = CreateRequest(url);
request.Method = WebRequestMethods.Ftp.UploadFile;
request.Credentials = new NetworkCredential(user, password);
using (var requestStream = request.GetRequestStream())
using (var fileStream = File.Open(fileName, FileMode.Open))
{
StreamPipe.Transfer(fileStream, requestStream, bufferSize);
response = (FtpWebResponse)request.GetResponse();
Console.WriteLine(response.StatusDescription);
Console.WriteLine("Upload complete.");
}
}
catch (UriFormatException ex)
{
Console.WriteLine(ex.Message);
}
catch (IOException ex)
{
Console.WriteLine(ex.Message);
}
catch (WebException ex)
{
string status = ((FtpWebResponse)ex.Response).StatusDescription;
if (status.Contains("550"))
{
if (MakeDirectorySafe())
{
goto tryAgain;
}
}
else
{
PrintWebException(ex);
}
}
finally
{
if (response != null)
{
response.Close();
}
}
}
/// <summary>
/// Downloads the specified URL.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="fileName">Name of the file.</param>
public void Download(string url, string fileName)
{
var request = AppCore.GameSettings.ServerSettings.CreateRequest(url);
using (var response = (HttpWebResponse)request.GetResponse())
using (var source = response.GetResponseStream())
using (var destination = File.OpenWrite(fileName))
{
StreamPipe.Transfer(source, destination);
}
}
public virtual Stream Process(Stream requestStream)
{
RequestHandler handler = this.DispatchHandler();
if (handler != null)
{
return(handler.Process(requestStream));
}
StreamPipe pipe = new StreamPipe();
this.Process(this.CreateRequestMessage(requestStream), this.CreateResponseMessage(pipe.WriteStream));
return(pipe.ReadStream);
}
/// <summary>
/// Downloads the specified file name.
/// </summary>
/// <param name="fileName">Name of the file.</param>
public void Download(string fileName)
{
try
{
Uri url = GetUrl(fileName);
Console.WriteLine("Download url: " + url);
FtpWebRequest request = CreateRequest(url);
request.Method = WebRequestMethods.Ftp.DownloadFile;
var downloadResponse = request.GetResponse();
using (var responseStream = downloadResponse.GetResponseStream())
using (var fileStream = File.Create(localdir + fileName))
{
StreamPipe.Transfer(responseStream, fileStream, bufferSize);
}
}
catch (Exception ex)
{
throw new FtpException("Error download file", ex);
}
}
private void AsyncCallback(IAsyncResult ar)
{
DownloadRequestCompleteEventArgs arg;
var downloadRequest = (DownloadRequest)ar.AsyncState;
try
{
using (var response = downloadRequest.Request.EndGetResponse(ar))
using (var source = response.GetResponseStream())
using (var destination = File.OpenWrite(downloadRequest.FileName))
{
StreamPipe.Transfer(source, destination);
}
arg = new DownloadRequestCompleteEventArgs(downloadRequest.FileName, true, null);
}
catch (Exception ex)
{
arg = new DownloadRequestCompleteEventArgs(downloadRequest.FileName, false, ex);
}
if (Downloaded != null)
{
Downloaded(this, arg);
}
}
public virtual Stream ProcessAsynchronously(Stream requestStream)
{
DateTime now = DateTime.Now;
string asyncToken = now.Ticks.ToString(CultureInfo.InvariantCulture);
AsyncTask asyncTask = null;
if (requestStream == null)
{
asyncTask = new AsyncTask(this, this.CreateRequestMessage(null), now.AddSeconds(AsyncTask.DefaultDuration));
}
else
{
StreamPipe requestPipe = new StreamPipe();
using (requestPipe.WriteStream)
{
requestStream.CopyTo(requestPipe.WriteStream); // read the input stream to memory
}
var requestMessage = this.CreateRequestMessage(requestPipe.ReadStream);
asyncTask = new AsyncTask(this, requestMessage, now.AddSeconds(AsyncTask.DefaultDuration));
}
AsyncTask.AddTask(asyncToken, asyncTask);
StreamPipe responsePipe = new StreamPipe();
var responseMessage = new ODataResponseMessage(responsePipe.WriteStream, 202); //202 Accepted
responseMessage.PreferenceAppliedHeader().RespondAsync = true;
ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken);
return responsePipe.ReadStream;
}
public virtual Stream Process(Stream requestStream)
{
RequestHandler handler = this.DispatchHandler();
if (handler != null)
{
return handler.Process(requestStream);
}
StreamPipe pipe = new StreamPipe();
this.Process(this.CreateRequestMessage(requestStream), this.CreateResponseMessage(pipe.WriteStream));
return pipe.ReadStream;
}
private async Task ConnectAsync(CancellationToken cancellationToken)
{
if (IsConnected)
{
return;
}
LastAction = "Waiting for Connecting lock to be free";
var wait = _connectSemaphoreSlim.WaitAsync(cancellationToken);
if (!wait.IsCompletedSuccessfully())
{
await wait.ConfigureAwait(false);
}
try
{
if (IsConnected)
{
return;
}
LastAction = "Connecting";
Interlocked.Increment(ref _reconnectAttempts);
_socket = new RedisSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
SendTimeout = ClientConfig.SendTimeoutMillis,
ReceiveTimeout = ClientConfig.ReceiveTimeoutMillis
};
OptimiseSocket();
if (IPAddress.TryParse(ClientConfig.Host, out var ip))
{
await _socket.ConnectAsync(ip, ClientConfig.Port).ConfigureAwait(false);
}
else
{
var addresses = await Dns.GetHostAddressesAsync(ClientConfig.Host);
await _socket.ConnectAsync(
addresses.FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork),
ClientConfig.Port).ConfigureAwait(false);
}
if (!_socket.Connected)
{
Log.Debug("Socket Connect failed");
_socket.Close();
_socket = null;
return;
}
Log.Debug("Socket Connected");
Stream networkStream = new NetworkStream(_socket);
var redisPipeOptions = GetPipeOptions();
if (ClientConfig.Ssl)
{
_sslStream = new SslStream(networkStream,
false,
ClientConfig.CertificateValidationCallback,
ClientConfig.CertificateSelectionCallback,
EncryptionPolicy.RequireEncryption);
LastAction = "Authenticating SSL Stream as Client";
await _sslStream.AuthenticateAsClientAsync(ClientConfig.Host).ConfigureAwait(false);
if (!_sslStream.IsEncrypted)
{
Dispose();
throw new SecurityException($"Could not establish an encrypted connection to Redis - {ClientConfig.Host}");
}
LastAction = "Creating SSL Stream Pipe";
_pipe = StreamPipe.GetDuplexPipe(_sslStream, redisPipeOptions.SendOptions, redisPipeOptions.ReceiveOptions);
}
else
{
LastAction = "Creating Socket Pipe";
_pipe = SocketPipe.GetDuplexPipe(_socket, redisPipeOptions.SendOptions, redisPipeOptions.ReceiveOptions);
}
IsConnected = true;
if (!string.IsNullOrEmpty(ClientConfig.Password))
{
LastAction = "Authorizing";
await Authorize(cancellationToken);
}
if (ClientConfig.Db != 0)
{
LastAction = "Selecting Database";
await SelectDb(cancellationToken);
}
if (ClientConfig.ClientName != null)
{
LastAction = "Setting Client Name";
await SetClientNameAsync(cancellationToken);
}
}
finally
{
_connectSemaphoreSlim.Release();
}
}
/// <summary>
/// Sends the file.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="mode">The mode.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="content">The content.</param>
/// <param name="mimeType">Type of the MIME.</param>
public static void SendFile(this HttpContext context, SendMode mode, string fileName, Stream content, string mimeType)
{
PrepareResponse(context, mode, fileName, content.Length);
StreamPipe.Transfer(content, context.Response.OutputStream);
ResponseEnd(context.Response);
}
/// <summary>
/// Метод чтения данных из канала в потоке
/// </summary>
/// <param name="data"></param>
protected override void ThreadRead(object data)
{
int err = 0;
int errRead = -1;
string stat = string.Empty
, new_pipe = string.Empty;
string[] main_com = null //Разбор сообщения
//, message = null
;
while (err < 50)
{
errRead = 0;
stat = m_ss.ReadString(out errRead);//Чтение из канала
if (errRead > 0)
{
err++;
}
else
{
//main_com = stat.Split(DELIMETER_MESSAGE_COMMAND);//Разбор сообщения
main_com = stat.Split(DELIMETER_MESSAGE_KEYVALUEPAIR); //Разбор сообщения
//message = new string[0];
if (main_com[0].Equals(COMMAND.Disconnect.ToString()) == true) //Переход по основной команде
{
//message = main_com[1].Split(DELIMETER_MESSAGE_KEYVALUEPAIR);//Получаем имя канала от клиента
//dictServ[message[1]].StartPipe();//Запускаем канал по имени клиента
m_dictStreamPipeClient[main_com[1]].StartPipe();//Запускаем канал по имени клиента
if (!(ConnectClient == null))
{
ConnectClient(this, new ConnectionClientEventArgs(main_com[1]));
}
else
{
;
}
m_ErrServ = ERROR.DISCONNECT;//Завершаем цикл и перезапускаем основной канал
}
else
if (main_com[0].Equals(COMMAND.Connect.ToString()) == true)
{
//message = main_com[1].Split(DELIMETER_MESSAGE_KEYVALUEPAIR);//Получаем имя клиента
new_pipe = main_com[1] + "_" + (m_dictStreamPipeClient.Count + 1); //добавляем номер п\п
m_ss.WriteString(new_pipe); //отправляем клиенту имя канала для работы
StreamPipe stream = new StreamPipe(new_pipe); //Создаём новый канал для клиента
m_dictStreamPipeClient.Add(new_pipe, stream); //Добавляем в словарь клиента и поток
//Подписываемся на события
m_dictStreamPipeClient[new_pipe].ReadMessage += new EventHandler(readMessage);
m_dictStreamPipeClient[new_pipe].ResServ += new EventHandler(resServ);
}
else
{
//Не известна команда
m_pipeServer.Flush();
m_ss.WriteString(MESSAGE_UNRECOGNIZED_COMMAND);
}
if (!(m_ErrServ == ERROR.NO))
{
break;
}
}
}
m_ErrServ = ERROR.ANY;
if (!(ResServ == null))
{
ResServ(this, new ResServEventArgs(m_NamePipe));
}
else
{
;
}
}
