| public EndWaitForConnection ( IAsyncResult asyncResult ) : void | ||
| asyncResult | IAsyncResult | |
| Résultat | void | |
private static IEnumerator<Int32> PipeServerAsyncEnumerator(AsyncEnumerator ae) {
// Each server object performs asynchronous operation on this pipe
using (var pipe = new NamedPipeServerStream(
"Echo", PipeDirection.InOut, -1, PipeTransmissionMode.Message,
PipeOptions.Asynchronous | PipeOptions.WriteThrough)) {
// Asynchronously accept a client connection
pipe.BeginWaitForConnection(ae.End(), null);
yield return 1;
// A client connected, let's accept another client
var aeNewClient = new AsyncEnumerator();
aeNewClient.BeginExecute(PipeServerAsyncEnumerator(aeNewClient),
aeNewClient.EndExecute);
// Accept the client connection
pipe.EndWaitForConnection(ae.DequeueAsyncResult());
// Asynchronously read a request from the client
Byte[] data = new Byte[1000];
pipe.BeginRead(data, 0, data.Length, ae.End(), null);
yield return 1;
// The client sent us a request, process it
Int32 bytesRead = pipe.EndRead(ae.DequeueAsyncResult());
// Just change to upper case
data = Encoding.UTF8.GetBytes(
Encoding.UTF8.GetString(data, 0, bytesRead).ToUpper().ToCharArray());
// Asynchronously send the response back to the client
pipe.BeginWrite(data, 0, data.Length, ae.End(), null);
yield return 1;
// The response was sent to the client, close our side of the connection
pipe.EndWrite(ae.DequeueAsyncResult());
} // Close happens in a finally block now!
}
public async void SendMessageAsync()
{
try
{
using (var pipe = new NamedPipeServerStream(verb, PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
using (var stream = new StreamWriter(pipe))
{
var connectionTask = Task.Factory.FromAsync(pipe.BeginWaitForConnection, pipe.EndWaitForConnection, null);
var timeoutTask = Task.Delay(2000);
var firstTask = await Task.WhenAny(connectionTask, timeoutTask);
if (firstTask == timeoutTask)
{
pipe.EndWaitForConnection(connectionTask);
return;
}
stream.AutoFlush = true;
await stream.WriteLineAsync(selectedFile);
}
}
catch (Exception exception)
{
//OnSendMessageException(pipeName, new MessengerExceptionEventArgs(exception));
}
}
private void ServerLoop()
{
while (_stopRequired)
{
_allDone.Reset();
var pipeStream = new NamedPipeServerStream(PipeName, PipeDirection.InOut, -1, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
pipeStream.BeginWaitForConnection(asyncResult =>
{
pipeStream.EndWaitForConnection(asyncResult);
_allDone.Set();
var thread = new Thread(ProcessClientThread);
thread.Start(pipeStream);
}, null);
_allDone.WaitOne();
}
}
static void SetupPipeWait(App app)
{
var pipe = new NamedPipeServerStream(IPCName, PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
pipe.BeginWaitForConnection(result =>
{
pipe.EndWaitForConnection(result);
var buf = new byte[sizeof(int)];
pipe.Read(buf, 0, buf.Length);
var len = BitConverter.ToInt32(buf, 0);
buf = new byte[len];
pipe.Read(buf, 0, buf.Length);
var commandLine = Coder.BytesToString(buf, Coder.CodePage.UTF8);
app.Dispatcher.Invoke(() => app.CreateWindowsFromArgs(commandLine));
SetupPipeWait(app);
}, null);
}
void pipeServerThread(object o)
{
NamedPipeServerStream pipeServer = null;
try
{
while (true)
{
pipeServer = new NamedPipeServerStream(
this.ServerName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
IAsyncResult async = pipeServer.BeginWaitForConnection(null, null);
int index = WaitHandle.WaitAny(new WaitHandle[] { async.AsyncWaitHandle, closeApplicationEvent });
switch (index)
{
case 0:
pipeServer.EndWaitForConnection(async);
using (StreamReader sr = new StreamReader(pipeServer))
using (StreamWriter sw = new StreamWriter(pipeServer))
{
this.Recived(this, new ServerReciveEventArgs(sr, sw));
}
if (pipeServer.IsConnected)
{
pipeServer.Disconnect();
}
break;
case 1:
return;
}
}
}
finally
{
if (pipeServer != null)
{
pipeServer.Close();
}
}
}
/// <summary>
/// Launches the specifies process and sends the dto object to it using a named pipe
/// </summary>
/// <param name="dto">Dto object to send</param>
/// <param name="processStartInfo">Process info for the process to start</param>
/// <param name="syncProcessName">Name of the pipe to write to</param>
/// <returns>The started process</returns>
public static Process LaunchProcessAndSendDto(NauDto dto, ProcessStartInfo processStartInfo, string syncProcessName)
{
Process p;
using (NamedPipeServerStream pipe = new NamedPipeServerStream(syncProcessName, PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
{
p = Process.Start(processStartInfo);
if (p == null)
{
throw new ProcessStartFailedException("The process failed to start");
}
var asyncResult = pipe.BeginWaitForConnection(null, null);
if (asyncResult.AsyncWaitHandle.WaitOne(PIPE_TIMEOUT))
{
pipe.EndWaitForConnection(asyncResult);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(pipe, dto);
}
else if (p.HasExited)
{
Type exceptionType = Marshal.GetExceptionForHR(p.ExitCode).GetType();
throw new TimeoutException(string.Format("The NamedPipeServerStream timed out waiting for a named pipe connection, " +
"but the process has exited with exit code: {0} ({1})", p.ExitCode, exceptionType.FullName));
}
else
{
throw new TimeoutException("The NamedPipeServerStream timed out waiting for a named pipe connection.");
}
}
return p;
}
public ShellCommandHandler(CommandHandler cmdHandler)
{
pipeServer = new NamedPipeServerStream("sciGitPipe", PipeDirection.In, 1, PipeTransmissionMode.Byte,
PipeOptions.Asynchronous);
pipeThread = new Thread(() => {
while (true) {
try {
var ar = pipeServer.BeginWaitForConnection(null, null);
pipeServer.EndWaitForConnection(ar);
var ss = new StreamString(pipeServer);
string verb = ss.ReadString();
string filename = ss.ReadString();
cmdHandler(verb, filename);
pipeServer.Disconnect();
} catch (ObjectDisposedException) {
break;
} catch (IOException) {
break;
} catch (Exception e) {
Logger.LogException(e);
}
}
});
}
public void Initialize()
{
if (initialized)
return;
else
initialized = true;
// 初始化RenderControl
KillExistingProcess();
// 启动Pipe
// NOTE 必须设置 Asynchronous
pipeServer = new NamedPipeServerStream(
"testpipe",
PipeDirection.InOut,
1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
inBuffer = new byte[1024];
LogManager.Instance.Log("开始异步等待管道连接");
pipeServer.BeginWaitForConnection(ar =>
{
pipeServer.EndWaitForConnection(ar);
LogManager.Instance.Log("管道已连接");
pipeServer.BeginRead(inBuffer, 0, pipeServer.InBufferSize, onClientDataReceived, pipeServer);
}, pipeServer);
// ProcessStartInfo info = new ProcessStartInfo(ConfigManager.Instance.Get("RenderAppPath"));
ProcessStartInfo info = new ProcessStartInfo(System.IO.Path.Combine(Directory.GetCurrentDirectory(), "./SpineRenderer/SpineRenderer.exe"));
info.UseShellExecute = true;
info.Arguments = " -popupwindow";
// NOTE Hidden 会造成没有窗口句柄 unityProcess.MainWindowHandle == IntPtr.Zero
// info.WindowStyle = ProcessWindowStyle.Minimized;
// info.WindowStyle = ProcessWindowStyle.Normal;
// info.WindowStyle = ProcessWindowStyle.Hidden;
renderAppProcess = System.Diagnostics.Process.Start(info);
// Wait for process to be created and enter idle condition
LogManager.Instance.Log("开始等待渲染程序空闲");
// NOTE thy 方法A在Win7上不管用，方法B在Win7/Win8上都OK
// WaitForInputIdle 并不保证窗口句柄准备好
// 方法-A
// renderAppProcess.WaitForInputIdle(5000);
// 方法-B
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
while (renderAppProcess.MainWindowHandle == IntPtr.Zero)
{
System.Threading.Thread.Sleep(100);
// stopWatch.ElapsedMilliseconds >
}
if (renderAppProcess.HasExited)
{
LogManager.Instance.Warn("内嵌程序已经退出");
}
else
{
LogManager.Instance.Log("内嵌程序初始化完成");
LogManager.Instance.Log("检查内嵌程序句柄是否存在: " + renderAppProcess.MainWindowHandle.ToString());
}
}
public async Task<Stream> RunAsync(Stream output, string query, params string[] sqlArguments)
{
NamedPipeServerStream pipeServerStream = new NamedPipeServerStream("SqlBcpWrapper" + GetHashCode(), PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
pipeServerStream.BeginWaitForConnection(e =>
{
pipeServerStream.EndWaitForConnection(e);
while (pipeServerStream.IsConnected && !pipeServerStream.IsMessageComplete)
{
}
pipeServerStream.CopyTo(output);
output.Seek(0, SeekOrigin.Begin);
pipeServerStream.Disconnect();
pipeServerStream.Close();
}, this);
RunInternal("\\\\.\\pipe\\SqlBcpWrapper" + GetHashCode(), query, sqlArguments, null, null);
await Task.Run(() =>
{
while (pipeServerStream.IsConnected && !pipeServerStream.IsMessageComplete)
{
}
});
return output;
}
/// <summary>
/// Initialises the named pipe server and waits for a connection
/// </summary>
/// <param name="pipe">The name of the pipe to create</param>
/// <returns>True if a connection is received. Otherwise false.</returns>
public bool Init(string pipe)
{
bool OK = Disconnect();
if (OK)
{
try
{
ThePipe = new NamedPipeServerStream(pipe, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
ThePipe.ReadMode = PipeTransmissionMode.Byte;
ThePipe.BeginWaitForConnection(new AsyncCallback(delegate(IAsyncResult result)
{
try
{
ThePipe.EndWaitForConnection(result);
if (OnConnected != null)
{
OnConnected();
}
}
catch
{
//Ignore as probably error while terminating
}
}), null);
}
catch
{
OK = false;
ThePipe = null;
}
}
return OK;
}
private async Task ReadNamedPipeAsync()
{
string pipeID = pID.ToString();
using (NamedPipeServerStream pipeServer = new NamedPipeServerStream("luaPipeR" + pipeID, PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
{
await Task.Factory.FromAsync((cb, state) => pipeServer.BeginWaitForConnection(cb, state), ar => pipeServer.EndWaitForConnection(ar), null);
using (StreamReader pipeReader = new StreamReader(pipeServer))
{
await TaskScheduler.Default;
while (this.keepReadPipeOpen)
{
string command = await pipeReader.ReadLineAsync();
switch (command)
{
case "BreakpointHit":
{
debugThread.SourceFile = await pipeReader.ReadLineAsync();
debugThread.Line = uint.Parse(await pipeReader.ReadLineAsync());
debugThread.FuncName = await pipeReader.ReadLineAsync();
// Receive Callstack
debugThread.FrameCount = int.Parse(await pipeReader.ReadLineAsync());
List<Frame> frames = new List<Frame>(debugThread.FrameCount);
for (int stackLineIndex = 0; stackLineIndex < debugThread.FrameCount; stackLineIndex++)
{
string func = await pipeReader.ReadLineAsync();
string source = await pipeReader.ReadLineAsync();
string line = await pipeReader.ReadLineAsync();
frames.Add(new Frame(func, source, line));
}
debugThread.StackFrames = frames;
int numberToRead = int.Parse(await pipeReader.ReadLineAsync());
List<Variable> variables = new List<Variable>(numberToRead);
for (int localIndex = 0; localIndex < numberToRead; localIndex++)
{
variables.Add(new Variable(await pipeReader.ReadLineAsync(), await pipeReader.ReadLineAsync(), await pipeReader.ReadLineAsync()));
}
debugThread.NumberOfLocals = numberToRead;
debugThread.Locals = variables;
AD7BreakpointEvent.Send(this, breakpointManager.GetBoundBreakpoint(debugThread.SourceFile + debugThread.Line));
break;
}
case "BreakpointBound":
string fileandline = await pipeReader.ReadLineAsync();
AD7BoundBreakpoint boundbp = breakpointManager.GetBoundBreakpoint(fileandline);
AD7BreakpointBoundEvent boundBreakpointEvent = new AD7BreakpointBoundEvent(boundbp);
Send(boundBreakpointEvent, AD7BreakpointBoundEvent.IID, this);
break;
case "StepComplete":
{
debugThread.FrameCount = 1;
debugThread.SourceFile = await pipeReader.ReadLineAsync();
debugThread.Line = uint.Parse(await pipeReader.ReadLineAsync());
debugThread.FuncName = await pipeReader.ReadLineAsync();
// Receive Callstack
debugThread.FrameCount = int.Parse(await pipeReader.ReadLineAsync());
List<Frame> frames = new List<Frame>(debugThread.FrameCount);
for (int stackLineIndex = 0; stackLineIndex < debugThread.FrameCount; stackLineIndex++)
{
string func = await pipeReader.ReadLineAsync();
string source = await pipeReader.ReadLineAsync();
string line = await pipeReader.ReadLineAsync();
frames.Add(new Frame(func, source, line));
}
debugThread.StackFrames = frames;
int numberToRead = int.Parse(await pipeReader.ReadLineAsync());
List<Variable> variables = new List<Variable>(numberToRead);
for (int localIndex = 0; localIndex < numberToRead; localIndex++)
{
variables.Add(new Variable(await pipeReader.ReadLineAsync(), await pipeReader.ReadLineAsync(), await pipeReader.ReadLineAsync()));
}
debugThread.NumberOfLocals = numberToRead;
debugThread.Locals = variables;
Send(new AD7StepCompleteEvent(), AD7StepCompleteEvent.IID, this);
break;
}
}
}
}
}
}
private void waitForAdditionalInstances(string[] args)
{
var accumulatedArgs = new List<string>(args);
while (true)
{
var signal = new ManualResetEvent(false);
using (var pipeServer = new NamedPipeServerStream(ipcNamedPipeGuid, PipeDirection.In, -1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
{
pipeServer.BeginWaitForConnection(x =>
{
// if timed out, stop waiting for a connection
if (signal.WaitOne(0))
{
signal.Close();
return;
}
pipeServer.EndWaitForConnection(x);
signal.Set();
}, null);
// no client connected to the pipe within the Timeout period
if (!signal.WaitOne(Timeout, true))
{
signal.Set();
break;
}
using (var sr = new StreamReader(pipeServer))
{
int length = Convert.ToInt32(sr.ReadLine());
for (int i = 0; i < length; ++i)
accumulatedArgs.Add(sr.ReadLine());
}
}
// new args have been added to accumulatedArgs, continue loop to listen for another client
}
ipcMutex.Close();
Launching(this, new SingleInstanceEventArgs(accumulatedArgs.ToArray()));
}
private static BuildResult OutOfProcessBuild (Dictionary<string, object> arguments, int startupTimeoutMs = 5000) {
var jss = new JavaScriptSerializer {
MaxJsonLength = 1024 * 1024 * 64
};
var argsJson = jss.Serialize(arguments);
var pipeId = String.Format("JSIL.Build{0:X4}", (new Random()).Next());
Console.Error.WriteLine("// Starting out-of-process solution build with ID '{0}'...", pipeId);
using (var pipe = new NamedPipeServerStream(
pipeId, PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous
)) {
var psi = new ProcessStartInfo {
FileName = Process.GetCurrentProcess().MainModule.FileName,
Arguments = String.Format("--buildSolution {0}", pipeId),
WorkingDirectory = Environment.CurrentDirectory,
CreateNoWindow = false,
UseShellExecute = false,
ErrorDialog = false
};
var childProcess = Process.Start(psi);
if (childProcess == null)
throw new InvalidOperationException("Failed to start child process");
var connectedEvent = new ManualResetEventSlim(false);
var exitedEvent = new ManualResetEventSlim(false);
try {
var connectAR = pipe.BeginWaitForConnection((_) => connectedEvent.Set(), null);
try {
childProcess.Exited += (s, e) => exitedEvent.Set();
if (childProcess.HasExited)
exitedEvent.Set();
} catch {
}
WaitHandle.WaitAny(
new[] { connectedEvent.WaitHandle, exitedEvent.WaitHandle }, startupTimeoutMs
);
if (connectedEvent.IsSet) {
pipe.EndWaitForConnection(connectAR);
} else if (exitedEvent.IsSet) {
Console.Error.WriteLine("// Out-of-process solution build terminated unexpectedly with code {0}!", childProcess.ExitCode);
Environment.Exit(1);
} else {
Console.Error.WriteLine("// Out-of-process solution build timed out!");
Environment.Exit(2);
}
using (var sr = new StreamReader(pipe))
using (var sw = new StreamWriter(pipe)) {
sw.WriteLine(argsJson);
sw.Flush();
pipe.Flush();
pipe.WaitForPipeDrain();
var resultJson = sr.ReadLine();
var buildResult = jss.Deserialize<BuildResult>(resultJson);
Console.Error.WriteLine("// Out-of-process solution build completed successfully.");
return buildResult;
}
} finally {
try {
if (!childProcess.HasExited)
childProcess.Kill();
} catch {
}
childProcess.Dispose();
}
}
}
public bool StartServer(string strEventName, string strPipeName, Action<CMD_STREAM, CMD_STREAM> pfnCmdProc)
{
if (pfnCmdProc == null || strEventName.Length == 0 || strPipeName.Length == 0)
{
return false;
}
if (m_ServerThread != null)
{
return false;
}
m_StopFlag = false;
m_PulseEvent = new AutoResetEvent(false);
m_ServerThread = new Thread(new ThreadStart(() =>
{
using (EventWaitHandle eventConnect = new EventWaitHandle(false, EventResetMode.AutoReset, strEventName))
using (NamedPipeServerStream pipe = new NamedPipeServerStream(
strPipeName.Substring(strPipeName.StartsWith("\\\\.\\pipe\\", StringComparison.OrdinalIgnoreCase) ? 9 : 0),
PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
{
while (m_StopFlag == false)
{
pipe.BeginWaitForConnection(asyncResult =>
{
try
{
if (m_StopFlag == false)
{
pipe.EndWaitForConnection(asyncResult);
m_PulseEvent.Set();
}
}
catch (ObjectDisposedException)
{
}
}, null);
eventConnect.Set();
m_PulseEvent.WaitOne();
if (pipe.IsConnected)
{
try
{
byte[] bHead = new byte[8];
if (pipe.Read(bHead, 0, 8) == 8)
{
CMD_STREAM stCmd = new CMD_STREAM();
stCmd.uiParam = BitConverter.ToUInt32(bHead, 0);
stCmd.uiSize = BitConverter.ToUInt32(bHead, 4);
stCmd.bData = stCmd.uiSize == 0 ? null : new byte[stCmd.uiSize];
if (stCmd.uiSize == 0 || pipe.Read(stCmd.bData, 0, stCmd.bData.Length) == stCmd.bData.Length)
{
CMD_STREAM stRes = new CMD_STREAM();
pfnCmdProc.Invoke(stCmd, stRes);
if (stRes.uiParam == (uint)ErrCode.CMD_NEXT)
{
// Emun用の繰り返しは対応しない
throw new InvalidOperationException();
}
else if (stRes.uiParam != (uint)ErrCode.CMD_NO_RES)
{
BitConverter.GetBytes(stRes.uiParam).CopyTo(bHead, 0);
BitConverter.GetBytes(stRes.uiSize).CopyTo(bHead, 4);
pipe.Write(bHead, 0, 8);
if (stRes.uiSize != 0 && stRes.bData != null && stRes.bData.Length >= stRes.uiSize)
{
pipe.Write(stRes.bData, 0, (int)stRes.uiSize);
}
}
}
}
pipe.WaitForPipeDrain();
pipe.Disconnect();
}
catch
{
// Read & Write 中に切断されると例外が起きるはずなので一応 catch しておく
}
}
}
}
}));
m_ServerThread.Start();
return true;
}
public override async Task<IAsyncTransport> CreateAsync(Address address)
{
NamedPipeServerStream server = new NamedPipeServerStream(address.Path, PipeDirection.InOut, 4,
PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
#if DOTNET
await server.WaitForConnectionAsync();
#else
await Task.Factory.FromAsync(
(c, s) => server.BeginWaitForConnection(c, s),
(r) => server.EndWaitForConnection(r),
null);
#endif
return new NamedPipeTransport(server);
}
private void doServerWork()
{
IsRunning = true;
Helper.Logging.OnLogMessage("Starting CWSRestartServer for process communication", ServerService.MessageType.Info);
PipeSecurity ps = new PipeSecurity();
ps.AddAccessRule(new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null), PipeAccessRights.ReadWrite | PipeAccessRights.CreateNewInstance, System.Security.AccessControl.AccessControlType.Allow));
serverStream = new NamedPipeServerStream(CWSProtocol.Settings.SERVERNAME, PipeDirection.InOut, 254, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, 1024, 1024, ps);
while (!_shouldStop)
{
wait = new EventWaitHandle(false, EventResetMode.ManualReset);
serverStream.BeginWaitForConnection(ar =>
{
try
{
serverStream.EndWaitForConnection(ar);
if (serverStream.IsConnected)
{
//Helper.Logging.OnLogMessage("Module connected", ServerService.MessageType.Info);
StreamReader sr = new StreamReader(serverStream, System.Text.Encoding.UTF8, true, 2048, true);
string message = sr.ReadLine();
if (message != null)
{
string[] messages = message.Split(new string[] { " " }, 3, StringSplitOptions.None);
if (messages.Count() == 3 || messages.Count() == 2)
{
if (messages.Count() == 2 || messages.Count() == 3)
{
CWSProtocol.Commands.Action a = (CWSProtocol.Commands.Action)Enum.Parse(typeof(CWSProtocol.Commands.Action), messages[0]);
CWSProtocol.Commands.Command c = (CWSProtocol.Commands.Command)Enum.Parse(typeof(CWSProtocol.Commands.Command), messages[1]);
message = (messages.Count() == 3) ? messages[2] : "";
switch (a)
{
case CWSProtocol.Commands.Action.GET:
switch (c)
{
case CWSProtocol.Commands.Command.IDENTIFY:
Helper.Logging.OnLogMessage(String.Format("{0} said hello", message), ServerService.MessageType.Info);
sendReply(CWSProtocol.Commands.Command.ACK, "", serverStream);
break;
case CWSProtocol.Commands.Command.STATISTICS:
//Helper.Logging.OnLogMessage("Statistics were requested by an external module", ServerService.MessageType.Info);
sendReply(CWSProtocol.Commands.Command.STATISTICS, String.Format("ALIVE {0}", ServerService.Validator.IsRunning()), serverStream);
if (Statistics != null && Statistics.Enabled)
{
sendReply(CWSProtocol.Commands.Command.STATISTICS, String.Format("TOTAL {0}", Statistics.Players.Count), serverStream);
sendReply(CWSProtocol.Commands.Command.STATISTICS, String.Format("CURRENT {0}", Statistics.ConnectedPlayers.Count), serverStream);
sendReply(CWSProtocol.Commands.Command.STATISTICS, String.Format("RUNTIME {0:00}:{1:00}:{2:00}", Statistics.Runtime.TotalHours, Statistics.Runtime.Minutes, Statistics.Runtime.Seconds), serverStream);
sendReply(CWSProtocol.Commands.Command.STATISTICS, String.Format("ENABLED {0}", Statistics.Enabled), serverStream);
if (Statistics.StatisticsDB != null)
sendReply(CWSProtocol.Commands.Command.STATISTICS, String.Format("STATISTICSFILE {0}", Statistics.StatisticsDB.DatabaseFile), serverStream);
}
sendReply(CWSProtocol.Commands.Command.ENDSTATISTICS, "", serverStream);
break;
case CWSProtocol.Commands.Command.START:
ServerService.Helper.General.StartServer();
break;
case CWSProtocol.Commands.Command.STOP:
ServerService.Helper.General.SendQuit();
break;
case CWSProtocol.Commands.Command.RESTART:
ServerService.Helper.General.RestartServer();
break;
case CWSProtocol.Commands.Command.KILL:
ServerService.Helper.General.KillServer();
break;
case CWSProtocol.Commands.Command.WATCHER:
sendReply(CWSProtocol.Commands.Command.WATCHER, String.Format("ENABLED {0}", Helper.Watcher.Instance.IsRunning), serverStream);
sendReply(CWSProtocol.Commands.Command.WATCHER, String.Format("BLOCKED {0}", Helper.Watcher.Instance.IsBlocked), serverStream);
sendReply(CWSProtocol.Commands.Command.WATCHER, String.Format("TIMEOUT {0}", Helper.Watcher.Instance.IntervallSeconds.ToString()), serverStream);
sendReply(CWSProtocol.Commands.Command.WATCHER, String.Format("CHECKINTERNET {0}", ServerService.Helper.Settings.Instance.CheckInternet), serverStream);
sendReply(CWSProtocol.Commands.Command.WATCHER, String.Format("CHECKLAN {0}", ServerService.Helper.Settings.Instance.CheckLAN), serverStream);
sendReply(CWSProtocol.Commands.Command.WATCHER, String.Format("CHECKLOOPBACK {0}", ServerService.Helper.Settings.Instance.CheckLoopback), serverStream);
break;
case CWSProtocol.Commands.Command.LOG:
if (GetLog != null)
{
List<Helper.LogMessage> logEntries = GetLog();
try
{
StreamWriter writer = new StreamWriter(serverStream, System.Text.Encoding.UTF8, 2048, true);
foreach (Helper.LogMessage m in logEntries)
{
if (m != null)
{
StringBuilder b = new StringBuilder();
b.AppendFormat("{0:HH:mm:ss}", m.Timestamp);
b.Append(" ");
b.Append(m.MessageType.ToString());
b.Append(": ");
b.Append(m.Message);
b.Append(Environment.NewLine);
writer.WriteLine(b.ToString());
}
}
writer.Close();
}
catch (IOException ex)
{
if (Debugger.IsAttached)
{
Debugger.Break();
Debugger.Log(1, "server", ex.Message);
}
}
}
else
{
sendReply(CWSProtocol.Commands.Command.LOG, "", serverStream);
}
break;
case CWSProtocol.Commands.Command.CONNECTED:
List<PlayerInfo> connected;
if (Statistics.Enabled && (connected = new List<PlayerInfo>(Statistics.ConnectedPlayers)).Count > 0)
{
StreamWriter writer = new StreamWriter(serverStream, System.Text.Encoding.UTF8, 2048, true);
foreach (PlayerInfo ip in connected)
writer.WriteLine(ip.Address.ToString());
writer.Close();
}
else
{
StreamWriter writer = new StreamWriter(serverStream, System.Text.Encoding.UTF8, 2048, true);
writer.WriteLine("");
writer.Close();
}
break;
case CWSProtocol.Commands.Command.ACCESSLIST:
List<AccessListEntry> entries = new List<AccessListEntry>(AccessControl.Instance.AccessList);
if ((Statistics.Enabled || ServerService.Helper.Settings.Instance.ExternalAccessControl) && entries.Count > 0)
{
StreamWriter writer = new StreamWriter(serverStream, System.Text.Encoding.UTF8, 2048, true);
foreach (AccessListEntry e in entries)
writer.WriteLine(e.ToString());
writer.Close();
}
else
{
StreamWriter writer = new StreamWriter(serverStream, System.Text.Encoding.UTF8, 2048, true);
writer.WriteLine("");
writer.Close();
}
break;
case CWSProtocol.Commands.Command.ACCESSMODE:
sendReply(CWSProtocol.Commands.Command.ACCESSMODE, AccessControl.Instance.Mode.ToString(), serverStream);
break;
case CWSProtocol.Commands.Command.PLAYERSDATABASE:
Helper.Settings.Instance.SetUpPlayersdatabase();
sendReply(CWSProtocol.Commands.Command.PLAYERSDATABASE, Helper.Settings.Instance.KnownPlayersLocation, serverStream);
break;
case CWSProtocol.Commands.Command.PLAYERIDENTIFICATION:
if (Helper.Settings.Instance.PlayeridentificationEnabled)
sendReply(CWSProtocol.Commands.Command.PLAYERIDENTIFICATION, "ENABLED", serverStream);
else
sendReply(CWSProtocol.Commands.Command.PLAYERIDENTIFICATION, "DISABLED", serverStream);
break;
case CWSProtocol.Commands.Command.PREMIUMSLOTS:
if (Helper.Settings.Instance.PremiumslotsEnabled)
sendReply(CWSProtocol.Commands.Command.PREMIUMSLOTS, "ENABLED", serverStream);
else
sendReply(CWSProtocol.Commands.Command.PREMIUMSLOTS, "DISABLED", serverStream);
break;
case CWSProtocol.Commands.Command.PREMIUMDATABASE:
Helper.Settings.Instance.SetUpPremiumdatabase();
sendReply(CWSProtocol.Commands.Command.PREMIUMDATABASE, Helper.Settings.Instance.PremiumLocation, serverStream);
break;
}
break;
case CWSProtocol.Commands.Action.POST:
switch (c)
{
case CWSProtocol.Commands.Command.LOG:
if (String.Compare(message, "clear", true) == 0)
{
if (ClearLog != null)
ClearLog();
}
break;
case CWSProtocol.Commands.Command.WATCHER:
{
if (String.Compare(message, "start", true) == 0 && !Helper.Watcher.Instance.IsRunning)
Helper.Watcher.Instance.Start();
else if (String.Compare(message, "stop", true) == 0 && Helper.Watcher.Instance.IsRunning && !Helper.Watcher.Instance.IsBlocked)
Helper.Watcher.Instance.Stop();
else
{
string[] parts = message.Split(new string[] { " " }, 2, StringSplitOptions.None);
if (parts.Length == 2)
{
switch (parts[0])
{
case "TIMEOUT":
UInt32 seconds;
if (UInt32.TryParse(parts[1], out seconds))
Helper.Watcher.Instance.IntervallSeconds = seconds;
break;
case "ACCESS":
parts = parts[1].Split(' ');
if (parts.Length == 6)
{
for (int i = 0; i < parts.Length; i = i + 2)
{
bool check;
if (Boolean.TryParse(parts[i + 1], out check))
{
switch (parts[i])
{
case "CHECKINTERNET":
ServerService.Helper.Settings.Instance.CheckInternet = check;
break;
case "CHECKLAN":
ServerService.Helper.Settings.Instance.CheckLAN = check;
break;
case "CHECKLOOPBACK":
ServerService.Helper.Settings.Instance.CheckLoopback = check;
break;
}
}
}
}
break;
}
}
}
}
break;
case CWSProtocol.Commands.Command.KICK:
IPAddress ip;
if (IPAddress.TryParse(message, out ip))
{
ServerService.Helper.DisconnectWrapper.CloseRemoteIP(ip.ToString());
}
break;
case CWSProtocol.Commands.Command.ACCESSLIST:
string line;
List<AccessListEntry> entries = new List<AccessListEntry>();
AccessListEntry tmp;
if (AccessControl.GenerateEntryFromString(message, out tmp))
entries.Add(tmp);
while ((line = sr.ReadLine()) != null)
{
string[] parts = line.Split(new string[] { " " }, 3, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 3 && parts[0] == CWSProtocol.Commands.Action.POST.ToString() && parts[1] == CWSProtocol.Commands.Command.ACCESSLIST.ToString() && !String.IsNullOrEmpty(parts[2]))
{
if (AccessControl.GenerateEntryFromString(parts[2], out tmp))
entries.Add(tmp);
}
}
AccessControl.Instance.SetAccessList(new System.Collections.ObjectModel.ObservableCollection<AccessListEntry>(entries));
break;
case CWSProtocol.Commands.Command.ACCESSMODE:
AccessMode mode;
if (System.Enum.TryParse<AccessMode>(message, out mode))
AccessControl.Instance.Mode = mode;
break;
case CWSProtocol.Commands.Command.PRESET:
string[] content = message.Split(new string[] { " " }, 2, StringSplitOptions.RemoveEmptyEntries);
if (content.Length == 2 && (content[0] == "DELETE" || content[0] == "PERSISTENT") && File.Exists(content[1]))
{
Helper.Settings.Instance.LoadPreset(content[1]);
if (content[0] == "DELETE")
File.Delete(content[1]);
}
break;
case CWSProtocol.Commands.Command.PLAYERIDENTIFICATION:
if (message.ToLowerInvariant() == "enable")
Helper.Settings.Instance.PlayeridentificationEnabled = true;
else
Helper.Settings.Instance.PlayeridentificationEnabled = false;
Helper.Logging.OnLogMessage("Now ready to identify players...", ServerService.MessageType.Info);
break;
case CWSProtocol.Commands.Command.PREMIUMSLOTS:
if (message.ToLowerInvariant() == "enable")
Helper.Settings.Instance.PremiumslotsEnabled = true;
else
Helper.Settings.Instance.PremiumslotsEnabled = false;
Helper.Logging.OnLogMessage(Helper.Settings.Instance.PremiumslotsEnabled ? "Premium slots are enabled" : "Premium slots are disabled", ServerService.MessageType.Info);
break;
case CWSProtocol.Commands.Command.EXTERNALACCESSCONTROL:
if (message.ToLowerInvariant() == "enable")
ServerService.Helper.Settings.Instance.ExternalAccessControl = true;
else
ServerService.Helper.Settings.Instance.ExternalAccessControl = false;
Helper.Logging.OnLogMessage(ServerService.Helper.Settings.Instance.ExternalAccessControl ? "Access is controlled by an external program." : "Access to your server is controlled by CWSRestart.", ServerService.MessageType.Info);
break;
}
break;
}
}
}
}
sr.Close();
}
serverStream.Disconnect();
wait.Set();
}
catch (ObjectDisposedException)
{
Helper.Logging.OnLogMessage("CWSRestartServer has been stopped", ServerService.MessageType.Info);
wait.Set();
}
}, null);
wait.WaitOne();
}
serverStream.Close();
IsRunning = false;
}
private void clientConnected(IAsyncResult ar)
{
using (NamedPipeServerStream serverStream = new NamedPipeServerStream("CWSRestartServer", PipeDirection.In, 4, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
{
serverStream.EndWaitForConnection(ar);
}
}
private void Worker(object state)
{
try {
var sourceUrl = (string)state;
lock (Mutex) {
Dispose();
string resolvedUrl = null;
ServerPipe = new NamedPipeServerStream("Stream Mosaic", PipeDirection.InOut, 64, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
var connection = ServerPipe.BeginWaitForConnection(null, null);
var psi = new ProcessStartInfo(
Form.LivestreamerPath,
String.Format(
"--player-continuous-http --player StreamMosaic.exe \"{0}\" best",
sourceUrl
)
);
psi.UseShellExecute = false;
psi.CreateNoWindow = true;
psi.WindowStyle = ProcessWindowStyle.Hidden;
/*
psi.RedirectStandardError = true;
psi.RedirectStandardOutput = true;
*/
LivestreamerProcess = Process.Start(psi);
connection.AsyncWaitHandle.WaitOne();
ServerPipe.EndWaitForConnection(connection);
var bytes = new byte[10240];
var numBytes = ServerPipe.Read(bytes, 0, bytes.Length);
resolvedUrl = Encoding.UTF8.GetString(bytes, 0, numBytes);
// We keep the pipe open so the child process survives, which keeps livestreamer's proxy alive.
var ar = Form.BeginInvoke(
(Action<int>)((index) => {
Form.Sources.Rows[index].Cells[1].Value = resolvedUrl;
}), RowIndex
);
ar.AsyncWaitHandle.WaitOne();
}
} catch (Exception exc) {
MessageBox.Show(exc.ToString());
}
}
private void BeginWaitForConnectionCallback(IAsyncResult iar)
{
pipeServer = (NamedPipeServerStream)iar.AsyncState;
pipeServer.EndWaitForConnection(iar);
if (pipeServer.IsConnected)
pipeServer.BeginRead(receiveBuffer, 0, receiveBuffer.Length, BeginReadCallback, pipeServer);
}
/// <summary>
/// After the callback, the lock is released
/// </summary>
//public void mycallBack(IAsyncResult ar)
//{
// lock (_sync)
// {
// _server.EndWaitForConnection(ar);
// _isLocked = false;
// }
//}
/// <summary>
/// Instantiate the server object, along with its reader and writer
/// Return value: 0 = good, -1 = error
/// </summary>
public int start()
{
int ret = 0;
try
{
//Create NamedPipe server instance
_server = new NamedPipeServerStream(Constants.pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
//Wrap pipe in reader/writer (for IO to pipe)
sw = new StreamWriter(_server);
sr = new StreamReader(_server);
//Wait for a connection to the pipe (Asynchronously)
_server.BeginWaitForConnection((a) =>
{
_server.EndWaitForConnection(a);
_isLocked = false;
}, null);
//Confirm in debug
System.Diagnostics.Debug.WriteLine("Connected!");
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Error creating server NamedPipe" + ex.ToString());
//Denote that an error occurred
ret = -1;
}
return ret;
}
private void ReadMessage(NamedPipeServerStream namedPipeServer)
{
var connectEvent = new AutoResetEvent(false);
var connectResult = namedPipeServer.BeginWaitForConnection(ar => connectEvent.Set(), null);
WaitHandle.WaitAny(new WaitHandle[] {_cancelConnectionEvent, connectEvent});
if (_stopReading)
return;
namedPipeServer.EndWaitForConnection(connectResult);
byte[] data;
using (var ms = new MemoryStream())
{
var buffer = new byte[256 * 1024];
int bytesRead;
while ((bytesRead = namedPipeServer.Read(buffer, 0, buffer.Length)) > 0)
ms.Write(buffer, 0, bytesRead);
data = ms.ToArray();
}
namedPipeServer.Disconnect();
HandleMessage(data);
}
/// <summary>
/// Background listening thread.
/// </summary>
private void OpenPipe()
{
while (_running)
{
lock (_syncObject)
{
try
{
_waitingPipe = new NamedPipeServerStream(_endPoint.Name, PipeDirection.InOut, MAX_SERVER_INSTANCES, PipeTransmissionMode.Byte, PipeOptions.Asynchronous | PipeOptions.WriteThrough);
_waitingPipe.BeginWaitForConnection(ar =>
{
try
{
NamedPipeCommunicationChannel channel;
lock (_syncObject)
{
_waitingPipe.EndWaitForConnection(ar);
channel = new NamedPipeCommunicationChannel(_endPoint, _waitingPipe);
_waitingPipe = null;
}
channel.Disconnected += ChannelDisconnected;
OnCommunicationChannelConnected(channel);
}
catch (ObjectDisposedException)
{ }
// listen for next connection
if (_running) OpenPipe();
}, null);
return;
}
catch
{
if (_waitingPipe != null)
{
try
{
_waitingPipe.Dispose();
}
catch { }
_waitingPipe = null;
}
}
}
if (_running) Thread.Sleep(1000);
}
}
private void doServerWork()
{
IsRunning = true;
serverStream = new NamedPipeServerStream("CWSRestartServer", PipeDirection.InOut, 4, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
Helper.Logging.OnLogMessage("Starting CWSRestartServer for process communication", ServerService.Logging.MessageType.Info);
while (!_shouldStop)
{
wait = new EventWaitHandle(false, EventResetMode.ManualReset);
serverStream.BeginWaitForConnection(ar =>
{
try
{
serverStream.EndWaitForConnection(ar);
if (serverStream.IsConnected)
{
Helper.Logging.OnLogMessage("Module connected", ServerService.Logging.MessageType.Info);
}
serverStream.Close();
wait.WaitOne();
}
catch (ObjectDisposedException)
{
Helper.Logging.OnLogMessage("CWSRestartServer has been stopped", ServerService.Logging.MessageType.Info);
wait.Set();
}
}, null);
wait.WaitOne();
}
serverStream.Close();
IsRunning = false;
}
private async Task WriteNamedPipeAsync()
{
string pipeID = pID.ToString();
using (NamedPipeServerStream pipeServer = new NamedPipeServerStream("luaPipeW" + pipeID, PipeDirection.Out, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous))
{
await Task.Factory.FromAsync((cb, state) => pipeServer.BeginWaitForConnection(cb, state), ar => pipeServer.EndWaitForConnection(ar), null);
using (StreamWriter pipeWriter = new StreamWriter(pipeServer))
{
pipeWriter.AutoFlush = true;
keepWritePipeOpen = true;
// Transition to a background thread
await TaskScheduler.Default;
while (keepWritePipeOpen)
{
Command command = await this.writeCommandQueue.DequeueAsync();
switch (command.Kind)
{
case CommandKind.Breakpoint:
BreakpointCommand bpCommand = command as BreakpointCommand;
await pipeWriter.WriteLineAsync("Breakpoint\0");
await pipeWriter.WriteLineAsync(bpCommand.File + "\0");
await pipeWriter.WriteLineAsync(bpCommand.LineNumber.ToString() + "\0");
break;
case CommandKind.Step:
await pipeWriter.WriteLineAsync("Step\0");
break;
case CommandKind.Continue:
await pipeWriter.WriteLineAsync("Continue\0");
break;
case CommandKind.Detach:
keepWritePipeOpen = false;
break;
case CommandKind.DebuggerEnvironmentReady:
await pipeWriter.WriteLineAsync("DebuggerEnvironmentReady\0");
break;
}
}
}
}
}
private void bw_DoWork(object sender, DoWorkEventArgs e)
{
int count = 0;
BackgroundWorker worker = sender as BackgroundWorker;
const int BufferSize = 256;
System.Diagnostics.Debug.WriteLine("Start Background Worker");
if (dataSource == SourceFrom.UART)
{
SkytraqGps gps = e.Argument as SkytraqGps;
byte[] buff = new byte[BufferSize];
try
{
while (!worker.CancellationPending)
{
int l = gps.ReadLineNoWait(buff, 256, 1000);
if (buff[0] != 0xa0 || buff[1] != 0xa1 || buff[4] != 0x64 || buff[5] != 0xfd)
{
continue;
}
++count;
worker.ReportProgress(count, new IQInfo(
buff[6],
(UInt32)buff[7] << 8 | (UInt32)buff[8],
buff[9],
buff[10],
buff[11],
buff[12],
buff[13],
(Int32)((UInt32)buff[14] << 24 | (UInt32)buff[15] << 16 | (UInt32)buff[16] << 8 | (UInt32)buff[17]),
(Int16)((UInt32)buff[18] << 8 | (UInt32)buff[19]),
(Int16)((UInt32)buff[20] << 8 | (UInt32)buff[21])));
//Console.WriteLine("{0},{1},{2},{3},{4},{5}",
// gpsType, nmeaSvid, integrateionTime, doppler, iValue, qValue);
}
}
catch (Exception ep)
{
Console.WriteLine(ep.ToString());
}
}
else
{
//Initial Namedpipe ===========================================
while (!worker.CancellationPending)
{
System.Diagnostics.Debug.WriteLine("Pipe name :" + Program.pipeName);
using (NamedPipeServerStream pipeStream = new NamedPipeServerStream(Program.pipeName,
PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
{
ReceiveStatus rs = ReceiveStatus.None;
int packageSize = 0;
int ptr = 0;
int sharpLen = 0;
byte[] buff = new byte[BufferSize];
System.Diagnostics.Debug.WriteLine("Create Named Pipe :" + Program.pipeName);
//Wait for connection
while (!worker.CancellationPending)
{
try
{
if (!pipeStream.IsConnected)
{
//pipeStream.WaitForConnection();
var asyncResult = pipeStream.BeginWaitForConnection(null, null);
while (!worker.CancellationPending)
{
if (asyncResult.AsyncWaitHandle.WaitOne(5))
{
pipeStream.EndWaitForConnection(asyncResult);
break;
}
}
}
}
catch (Exception ep)
{
Console.WriteLine(ep.ToString());
Thread.Sleep(10);
break;
}
if (worker.CancellationPending)
{
return;
}
var asyncResult2 = pipeStream.BeginRead(buff, ptr, 1, null, null);
//Wait for data in
while (!worker.CancellationPending)
{
if (asyncResult2.AsyncWaitHandle.WaitOne(5))
{
pipeStream.EndRead(asyncResult2);
++ptr;
break;
}
}
if (worker.CancellationPending)
{
return;
}
System.Diagnostics.Debug.Write(buff[ptr - 1]);
if (rs == ReceiveStatus.None && buff[ptr - 1] == '#')
{
rs = ReceiveStatus.GetSharpCommand;
}
else if (rs == ReceiveStatus.GetSharpCommand && buff[ptr - 1] == 0x0d)
{
rs = ReceiveStatus.GetSharpSlashR;
sharpLen = ptr - 1;
}
else if (rs == ReceiveStatus.GetSharpSlashR && buff[ptr - 1] == 0x0a)
{
rs = ReceiveStatus.FinishSharpCommand;
}
else if (rs == ReceiveStatus.GetSharpSlashR && buff[ptr - 1] != 0x0a)
{
rs = ReceiveStatus.GetSharpCommand;
}
else if (rs == ReceiveStatus.None && buff[ptr - 1] == 0xA0)
{
rs = ReceiveStatus.GetA0;
}
else if (rs == ReceiveStatus.GetA0 && buff[ptr - 1] == 0xA1)
{
rs = ReceiveStatus.GetA1;
}
else if (rs == ReceiveStatus.GetA1)
{
packageSize = buff[ptr - 1] << 8;
rs = ReceiveStatus.GetSize1;
}
else if (rs == ReceiveStatus.GetSize1)
{
packageSize |= buff[ptr - 1];
rs = ReceiveStatus.GetSize2;
}
else if (rs == ReceiveStatus.GetSize2)
{
if (ptr > (7 + packageSize) || ptr == BufferSize)
{
ptr = 0;
rs = ReceiveStatus.None;
}
if (ptr == (6 + packageSize) && buff[ptr - 1] == 0x0d)
{
rs = ReceiveStatus.GetSlashR;
}
}
else if (rs == ReceiveStatus.GetSlashR && buff[ptr - 1] == 0x0a)
{
rs = ReceiveStatus.FinishBinCommand;
}
else if (buff[ptr - 1] == 0x0d)
{
rs = ReceiveStatus.ErrorSlashR;
}
else if (rs == ReceiveStatus.ErrorSlashR && buff[ptr - 1] == 0x0a)
{
rs = ReceiveStatus.None;
ptr = 0;
}
if (rs == ReceiveStatus.FinishBinCommand)
{
if (buff[0] != 0xa0 || buff[1] != 0xa1 || buff[4] != 0x64 || buff[5] != 0xfd)
{
rs = ReceiveStatus.None;
ptr = 0;
continue;
}
++count;
worker.ReportProgress(count, new IQInfo(
buff[6],
(UInt32)buff[7] << 8 | (UInt32)buff[8],
buff[9],
buff[10],
buff[11],
buff[12],
buff[13],
(Int32)((UInt32)buff[14] << 24 | (UInt32)buff[15] << 16 | (UInt32)buff[16] << 8 | (UInt32)buff[17]),
(Int16)((UInt32)buff[18] << 8 | (UInt32)buff[19]),
(Int16)((UInt32)buff[20] << 8 | (UInt32)buff[21])));
rs = ReceiveStatus.None;
ptr = 0;
}
if (rs == ReceiveStatus.FinishSharpCommand)
{
string s2 = Encoding.UTF8.GetString(buff).Substring(0, sharpLen);
if(s2 == "#QUIT")
{
Close();
return;
}
}
if (ptr == BufferSize)
{
rs = ReceiveStatus.None;
ptr = 0;
}
} //while(worker.CancellationPending)
} //using (NamedPipeServerStream pipeStrea...
}
} //if (dataSource == SourceFrom.UART) else
}
public ServerRunner(String pipeName, Action<string> actionPrimaryReceiveMessage)
{
Debug.Assert(pipeName != null);
Debug.Assert(actionPrimaryReceiveMessage != null);
for (uint n = 0; n < ServerCount; ++n)
{
_threads[n] = new Thread(() =>
{
while (!_shutdown)
{
try
{
using (var server = new NamedPipeServerStream(pipeName, PipeDirection.In, ServerCount,
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous))
{
var connectEvent = new AutoResetEvent(false);
// note: unfortunately, WaitForConnection() does not put the current
// thread in an interruptible state. This is based on
// http://stackoverflow.com/questions/607872 and achieves this
// by using the async version, BeginWaitForConnection, in conjunction
// with an event.
server.BeginWaitForConnection(ar => {
// without this guard, unsafe access to a disposed closure can happen
if (_shutdown)
{
return;
}
// ReSharper disable AccessToDisposedClosure
Debug.Assert(server != null);
server.EndWaitForConnection(ar);
using (var sr = new StreamReader(server))
{
var line = sr.ReadLine();
if (!_shutdown)
{
// note: there is a small window in which the callback
// is called even though the application is likely no longer
// prepared for it. This needs to be checked for in the callback.
actionPrimaryReceiveMessage(line);
}
}
// ReSharper restore AccessToDisposedClosure
connectEvent.Set();
}, null);
connectEvent.WaitOne();
}
}
catch (IOException xc)
{
// ignore any IO exceptions happening here. We do not
// want to interrupt or crash the primary instance.
Console.WriteLine("Ignoring IOException in NamedPipe Server: " + xc.ToString());
}
catch (ThreadInterruptedException)
{
return;
}
}
});
_threads[n].Start();
}
}
private static void StartCliPipeServer(MainWindow main)
{
// http://stackoverflow.com/a/16302188
Task.Factory.StartNew(() =>
{
var server = new NamedPipeServerStream("CliPipe", PipeDirection.In, 1, PipeTransmissionMode.Message, PipeOptions.Asynchronous);
var reader = new StreamReader(server);
var connectedOrWaiting = false;
while (true)
{
if (!connectedOrWaiting)
{
server.BeginWaitForConnection((a) => { server.EndWaitForConnection(a); }, null);
connectedOrWaiting = true;
}
if (server.IsConnected)
{
var line = reader.ReadLine();
if (line != null)
{
// use StartsWith as HyperSpin adds a fullstop to the end (presumably for the rom extension)
if (line.StartsWith("-search"))
{
main.OnTriggerKeyHit(HyperSearchSettings.Instance().Input.Triggers.Search.FirstKey, null);
}
else if (line.StartsWith("-genre"))
{
main.OnTriggerKeyHit(HyperSearchSettings.Instance().Input.Triggers.Genre.FirstKey, null);
}
else if (line.StartsWith("-fav"))
{
main.OnTriggerKeyHit(HyperSearchSettings.Instance().Input.Triggers.Favourites.FirstKey, null);
}
else if (line.StartsWith("-settings"))
{
main.OnTriggerKeyHit(HyperSearchSettings.Instance().Input.Triggers.Settings.FirstKey, null);
}
}
server.Disconnect();
connectedOrWaiting = false;
}
System.Threading.Thread.Sleep(80);
}
});
}
