Ejemplo n.º 1
0
        /// <summary>
        /// Synchronously waits for the given PID and returns the exit code.
        /// </summary>
        public static unsafe int WaitPid(int pid, TimeSpan?timeout = null)
        {
            using (var kqueue = new KernelQueue()) {
                var events = stackalloc KernelEvent [1];
                events [0] = new KernelEvent {
                    Ident  = (IntPtr)pid,
                    Filter = EventFilter.Proc,
                    // header says NOTE_EXITSTATUS only valid for child processes, but this seems to work for any arbitrary process
                    FilterFlags = (uint)FilterFlags.ProcExitStatus,
                    Flags       = EventFlags.Add
                };

                var tsTimeout  = timeout.GetValueOrDefault().ToTimespec();
                var eventCount = KQueue.kevent((int)kqueue.Handle, events, 1, events, 1,
                                               timeout.HasValue ? &tsTimeout : (TimeSpec *)0);

                switch (eventCount)
                {
                case -1:
                    throw new SystemException("kqueue error: " + Marshal.GetLastWin32Error());

                case 0:
                    throw new TimeoutException();
                }
                if (events [0].Flags.HasFlag(EventFlags.Error))
                {
                    throw new Exception("Unix IO event error: " + (int)events [0].Data);
                }

                return((int)events [0].Data >> 8);
            }
        }
Ejemplo n.º 2
0
        public void KEventExceptions()
        {
            using (var sleep = Process.Start("/bin/sleep", "0")) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    var empty  = new KernelEvent [0];

                    Assert.Throws <ArgumentNullException> (() => kqueue.KEvent(null, events, null), "a1");
                    Assert.Throws <ArgumentNullException> (() => kqueue.KEvent(events, null, null), "a2");
                    Assert.Throws <ArgumentNullException> (() => kqueue.KEvent(null, null, null), "a3");
                    Assert.Throws <ArgumentOutOfRangeException> (() => kqueue.KEvent(events, empty, null), "a4");
                    Assert.Throws <ArgumentOutOfRangeException> (() => kqueue.KEvent(empty, events, null), "a5");

                    Assert.Throws <ArgumentNullException> (() => kqueue.KEvent(null, 1, events, 1, null), "b1");
                    Assert.Throws <ArgumentNullException> (() => kqueue.KEvent(events, 1, null, 1, null), "b2");
                    Assert.Throws <ArgumentNullException> (() => kqueue.KEvent(null, 1, null, 1, null), "b3");
                    Assert.Throws <ArgumentOutOfRangeException> (() => kqueue.KEvent(events, 1, empty, 1, null), "b4");
                    Assert.Throws <ArgumentOutOfRangeException> (() => kqueue.KEvent(empty, 1, events, 1, null), "b5");
                    Assert.Throws <ArgumentOutOfRangeException> (() => kqueue.KEvent(events, 1, events, 2, null), "b6");
                    Assert.Throws <ArgumentOutOfRangeException> (() => kqueue.KEvent(events, 2, events, 1, null), "b7");
                }
            }
        }
Ejemplo n.º 3
0
        public void KEvent()
        {
            // (KernelEvent[], KernelEvent[])
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.IsTrue(kqueue.KEvent(events, events), "kevent");
                }
            }

            // (KernelEvent[], KernelEvent[], TimeSpan?)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.AreEqual(1, kqueue.KEvent(events, events, TimeSpan.FromSeconds(5)), "kevent");
                }
            }

            // (KernelEvent[], KernelEvent[], TimeSpan?)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.AreEqual(1, kqueue.KEvent(events, events, null), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int, TimeSpec?)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var      events = CreateEvents(sleep);
                    TimeSpec ts     = new TimeSpec
                    {
                        Seconds = 5,
                    };
                    Assert.AreEqual(1, kqueue.KEvent(events, events.Length, events, events.Length, ts), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int, TimeSpec?)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.AreEqual(1, kqueue.KEvent(events, events.Length, events, events.Length, null), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int, ref TimeSpec)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var      events = CreateEvents(sleep);
                    TimeSpec ts     = new TimeSpec
                    {
                        Seconds = 5,
                    };
                    Assert.IsTrue(kqueue.KEvent(events, events.Length, events, events.Length, ref ts), "kevent");
                }
            }

            // (KernelEvent[], KernelEvent[], ref TimeSpec)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var      events = CreateEvents(sleep);
                    TimeSpec ts     = new TimeSpec
                    {
                        Seconds = 5,
                    };
                    Assert.IsTrue(kqueue.KEvent(events, events, ref ts), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int)
            using (var sleep = Process.Start("/bin/sleep", "0.5")) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.IsTrue(kqueue.KEvent(events, events.Length, events, events.Length), "kevent");
                }
            }
        }
        public void KEvent()
        {
            var sleep_duration = "0.05";

            // (KernelEvent[], KernelEvent[])
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
#if NET
                    Assert.That(kqueue.KEvent(events, events), Is.GreaterThan(0), "kevent");
#else
                    Assert.IsTrue(kqueue.KEvent(events, events), "kevent");
#endif
                }
            }

            // (KernelEvent[], KernelEvent[], TimeSpan?)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.AreEqual(1, kqueue.KEvent(events, events, TimeSpan.FromSeconds(5)), "kevent");
                }
            }

            // (KernelEvent[], KernelEvent[], TimeSpan?)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.AreEqual(1, kqueue.KEvent(events, events, null), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int, TimeSpec?)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var      events = CreateEvents(sleep);
                    TimeSpec ts     = new TimeSpec
                    {
                        Seconds = 5,
                    };
                    Assert.AreEqual(1, kqueue.KEvent(events, events.Length, events, events.Length, ts), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int, TimeSpec?)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
                    Assert.AreEqual(1, kqueue.KEvent(events, events.Length, events, events.Length, null), "kevent");
                }
            }

            // (KernelEvent[], int, KernelEvent[], int, ref TimeSpec)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var      events = CreateEvents(sleep);
                    TimeSpec ts     = new TimeSpec
                    {
                        Seconds = 5,
                    };
#if NET
                    Assert.That(kqueue.KEvent(events, events.Length, events, events.Length, ts), Is.GreaterThan(0), "kevent");
#else
                    Assert.IsTrue(kqueue.KEvent(events, events.Length, events, events.Length, ref ts), "kevent");
#endif
                }
            }

            // (KernelEvent[], KernelEvent[], ref TimeSpec)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
#if NET
                    Assert.That(kqueue.KEvent(events, events, TimeSpan.FromSeconds(5)), Is.GreaterThan(0), "kevent");
#else
                    TimeSpec ts = new TimeSpec
                    {
                        Seconds = 5,
                    };
                    Assert.IsTrue(kqueue.KEvent(events, events, ref ts), "kevent");
#endif
                }
            }

            // (KernelEvent[], int, KernelEvent[], int)
            using (var sleep = Process.Start("/bin/sleep", sleep_duration)) {
                using (var kqueue = new KernelQueue()) {
                    var events = CreateEvents(sleep);
#if NET
                    Assert.That(kqueue.KEvent(events, events.Length, events, events.Length), Is.GreaterThan(0), "kevent");
#else
                    Assert.IsTrue(kqueue.KEvent(events, events.Length, events, events.Length), "kevent");
#endif
                }
            }
        }