Esempio n. 1
0
        public void WindowsWMIInputCRUD()
        {
            Service         service         = Connect();
            InputCollection inputCollection = service.GetInputs();
            ServiceInfo     info            = service.GetInfo();

            if (info.OsName.Equals("Windows"))
            {
                string name = "sdk-input-wmi";
                Args   args = new Args();

                if (inputCollection.ContainsKey(name))
                {
                    inputCollection.Remove(name);
                    inputCollection.Refresh();
                }

                Assert.IsFalse(inputCollection.ContainsKey(name), assertRoot + "#80");

                // CRUD Windows Wmi Input
                args.Add("classes", "PerfOS_Processor");
                args.Add("interval", 600);
                args.Add("lookup_host", service.Host);
                inputCollection.Create(name, InputKind.WindowsWmi, args);
                Assert.IsTrue(inputCollection.ContainsKey(name), assertRoot + "#81");
                WindowsWmiInput windowsWmiInput = (WindowsWmiInput)inputCollection.Get(name);

                Assert.AreEqual("Win32_PerfFormattedData_PerfOS_Processor", windowsWmiInput.Classes, assertRoot + "#82");
                Assert.AreEqual(600, windowsWmiInput.Interval, assertRoot + "#83");
                Assert.AreEqual(windowsWmiInput.LookupHost, service.Host, assertRoot + "#84");

                windowsWmiInput.Classes   = "PerfDisk_LogicalDisk";
                windowsWmiInput.Fields    = new string[] { "Caption" };
                windowsWmiInput.Index     = "main";
                windowsWmiInput.Interval  = 1200;
                windowsWmiInput.Instances = new string[] { "_Total" };
                windowsWmiInput.Servers   = "host1.splunk.com,host2.splunk.com";
                windowsWmiInput.Update();

                Assert.AreEqual("Win32_PerfFormattedData_PerfDisk_LogicalDisk", windowsWmiInput.Classes, assertRoot + "#85");
                Assert.AreEqual(1, windowsWmiInput.Fields.Length, assertRoot + "#86");
                Assert.IsTrue(this.Contains(windowsWmiInput.Fields, "Caption"), assertRoot + "#87");
                Assert.AreEqual("main", windowsWmiInput.Index, assertRoot + "#88");
                Assert.AreEqual(1200, windowsWmiInput.Interval, assertRoot + "#89");
                Assert.AreEqual(1, windowsWmiInput.Instances.Length, assertRoot + "#90");
                Assert.IsTrue(this.Contains(windowsWmiInput.Instances, "_Total"), assertRoot + "#91");
                Assert.AreEqual("host1.splunk.com,host2.splunk.com", windowsWmiInput.Servers, assertRoot + "#92");

                // set list fields
                windowsWmiInput.Fields = new string[] { "Caption", "Description" };
                windowsWmiInput.Update();

                Assert.AreEqual(2, windowsWmiInput.Fields.Length, assertRoot + "#93");
                Assert.IsTrue(this.Contains(windowsWmiInput.Fields, "Caption"), assertRoot + "#94");
                Assert.IsTrue(this.Contains(windowsWmiInput.Fields, "Description"), assertRoot + "#95");

                windowsWmiInput.Remove();
                inputCollection.Refresh();
                Assert.IsFalse(inputCollection.ContainsKey(name), assertRoot + "#96");
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Touch all the properties of all any input
        /// </summary>
        /// <param name="input">The Input</param>
        private void TouchSpecificInput(Input input)
        {
            InputKind      inputKind      = input.GetKind();
            TcpConnections tcpConnections = null;
            UdpConnections udpConnections = null;

            string[] dummyStrings;
            string   dummyString;
            bool     dummyBoolean;
            DateTime dummyDate;
            int      dummyInt;

            if (inputKind.Equals(InputKind.Monitor))
            {
                MonitorInput monitorInput = (MonitorInput)input;
                dummyString  = monitorInput.Blacklist;
                dummyString  = monitorInput.CrcSalt;
                dummyInt     = monitorInput.FileCount;
                dummyBoolean = monitorInput.FollowTail;
                dummyString  = monitorInput.Host;
                dummyString  = monitorInput.HostRegex;
                dummyString  = monitorInput.IgnoreOlderThan;
                dummyString  = monitorInput.Index;
                dummyString  = monitorInput.Queue;
                dummyBoolean = monitorInput.IsRecursive;
                dummyString  = monitorInput.Source;
                dummyString  = monitorInput.SourceType;
                dummyInt     = monitorInput.TimeBeforeClose;
                dummyString  = monitorInput.Whitelist;
            }
            else if (inputKind.Equals(InputKind.Script))
            {
                ScriptInput scriptInput = (ScriptInput)input;
                dummyDate   = scriptInput.EndTime;
                dummyString = scriptInput.Group;
                dummyString = scriptInput.Host;
                dummyString = scriptInput.Index;
                dummyString = scriptInput.Interval;
                dummyDate   = scriptInput.StartTime;
            }
            else if (inputKind.Equals(InputKind.Tcp))
            {
                TcpInput tcpInput = (TcpInput)input;
                dummyString    = tcpInput.ConnectionHost;
                dummyString    = tcpInput.Group;
                dummyString    = tcpInput.Host;
                dummyString    = tcpInput.Index;
                dummyString    = tcpInput.Queue;
                dummyString    = tcpInput.RestrictToHost;
                dummyString    = tcpInput.Source;
                dummyString    = tcpInput.SourceType;
                dummyBoolean   = tcpInput.SSL;
                tcpConnections = tcpInput.Connections();
                dummyString    = tcpConnections.Connection;
                dummyString    = tcpConnections.Servername;
            }
            else if (inputKind.Equals(InputKind.TcpSplunk))
            {
                TcpSplunkInput tcpSplunkInput = (TcpSplunkInput)input;
                dummyString    = tcpSplunkInput.ConnectionHost;
                dummyString    = tcpSplunkInput.Group;
                dummyString    = tcpSplunkInput.Host;
                dummyString    = tcpSplunkInput.Index;
                dummyString    = tcpSplunkInput.Queue;
                dummyString    = tcpSplunkInput.Source;
                dummyString    = tcpSplunkInput.SourceType;
                dummyBoolean   = tcpSplunkInput.SSL;
                tcpConnections = tcpSplunkInput.Connections();
                dummyString    = tcpConnections.Connection;
                dummyString    = tcpConnections.Servername;
            }
            else if (inputKind.Equals(InputKind.Udp))
            {
                UdpInput udpInput = (UdpInput)input;
                dummyString    = udpInput.ConnectionHost;
                dummyString    = udpInput.Group;
                dummyString    = udpInput.Host;
                dummyString    = udpInput.Index;
                dummyString    = udpInput.Queue;
                dummyString    = udpInput.Source;
                dummyString    = udpInput.SourceType;
                dummyBoolean   = udpInput.NoAppendingTimeStamp;
                dummyBoolean   = udpInput.NoPriorityStripping;
                udpConnections = udpInput.Connections();
                dummyString    = udpConnections.Group;
            }
            else if (inputKind.Equals(InputKind.WindowsActiveDirectory))
            {
                WindowsActiveDirectoryInput windowsActiveDirectoryInput = (WindowsActiveDirectoryInput)input;
                dummyString  = windowsActiveDirectoryInput.Index;
                dummyBoolean = windowsActiveDirectoryInput.MonitorSubtree;
                dummyString  = windowsActiveDirectoryInput.StartingNode;
                dummyString  = windowsActiveDirectoryInput.TargetDc;
            }
            else if (inputKind.Equals(InputKind.WindowsEventLog))
            {
                WindowsEventLogInput windowsEventLogInput = (WindowsEventLogInput)input;
                dummyString  = windowsEventLogInput.Hosts;
                dummyString  = windowsEventLogInput.Index;
                dummyString  = windowsEventLogInput.LocalName;
                dummyStrings = windowsEventLogInput.Logs;
                dummyString  = windowsEventLogInput.LookupHost;
            }
            else if (inputKind.Equals(InputKind.WindowsPerfmon))
            {
                WindowsPerfmonInput windowsPerfmonInput = (WindowsPerfmonInput)input;
                dummyStrings = windowsPerfmonInput.Counters;
                dummyString  = windowsPerfmonInput.Index;
                dummyStrings = windowsPerfmonInput.Instances;
                dummyInt     = windowsPerfmonInput.Interval;
                dummyString  = windowsPerfmonInput.Object;
            }
            else if (inputKind.Equals(InputKind.WindowsRegistry))
            {
                WindowsRegistryInput windowsRegistryInput = (WindowsRegistryInput)input;
                dummyBoolean = windowsRegistryInput.Baseline;
                dummyString  = windowsRegistryInput.Hive;
                dummyString  = windowsRegistryInput.Index;
                dummyBoolean = windowsRegistryInput.MonitorSubnodes;
                dummyString  = windowsRegistryInput.Proc;
                dummyStrings = windowsRegistryInput.Type;
            }
            else if (inputKind.Equals(InputKind.WindowsWmi))
            {
                WindowsWmiInput windowsWmiInput = (WindowsWmiInput)input;
                dummyString  = windowsWmiInput.Classes;
                dummyStrings = windowsWmiInput.Fields;
                dummyString  = windowsWmiInput.Index;
                dummyStrings = windowsWmiInput.Instances;
                dummyInt     = windowsWmiInput.Interval;
                dummyString  = windowsWmiInput.LocalName;
                dummyString  = windowsWmiInput.LookupHost;
                dummyString  = windowsWmiInput.Servers;
                dummyString  = windowsWmiInput.Wql;
            }
            else
            {
                Assert.Fail();
            }
        }