public CmdExeApi start() { try { PipeName.namePipeServer(ConsoleOut); // setup namedpipe saveUsersWindow(); this.sleep(250); // host process HostProcessStarted = true; HostCmdExeProcess = Processes.startProcess("cmd.exe", "", MinimizeHostWindow); HostCmdExeProcess.Exited += (sender, e) => HostProcessEnded = true; findHostProcessHandle(); // child process // the ReadTimeout can be reset on next recompile // see http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/redirection.mspx?mfr=true for details on cmd.exe redirection var CreateChildProcessWithRedirection = "\"{0}\" {1} > \\\\.\\pipe\\{2} 2>&1".format(ProcessToStart, Arguments, PipeName); restoreUsersWindow(); hostCmd(CreateChildProcessWithRedirection); //ChildProcess = Processes.startProcess(ProcessToStart,ChildProcessAgumentsWithRedirection); //this.sleep(1000); } catch (Exception ex) { ex.log("in CmdExeApi.start"); } return(this); }
public static IDisposable BeginWritingMessages(this PipeName pipe, string processName, Action <Exception> onWriteError, params IObservable <IBinaryMessage>[] messages) { var ctSource = new CancellationTokenSource(); var queue = new DispatcherQueue <IBinaryMessage>(); var writeThread = new Thread(() => { try { using (var stream = Pipe.Connect(pipe).Result) using (var writer = new BinaryWriter(stream)) { queue.Dispatch(message => message.WriteTo(writer), ctSource.Token); } } catch (Exception e) { onWriteError(e); } }) { Name = "Write binary messages to " + processName, IsBackground = true, }; writeThread.Start(); return(Disposable.Combine( Disposable.Create(ctSource.Cancel), messages.Merge().Subscribe(queue.Enqueue))); }
public void DataAndTypeAreReadWriteInvariant() { var pipe = PipeName.New(); var outbox = new [] { BinaryMessage.Compose("Elm1", writer => { }), BinaryMessage.Compose("Elm1", writer => { }), BinaryMessage.Compose("Elm2", writer => writer.Write(new byte[] { 13, 37 })), BinaryMessage.Compose("Elm3", writer => writer.Write(new byte[] { 19, 11 })), BinaryMessage.Compose("Elm4", writer => { }) }; pipe.BeginWritingMessages("Test", ex => Assert.Fail("Write failed: " + ex.Message), outbox.ToObservable()); var inbox = pipe.ReadMessages("test").RefCount().ToEnumerable().Take(outbox.Length).ToArray(); Assert.AreEqual(outbox.Length, inbox.Length); for (int i = 0; i < outbox.Length; i++) { Assert.AreEqual(outbox[i].Type, inbox[i].Type); CollectionAssert.AreEqual(outbox[i].DumpBytes(), inbox[i].DumpBytes()); } }
public static IConnectableObservable <IBinaryMessage> ReadMessages(this PipeName pipe, string processName) { return(Observable .Defer(() => Pipe.Host(pipe).ToObservable()) .Select(p => p.ReadMessages(processName)) .Concat() .Publish()); }
internal static string GetMSMQPath(this PipeName pipeName) { var machineNameEncoded = (String.IsNullOrEmpty(pipeName.MachineName)) ? "." : pipeName.MachineName.ToLowerInvariant(); return(machineNameEncoded + '\\' + pipeName.GetMSMQName()); }
internal static bool IsLocal(this PipeName pipeName) { return((String.IsNullOrEmpty(pipeName.MachineName) || pipeName.MachineName == "." || pipeName.MachineName.ToLower() == Environment.MachineName.ToLower()) ? true : false); }
public VisualStudioConnectionHandler(CodeLensDataPoint owner, int vspid) { this.owner = owner; stream = new NamedPipeClientStream( serverName: ".", PipeName.Get(vspid), PipeDirection.InOut, PipeOptions.Asynchronous); }
internal static bool GetExists(this PipeName pipeName) { if (pipeName.IsLocal()) { string msmqPath = pipeName.GetMSMQPath(); return(MessageQueue.Exists(msmqPath)); } string myMSMQFormatName = pipeName.GetMSMQDirectName(); MessageQueue[] queueList = MessageQueue.GetPrivateQueuesByMachine(pipeName.MachineName); return(queueList.Select(messageQueue => messageQueue.FormatName).Any(curMSMQFormatName => String.Compare(myMSMQFormatName, curMSMQFormatName, true) == 0)); }
internal static string GetMSMQName(this PipeName pipeName) { var typeName = pipeName.GetType().Name; Debug.Assert(typeName.EndsWith(TypeSuffix), "PipeName subclass " + typeName + " does not end with mandatory suffix " + TypeSuffix); // TODO: Remove "PipeName" type suffix and lowercase the string. typeName = typeName.Substring(0, typeName.Length - TypeSuffix.Length).ToLowerInvariant(); var msmqName = Privacy + '\\' + Badge + Delimiter + typeName; msmqName += Delimiter + pipeName.LongName; return(msmqName); }
private static PipeName GetPipeName(string url) { IDictionary parts = null; if (!ParseUrl(url, out parts)) { throw new ArgumentException("Invalid pipe address specified"); } PipeName pipeName = new PipeName((string)parts["host"], (string)parts["pipe"]); return(pipeName); }
public Stream CreateStream(string name) { var pipeName = new PipeName(GetProcessIdentifier() + name); try { return(new UnixSocketStream(pipeName, SocketUsage.Host)); } catch (Exception) { UnixSocketStream.Unlink(pipeName); } return(new UnixSocketStream(pipeName, SocketUsage.Host)); }
internal static uint Count(this PipeName pipeName) { MSMQExt.MQMGMTPROPS props = new MSMQExt.MQMGMTPROPS { cProp = 1 }; try { props.aPropID = Marshal.AllocHGlobal(sizeof(int)); Marshal.WriteInt32(props.aPropID, (int)MSMQExt.MQMGMT_QUEUE_PROPERTIES.PROPID_MGMT_QUEUE_MESSAGE_COUNT); // Marshal.SizeOf(typeof(MSMQExt.MQPROPVARIANT)) props.aPropVar = Marshal.AllocHGlobal(24); Marshal.StructureToPtr(new MSMQExt.MQPROPVARIANT { vt = MSMQExt.VT_NULL }, props.aPropVar, false); props.aStatus = Marshal.AllocHGlobal(sizeof(int)); Marshal.WriteInt32(props.aStatus, 0); string machineName = (pipeName.IsLocal()) ? null : pipeName.MachineName; string specialPath = "QUEUE=" + pipeName.GetMSMQDirectName(); int result = MSMQExt.MQMgmtGetInfo(machineName, specialPath, ref props); if (result != 0 || Marshal.ReadInt32(props.aStatus) != 0) { return(0); } MSMQExt.MQPROPVARIANT propVar = (MSMQExt.MQPROPVARIANT)Marshal.PtrToStructure(props.aPropVar, typeof(MSMQExt.MQPROPVARIANT)); if (propVar.vt != MSMQExt.VT_UI4) { return(0); } else { return(propVar.Union1.ulVal); } } finally { Marshal.FreeHGlobal(props.aPropID); Marshal.FreeHGlobal(props.aPropVar); Marshal.FreeHGlobal(props.aStatus); } }
public static async Task AcceptCodeLensConnections() { try { while (true) { var stream = new NamedPipeServerStream( PipeName.Get(Process.GetCurrentProcess().Id), PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous); await stream.WaitForConnectionAsync().Caf(); _ = HandleConnection(stream); } } catch (Exception ex) { LogVS(ex); throw; }
private void Initialize(IDictionary properties, IServerChannelSinkProvider sinkProvider) { if (properties != null) { // read property values foreach (DictionaryEntry property in properties) { switch ((string)property.Key) { case "name": _channelName = Convert.ToString(property.Value); break; case "priority": _channelPriority = Convert.ToInt32(property.Value); break; case "pipe": _pipe = Convert.ToString(property.Value); break; case "securityDescriptor": _securityDescriptor = (property.Value as SecurityDescriptor); break; } } } // setup pipe name _pipeName = new PipeName(@"\\.\pipe\" + _pipe); // create the chain of the sink providers that will process all messages _sinkProvider = ChannelHelper.ServerChannelCreateSinkProviderChain(sinkProvider); _channelData = ChannelHelper.ServerChannelCreateDataStore(ChannelUri, _sinkProvider); // create transport sink IServerChannelSink nextSink = ChannelServices.CreateServerChannelSinkChain(_sinkProvider, this); _transportSink = new ServerTransportSink(nextSink); // create listener thread _transportListener = new TransportListener(ChannelUri, typeof(PipeTransport)); _listenerThread = new Thread(new ThreadStart(ListenerStart)); _listenerThread.IsBackground = true; _requestHandler = new ProcessRequestCallback(_transportSink.ProcessRequest); // start listening on the channel StartListening(null); }
private string MakeConnectionString() { if (ConnectionType == ConnectionType.Embedded) { return(String.Format("type=embedded;storesDirectory={0}", DirectoryPath)); } if (ConnectionType == ConnectionType.Http || ConnectionType == ConnectionType.Tcp) { var connString = new StringBuilder(); connString.Append(ConnectionType == ConnectionType.Http ? "type=http;endpoint=http://" : "type=tcp;endpoint=net.tcp://"); connString.Append(ServerName); if (!String.IsNullOrEmpty(ServerPort)) { connString.Append(":"); connString.Append(ServerPort); } if (!String.IsNullOrEmpty(ServerPath)) { if (!ServerPath.StartsWith("/")) { connString.Append("/"); } connString.Append(ServerPath); } return(connString.ToString()); } if (ConnectionType == ConnectionType.NamedPipe) { var connString = new StringBuilder(); connString.Append("type=namedpipe;endpoint=net.pipe://"); connString.Append(ServerName); if (!PipeName.StartsWith("/")) { connString.Append("/"); } connString.Append(PipeName); return(connString.ToString()); } throw new NotSupportedException(String.Format("Cannot generate connection string for connection type {0}", ConnectionType)); }
/// <summary> /// Connects to the named pipe /// </summary> /// <returns>Whether connection was successful</returns> public bool Connect() { Client = new NamedPipeClientStream(PipeName.ToString()); var tries = 0; while (Client.IsConnected == false) { if (tries == 20) { break; // Failed to connect } Client.Connect(); tries += 1; Thread.Sleep(1000); } return(Client.IsConnected); }
public static UnoHostProcess Spawn(AbsoluteFilePath assembly, IObservable <IBinaryMessage> messagesToUnoHost, AbsoluteFilePath userDataPath, IEnumerable <string> moreArgs) { if (Application == null) { throw new InvalidOperationException("UnoHostProcess.Application has not been initialized"); } var args = new UnoHostArgs { AssemblyPath = assembly, OutputPipe = PipeName.New(), InputPipe = PipeName.New(), UserDataPath = userDataPath, }; var disp = args.InputPipe.BeginWritingMessages("UnoHost", ex => Console.WriteLine("Designer failed to write message to UnoHost: " + ex), messagesToUnoHost); return(new UnoHostProcess { Messages = args.OutputPipe.ReadMessages("UnoHost"), Process = Observable.Start(() => Application.Start(args.Serialize().Concat(moreArgs))), Disposables = Disposable.Combine(disp) }); }
internal static string GetMSMQFormatName(this PipeName pipeName) { return(FormatNamePrefix + pipeName.GetMSMQDirectName()); }
internal MSMQPipe(PipeName pipeName) { this._pipeName = pipeName; }
public void SetUp() { _pipeName = new PipeName(Guid.NewGuid()); }
public DocumentAppHandler(IReport reporter, string applicationName, string[] args) { _reporter = reporter; _args = args; _pipeName = new PipeName(applicationName); }