Ejemplo n.º 1
0
        public static void RunCepStream(CepStream <MediationData> cepStream)
        {
            var binder = new QueryBinder(application.CreateQueryTemplate(
                                             Guid.NewGuid().ToString(),
                                             "description1",
                                             cepStream));

            binder.BindProducer <MediationData>(
                "cepStream1",
                inputAdapter,
                inConfig,
                EventShape.Point);
            binder.AddConsumer <MediationData>(
                "output1",
                outputAdapter,
                outConfig,
                EventShape.Point,
                StreamEventOrder.ChainOrdered);

            var query = application.CreateQuery("queyName", "desc", binder);

            query.Start();
            DiagnosticView diagnosticView;

            do
            {
                Thread.Sleep(100);
                diagnosticView = query.Application.Server.GetDiagnosticView(query.Name);
            } while ((string)diagnosticView["QueryState"] == "Running");

            query.Stop();
            query.Delete();
        }
Ejemplo n.º 2
0
        /// <summary>[Q4] “Find the most recent toll generated from vehicles being processed
        /// at each station over a 3 minute window reporting the result every time a
        /// change occurs in the input. Return the result at a point in time”.</summary>
        private static void RunGroupedSlidingWindowDemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from e in inputStream.AlterEventDuration(e => TimeSpan.FromMinutes((double)3))
                              group e by e.TollId into perTollBooth
                              from w in perTollBooth.SnapshotWindow(SnapshotWindowOutputPolicy.Clip)
                              select new Toll
            {
                TollId       = perTollBooth.Key,
                TollAmount   = w.Sum(e => e.Toll),
                VehicleCount = w.Count()                   // computed as a bonus, not asked in the query
            };

            BindAndRunQuery(
                "GroupedSliding",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "TollId", "TollAmount", "VehicleCount"
            });
        }
Ejemplo n.º 3
0
        private static void RunQuery(Application cepApplication)
        {
            var config = new YahooDataInputConfig()
            {
                Symbols            = new string[] { "AAPL", "DELL", "MSFT", "GOOG", "GE" },
                RefreshInterval    = TimeSpan.FromSeconds(0.5),
                TimestampIncrement = TimeSpan.FromSeconds(0.5),
                AlwaysUseNow       = true,
                EnqueueCtis        = false
            };

            AdvanceTimeSettings ats = new AdvanceTimeSettings(new AdvanceTimeGenerationSettings(
                                                                  TimeSpan.FromMilliseconds(1000),
                                                                  TimeSpan.FromMilliseconds(200)),
                                                              null, AdvanceTimePolicy.Drop);

            var data = CepStream <YahooDataEvent> .Create(cepApplication, "TestData", typeof(YahooDataInputFactory), config,
                                                          EventShape.Point, ats);

            var query = data.ToQuery(cepApplication, "Test", "Test", typeof(ConsoleOutputFactory),
                                     new ConsoleOutputConfig()
            {
                ShowCti          = true,
                CtiEventColor    = ConsoleColor.Yellow,
                InsertEventColor = ConsoleColor.Magenta
            },
                                     EventShape.Point, StreamEventOrder.FullyOrdered);

            query.Start();
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Create a simple passthrough query.
        /// </summary>
        /// <param name="app">The application that will host the query.</param>
        /// <param name="queryName">The name of the query.</param>
        /// <param name="queryDescription">The description of the query.</param>
        /// <param name="inputFile">The file to read input from.</param>
        /// <param name="outputPath">The path under which to put our output. This will go to a file of the form [app].[query].out</param>
        /// <param name="eventFrequency">How often the input adapter should produce events. Zero will produce them as fast as possible.</param>
        /// <returns>The new query.</returns>
        private static Query CreatePassthroughQuery(Application app, string queryName, string queryDescription, string inputFile, string outputPath, TimeSpan eventFrequency)
        {
            // Create a configuration for our input adapter.
            var inputConfig = new ReplayablePointCsvInputAdapterConfig(inputFile, eventFrequency);

            // Declare the input stream.
            var inputStream = CepStream <XYPayload> .Create(
                queryName + ":input",
                typeof(ReplayablePointCsvInputAdapterFactory),
                inputConfig,
                EventShape.Point,
                null);

            // Just a passthrough template.
            var q = from e in inputStream select e;

            // Create the query. This declares which output adapter to use, and also configures
            // the query for resiliency.
            Query rval = q.ToQuery(
                app,
                queryName,
                queryDescription,
                typeof(DedupingPointCsvOuputAdapterFactory),
                new DedupingPointCsvOutputAdapterConfig(Path.Combine(outputPath, GetOutputFileName(app.ShortName, queryName))),
                EventShape.Point,
                StreamEventOrder.FullyOrdered,
                true); // <== *** This says that the query is resilient and enables it for checkpointing. ***

            return(rval);
        }
Ejemplo n.º 5
0
        /// <summary>[Q2] “Find the number of vehicles being processed in the toll
        /// station at some time over a 3 minute window, with the time
        /// advancing in one minute hops. Provide the counts as of the last
        /// reported result. Return the result at a point in time at the
        /// end of each 3 minute window” </summary>
        private static void RunHoppingCountDemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var tQ2 = from w in inputStream.HoppingWindow(
                TimeSpan.FromMinutes(3),
                TimeSpan.FromMinutes(1),
                HoppingWindowOutputPolicy.ClipToWindowEnd)
                      select new TollCount
            {
                Count = w.Count()
            };
            var queryStream = from e in tQ2.ShiftEventTime(e => e.StartTime + TimeSpan.FromMinutes(3)).ToPointEventStream()
                              select e;

            BindAndRunQuery(
                "Hopping",
                queryStream,
                EventShape.Point,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "Count"
            });
        }
Ejemplo n.º 6
0
        /// <summary>[Q11] “Over a 3 minute tumbling window, find the ratio of out-of-state
        /// vehicles to total vehicles being processed at a toll station”</summary>
        private static void RunUDADemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from w in inputStream.TumblingWindow(
                TimeSpan.FromMinutes((double)3),
                HoppingWindowOutputPolicy.ClipToWindowEnd)
                              select new VehicleRatio
            {
                Value = w.OutOfStateVehicleRatio()
            };

            BindAndRunQuery(
                "UDA",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "Value"
            });
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Contains the query logic in form of a query template.
        /// </summary>
        /// <param name="application">Application to host the query template.</param>
        /// <returns>The new query template object.</returns>
        private static QueryTemplate CreateQueryTemplate(Application application)
        {
            // Create stream objects as basis for query template
            // specification. The specified names will be used when binding
            // the query template's inputs to event producers.
            CepStream <SensorReading> sensorStream = CepStream <SensorReading> .Create("sensorInput");

            CepStream <LocationData> locationStream = CepStream <LocationData> .Create("locationInput");

            // Extend duration of each sensor reading, so that they fall in
            // a one-minute sliding window. Group by sensor ID and calculate the
            // average vehicular count per group within each window.
            // Include the grouping key in the aggregation result.
            var avgCount = from oneMinReading in sensorStream.AlterEventDuration(e => TimeSpan.FromMinutes(1))
                           group oneMinReading by oneMinReading.SensorId into oneGroup
                           from eventWindow in oneGroup.SnapshotWindow(SnapshotWindowOutputPolicy.Clip)
                           select new { avgCount = eventWindow.Avg(e => e.VehicularCount), SensorId = oneGroup.Key };

            // Join sensors and locations. Moreover, filter the count
            // result by a threshold, which is looked up based on the
            // sensor location through a user-defined function.
            var joined = from averageEvent in avgCount
                         join locationData in locationStream
                         on averageEvent.SensorId equals locationData.SensorId
                         where averageEvent.avgCount > UserFunctions.LocationCountThreshold(locationData.LocationId)
                         select new
            {
                SensorId       = locationData.SensorId,
                LocationID     = locationData.LocationId,
                VehicularCount = averageEvent.avgCount
            };

            return(application.CreateQueryTemplate("SampleQueryTemplate", string.Empty, joined));
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Main entry point for the sample program.
        /// </summary>
        private static void Main()
        {
            using (Server server = Server.Create("Default"))
            {
                Application application = server.CreateApplication("Application");

                // Define a simple query
                CepStream <EventType> input = CepStream <EventType> .Create("Input");

                var streamDefinition = from e in input
                                       where e.X % 10 == 0
                                       select e;

                // Bind query
                Uri   inputAddress  = new Uri("http://localhost:8080/InputAdapter");
                Uri   outputAddress = new Uri("http://localhost:8080/OutputAdapter");
                Query query         = CreateQuery(application, streamDefinition, inputAddress, outputAddress);

                query.Start();
                Console.WriteLine("Query started.");
                Console.WriteLine("Press enter to stop query.");

                // Produce and consume events via the service contract channels.
                new Thread(() => ProduceEvents(inputAddress)).Start();
                new Thread(() => ConsumeEvents(outputAddress)).Start();

                Console.ReadLine();

                query.Stop();
                Console.WriteLine("Query stopped.");
            }
        }
Ejemplo n.º 9
0
        /// <summary>[Q3] “Find the toll generated from vehicles being processed at each
        /// toll station at some time over a 3 minute window, with the time advancing
        /// in one minute hops. Provide the value as of the last reported result.
        /// Return the result at a point in time” </summary>
        private static void RunGroupedHoppingWindow()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from e in inputStream
                              group e by e.TollId into perTollBooth
                              from w in perTollBooth.HoppingWindow(
                TimeSpan.FromMinutes(3),                                // Window Size
                TimeSpan.FromMinutes(1),                                // Hop Size
                HoppingWindowOutputPolicy.ClipToWindowEnd)
                              select new Toll
            {
                TollId       = perTollBooth.Key,
                TollAmount   = w.Sum(e => e.Toll),
                VehicleCount = w.Count()
            };

            BindAndRunQuery(
                "GroupedHopping",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "TollId", "TollAmount", "VehicleCount"
            });
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Create a simple aggregate query.
        /// </summary>
        /// <param name="app">The application that will host the query.</param>
        /// <param name="queryName">The name of the query.</param>
        /// <param name="queryDescription">The description of the query.</param>
        /// <param name="inputFile">The file to read input from.</param>
        /// <param name="outputPath">The path under which to put our output. This will go to a file of the form [app].[query].out</param>
        /// <param name="eventFrequency">How often the input adapter should produce events. Zero will produce them as fast as possible.</param>
        /// <returns>The new query.</returns>
        private static Query CreateAggregationQuery(Application app, string queryName, string queryDescription, string inputFile, string outputPath, TimeSpan eventFrequency)
        {
            // Create a configuration for our input adapter.
            var inputConfig = new ReplayablePointCsvInputAdapterConfig(inputFile, eventFrequency);

            // Declare the input stream.
            var inputStream = CepStream <XYPayload> .Create(
                queryName + ":input",
                typeof(ReplayablePointCsvInputAdapterFactory),
                inputConfig,
                EventShape.Point,
                null);

            // Do some simple aggregation.
            var q = from window in inputStream.HoppingWindow(TimeSpan.FromHours(1), TimeSpan.FromMinutes(1))
                    select new { AvgX = window.Avg(e => e.X), AvgY = window.Avg(e => e.Y) };

            // Create the query. This declares which output adapter to use, and also configures
            // the query for resiliency.
            Query rval = q.ToQuery(
                app,
                queryName,
                queryDescription,
                typeof(DedupingPointCsvOuputAdapterFactory),
                new DedupingPointCsvOutputAdapterConfig(Path.Combine(outputPath, GetOutputFileName(app.ShortName, queryName)), new string[] { "AvgX", "AvgY" }),
                EventShape.Point,
                StreamEventOrder.FullyOrdered,
                true); // <== *** This says that the query is resilient and enables it for checkpointing. ***

            return(rval);
        }
Ejemplo n.º 11
0
        /// <summary>[Q10] “For each vehicle that is being processed at an EZ-Pass booth, report
        /// the TollReading if the tag does not exist, has expired, or is reported stolen</summary>
        private static void RunUDFDemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from e in inputStream
                              where (0 == e.Tag.Length) || IsLostOrStolen(e.Tag) || IsExpired(e.Tag)
                              select new TollViolation
            {
                LicensePlate = e.LicensePlate,
                Make         = e.Make,
                Model        = e.Model,
                State        = e.State,
                Tag          = e.Tag,
                TollId       = e.TollId
            };

            BindAndRunQuery(
                "UDF",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "LicensePlate", "Make", "Model", "State", "Tag", "TollId"
            });
        }
Ejemplo n.º 12
0
        static void Main(string[] args)
        {
            var server      = Server.Create("default");
            var application = server.CreateApplication("CellData");

            // Configuration for input 1
            var input1Config = new SensorInputConfig
            {
                Timeout          = Program.Timeout,
                Interval         = Program.Interval,
                NumberOfReadings = Program.NumberOfReading
            };


            //string streamName = "{ \"sensor\":\"compass\",\"values\":{ \"x\":82.26953,\"y\":-17.796535,\"z\":-8.009412},\"type\":\"sensor\"}";

            // Instantiate input adapters
            var input1Stream = CepStream <SensorData> .Create("input1Stream", typeof(SensorInputAdapterFactory), input1Config, EventShape.Point);

            // Configure output adapter
            var outputConfig = new SensorOutputConfig {
                AdapterStopSignal = "StopData"
            };


            // filtering logic for the json data
            // Join input adapters with a simple LINQ query
            var combinedInputStream = (from e in input1Stream
                                       //where (e.sensor == "compass" && Convert.ToDouble(e.values.x) > 149)
                                       //select e);
                                       where (e.sensor == "compass")
                                       select new SensorData
            {
                sensor = e.sensor,
                values = e.values,
                type = e.type,
                direction = Direction.GetDirection(e.values.x)
            });


            // Connect input adapters with output adapter
            var query = combinedInputStream.ToQuery(application, "CellInformation", "...", typeof(SensorOutputAdapterFactory), outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);


            // Instantiate semaphor for stop signal
            var adapterStopSignal = new EventWaitHandle(false,
                                                        EventResetMode.ManualReset, outputConfig.AdapterStopSignal);

            // Run the query
            query.Start();
            adapterStopSignal.WaitOne();
            query.Stop();

            application.Delete();
            server.Dispose();
        }
Ejemplo n.º 13
0
 /// <summary>
 /// Creates and binds a query with a single input stream.
 /// </summary>
 private static Query CreateQuery(Application application, CepStream<EventType> streamDefinition, Uri inputAddress, Uri outputAddress)
 {
     QueryTemplate template = application.CreateQueryTemplate("QueryTemplate", null, streamDefinition);
     QueryBinder binder = new QueryBinder(template);
     InputAdapter inputAdapter = application.CreateInputAdapter<WcfInputAdapterFactory>("InputAdapter", null);
     binder.BindProducer("Input", inputAdapter, inputAddress, EventShape.Point);
     OutputAdapter outputAdapter = application.CreateOutputAdapter<WcfOutputAdapterFactory>("OutputAdapter", null);
     binder.AddConsumer("Output", outputAdapter, outputAddress, EventShape.Point, StreamEventOrder.FullyOrdered);
     Query query = application.CreateQuery("Query", null, binder);
     return query;
 }
Ejemplo n.º 14
0
 private static Query CreateQuery(Application application, CepStream<BrandQuote> streamDefinition, BrandQuoteInputConfig inputConfig, BrandQuoteOutputConfig outputConfig)
 {
     var template = application.CreateQueryTemplate("QueryTemplate", null, streamDefinition);
     var binder = new QueryBinder(template);
     var inputAdapter = application.CreateInputAdapter<BrandQuoteInputAdapterFactory>("InputAdapter", null);
     binder.BindProducer("Input", inputAdapter, inputConfig, EventShape.Point);
     var outputAdapter = application.CreateOutputAdapter<BrandQuoteOutputAdapterFactory>("OutputAdapter", null);
     binder.AddConsumer("Output", outputAdapter, outputConfig, EventShape.Point, StreamEventOrder.FullyOrdered);
     var query = application.CreateQuery("Query", null, binder);
     return query;
 }
Ejemplo n.º 15
0
        public void TestTwitter()
        {
            var streamInsightInstanceName = Properties.Settings.Default.InstanceName;
            var server      = Server.Create(streamInsightInstanceName);
            var application = server.CreateApplication("twittertest");

            var inputConfig = new TwitterConfig
            {
                Username = UserNameTbx.Text,
                Password = PasswordTbx.Text
            };

            if (FilterModeRbn.Checked)
            {
                inputConfig.Mode       = TwitterMode.Filter;
                inputConfig.Parameters = "track=" + FilterParametersTbx.Text;
            }
            else if (SampleModeRbn.Checked)
            {
                inputConfig.Mode = TwitterMode.Sample;
            }

            var input = CepStream <Tweet> .Create("twitter", typeof(TwitterFactory), inputConfig, EventShape.Point);

            // Configure output adapter
            var outputConfig = new StackerConfig
            {
                StackerCtlPipeName = stackerCtl1.PipeName,
                StackerCtlHostName = "localhost"
            };

            // Create query and bind to the output adapter
            query = input.ToQuery(application, "query", "...", typeof(StackerFactory), outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            // Start query
            query.Start();

            // Wait until query change state
            DiagnosticView diagnosticView;

            stopFlag = false;
            do
            {
                Thread.Sleep(100);
                diagnosticView = query.Application.Server.GetDiagnosticView(query.Name);
            } while (!stopFlag && (string)diagnosticView["QueryState"] == "Running");

            // Stop query
            query.Stop();

            application.Delete();
            server.Dispose();
        }
Ejemplo n.º 16
0
        private static void BindAndRunQuery <TPayload>(string queryName, CepStream <TPayload> queryStream, EventShape outputEventShape, List <string> inputFields, List <string> outputFields)
        {
            var inputConfig = new CsvInputConfig
            {
                InputFileName        = @"..\..\..\TollInput.txt",
                Delimiter            = new char[] { ',' },
                BufferSize           = 4096,
                CtiFrequency         = 1,
                CultureName          = "en-US",
                Fields               = inputFields,
                NonPayloadFieldCount = 2,
                StartTimePos         = 1,
                EndTimePos           = 2
            };

            // The adapter recognizes empty filename as a write to console.
            var outputConfig = new CsvOutputConfig
            {
                OutputFileName = string.Empty,
                Delimiter      = new string[] { "\t" },
                CultureName    = "en-US",
                Fields         = outputFields
            };

            // Note - Please change the instance name to the one you have chosen during installation
            using (var server = Server.Create("Default"))
            {
                Application application = server.CreateApplication("TollStationApp");

                // set up input and output adapters
                InputAdapter  inputAdapter  = application.CreateInputAdapter <CsvInputFactory>("input", "Csv Input Source");
                OutputAdapter outputAdapter = application.CreateOutputAdapter <CsvOutputFactory>("output", "Csv Output");

                // set up the query template
                QueryTemplate queryTemplate = application.CreateQueryTemplate("QueryTemplate", string.Empty, queryStream);

                // set up advance time settings to enqueue CTIs
                var advanceTimeGenerationSettings = new AdvanceTimeGenerationSettings(inputConfig.CtiFrequency, TimeSpan.Zero, true);
                var advanceTimeSettings           = new AdvanceTimeSettings(advanceTimeGenerationSettings, null, AdvanceTimePolicy.Adjust);

                // Bind query template to input and output streams
                QueryBinder queryBinder = new QueryBinder(queryTemplate);
                queryBinder.BindProducer <TollReading>("TollStream", inputAdapter, inputConfig, EventShape.Interval, advanceTimeSettings);
                queryBinder.AddConsumer("outputStream", outputAdapter, outputConfig, outputEventShape, StreamEventOrder.FullyOrdered);

                // Create a runnable query by binding the query template to the input stream of interval events,
                // and to an output stream of fully ordered point events (through an output adapter instantiated
                // from the output factory class)
                Query query = application.CreateQuery(queryName, "Hello Toll Query", queryBinder);

                RunQuery(query);
            }
        }
Ejemplo n.º 17
0
        public static void Main()
        {
            var cepStream = CepStream <MediationData> .Create("cepStream1");

            Console.WriteLine("\n-----------------------------Filter e.Number > 3\n");
            var filter = from e in cepStream
                         where e.Number > 3
                         select e;

            RunCepStream(filter);

            Console.WriteLine("\n-----------------------------Get average for HoppingWindow(3,1)\n");
            var avgCepStream = from w in cepStream.Where(e => true).HoppingWindow(TimeSpan.FromMinutes(3), TimeSpan.FromMinutes(1), HoppingWindowOutputPolicy.ClipToWindowEnd)
                               select new MediationData()
            {
                Direction = "Average",
                Number    = w.Avg(e => e.Number)
            };

            RunCepStream(avgCepStream);

            Console.WriteLine("\n-----------------------------Sum of TumblingWindow(3)\n");
            var count = from win in cepStream.TumblingWindow(TimeSpan.FromMinutes(3))
                        select new MediationData()
            {
                Direction = "Average",
                Number    = win.Sum(e => e.Number)
            };

            RunCepStream(count);

            Console.WriteLine("\n-----------------------------Group e.Direction With HoppingWindow(3,3)\n");
            var groupCepStream = from e in cepStream
                                 group e by e.Direction into eGroup
                                 from w in eGroup.HoppingWindow(TimeSpan.FromMinutes(3), TimeSpan.FromMinutes(3), HoppingWindowOutputPolicy.ClipToWindowEnd)
                                 select new MediationData()
            {
                Direction = eGroup.Key,
                Number    = w.Avg(e => e.Number)
            };

            RunCepStream(groupCepStream);

            Console.WriteLine("\n-----------------------------ShiftEvent by 7 min\n");
            var shiftEventCepStream = from e in cepStream.ShiftEventTime(e => e.StartTime.AddMinutes(7))
                                      select e;

            RunCepStream(shiftEventCepStream);

            application.Delete();
            server.Dispose();
        }
Ejemplo n.º 18
0
        // Creates a binary stream of which windows exceed the threshold and
        // returns true on the first timestamp of every Alpha epoch and false on every other occasion.
        public static CepStream<double> detectBraid(CepStream<CsvReading2> inputStream)
        {
            // It contains the values from the PSD calculation.
            var tmpStream = from e in inputStream
                            select e.Value1;

            var tmpStream2 = detect(tmpStream);

            //var tmpFlagString = from k in tmpStream2
            //                   select FlagConversion(k);

            return tmpStream2;
        }
Ejemplo n.º 19
0
        /// <summary>
        /// Creates and binds a query with a single input stream.
        /// </summary>
        private static Query CreateQuery(Application application, CepStream <EventType> streamDefinition, Uri inputAddress, Uri outputAddress)
        {
            QueryTemplate template     = application.CreateQueryTemplate("QueryTemplate", null, streamDefinition);
            QueryBinder   binder       = new QueryBinder(template);
            InputAdapter  inputAdapter = application.CreateInputAdapter <WcfInputAdapterFactory>("InputAdapter", null);

            binder.BindProducer("Input", inputAdapter, inputAddress, EventShape.Point);
            OutputAdapter outputAdapter = application.CreateOutputAdapter <WcfOutputAdapterFactory>("OutputAdapter", null);

            binder.AddConsumer("Output", outputAdapter, outputAddress, EventShape.Point, StreamEventOrder.FullyOrdered);
            Query query = application.CreateQuery("Query", null, binder);

            return(query);
        }
Ejemplo n.º 20
0
        public void TestFacebook()
        {
            var streamInsightInstanceName = Properties.Settings.Default.InstanceName;
            var server      = Server.Create(streamInsightInstanceName);
            var application = server.CreateApplication("facebooktest");

            var inputConfig = new FacebookConfig
            {
                AccessToken        = AccessTokenTbx.Text,
                UsernameOrUniqueId = UsernameOrUniqueIdTbx.Text,
                RefreshPeriod      = int.Parse(RefreshIntervalTbx.Text) * 1000
            };


            var input = CepStream <FacebookItem> .Create("facebook", typeof(FacebookFactory), inputConfig, EventShape.Point);

            // Configure output adapter
            var outputConfig = new StackerConfig
            {
                StackerCtlPipeName = stackerCtl1.PipeName,
                StackerCtlHostName = "localhost"
            };

            // Create query and bind to the output adapter
            var expr = from e in input
                       select new { e.Id, e.FromName, Message = !string.IsNullOrEmpty(e.Message) ? e.Message : e.Description };

            query = expr.ToQuery(application, "query", "...", typeof(StackerFactory), outputConfig, EventShape.Point, StreamEventOrder.FullyOrdered);

            // Start query
            query.Start();

            // Wait until query change state
            DiagnosticView diagnosticView;

            stopFlag = false;
            do
            {
                Thread.Sleep(100);
                diagnosticView = query.Application.Server.GetDiagnosticView(query.Name);
            } while (!stopFlag && (string)diagnosticView["QueryState"] == "Running");

            // Stop query
            query.Stop();

            application.Delete();
            server.Dispose();
        }
Ejemplo n.º 21
0
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            var streamInsightInstanceName = Properties.Settings.Default.InstanceName;
            var server      = Server.Create(streamInsightInstanceName);
            var application = server.CreateApplication("yahoofinancetest");

            // Configure output adapter
            var outputConfig = new StackerConfig
            {
                StackerCtlPipeName = stackerCtl1.PipeName,
                StackerCtlHostName = "localhost"
            };

            var inputConfig = new YahooFinanceConfig
            {
                StockSymbol = "^GSPC",
                StockName   = "S&P 500",
                Timeout     = 10000,
                Interval    = 1000
            };

            var input = CepStream <StockQuote> .Create("yahoo", typeof(YahooFinanceFactory), inputConfig, EventShape.Point);

            // Create query and bind to the output adapter
            query = input.ToQuery(application, "query", "...", typeof(StackerFactory), outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            // Start query
            query.Start();

            // Wait until query change state
            DiagnosticView diagnosticView;

            stopFlag = false;
            do
            {
                Thread.Sleep(100);
                diagnosticView = query.Application.Server.GetDiagnosticView(query.Name);
            } while (!stopFlag && (string)diagnosticView["QueryState"] == "Running");

            // Stop query
            query.Stop();

            Thread.Sleep(1000);

            application.Delete();
            server.Dispose();
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Example of using a user-defined filter
        /// </summary>
        /// <param name="application"></param>
        /// <param name="inputConfig"></param>
        /// <param name="outputConfig"></param>
        /// <param name="inputAdapter"></param>
        /// <param name="outputAdapter"></param>
        /// <returns></returns>
        private static Query createUserFilterExampleQuery(Application application, StockQuoteInputConfig inputConfig, StockQuoteOutputConfig outputConfig, InputAdapter inputAdapter, OutputAdapter outputAdapter)
        {
            var input = CepStream <StockQuote> .Create("input");

            var filteredCepStream = from e in input
                                    where UserDefinedFilter(e.FieldID)
                                    select e;
            var queryTemplate = application.CreateQueryTemplate("userFilterExampleTemplate", "Description...", filteredCepStream);

            var queryBinder = new QueryBinder(queryTemplate);

            queryBinder.BindProducer <StockQuote>("input", inputAdapter, inputConfig, EventShape.Point);
            queryBinder.AddConsumer <StockQuote>("output", outputAdapter, outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            var query = application.CreateQuery("userFilterExampleQuery", "Description...", queryBinder);

            return(query);
        }
Ejemplo n.º 23
0
        private static void runQuery(CepStream <StockQuote> cepStream)
        {
            var observer = new Observer();

            // Create waithandle to signal when query is finished
            var adapterStopSignal = new EventWaitHandle(false, EventResetMode.AutoReset, "StockInsightSignal");

            // This starts the query
            var disposable = cepStream.ToObservable <StockQuote>().Subscribe(observer);

            // Wait for query to finish
            adapterStopSignal.WaitOne();

            // Write a blank line
            Console.WriteLine();

            // This line has been commented out because it hangs sometimes
            disposable.Dispose();
        }
Ejemplo n.º 24
0
        /// <summary>[Q5] “Report the output whenever Toll Booth 2 has the same number
        /// of vehicles as Toll Booth 1, every time a change occurs in either stream”</summary>
        private static void RunJoinDemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var slidingWindowQuery = from e in inputStream.AlterEventDuration(e => TimeSpan.FromMinutes((double)3))
                                     group e by e.TollId into perTollBooth
                                     from w in perTollBooth.SnapshotWindow(SnapshotWindowOutputPolicy.Clip)
                                     select new Toll
            {
                TollId       = perTollBooth.Key,
                TollAmount   = w.Sum(e => e.Toll),
                VehicleCount = w.Count()
            };
            var stream1 = from e in slidingWindowQuery
                          where e.TollId.Equals(((int)1).ToString())
                          select e;
            var stream2 = from e in slidingWindowQuery
                          where e.TollId.Equals(((int)2).ToString())
                          select e;
            var queryStream = from e1 in stream1
                              join e2 in stream2
                              on e1.VehicleCount equals e2.VehicleCount
                              select new TollCompare
            {
                TollId1      = e1.TollId,
                TollId2      = e2.TollId,
                VehicleCount = e1.VehicleCount
            };

            BindAndRunQuery(
                "Join",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "TollId1", "TollId2", "VehicleCount"
            });
        }
Ejemplo n.º 25
0
        /// <summary>[Q12] “Over a one hour tumbling window, report all commercial vehicles
        /// with tonnage greater than one ton (2K lbs), along with their arrival
        /// times at the toll, and any charges due to weight violation. Overweight
        /// charges during the rush hour (7am to 7pm) are double that of non-rush hours”</summary>
        private static void RunUDODemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from w in inputStream.TumblingWindow(TimeSpan.FromHours((double)1), HoppingWindowOutputPolicy.ClipToWindowEnd)
                              select w.VehicleWeights();

            BindAndRunQuery(
                "UDO",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "LicensePlate", "Weight", "WeightCharge"
            });
        }
Ejemplo n.º 26
0
        private static void RunFilterProject()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from w in inputStream
                              where w.TollId == "1"
                              select w;

            BindAndRunQuery(
                "Tumbling",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            });
        }
Ejemplo n.º 27
0
        /// <summary>
        /// Bucket things based on position and take counts.
        /// </summary>
        /// <param name="app">The application that will host the query.</param>
        /// <param name="queryName">The name of the query.</param>
        /// <param name="queryDescription">The description of the query.</param>
        /// <param name="inputFile">The file to read input from.</param>
        /// <param name="outputPath">The path under which to put our output. This will go to a file of the form [app].[query].out</param>
        /// <param name="eventFrequency">How often the input adapter should produce events. Zero will produce them as fast as possible.</param>
        /// <returns>The new query.</returns>
        private static Query CreateBucketQuery(Application app, string queryName, string queryDescription, string inputFile, string outputPath, TimeSpan eventFrequency)
        {
            // Create a configuration for our input adapter.
            var inputConfig = new ReplayablePointCsvInputAdapterConfig(inputFile, eventFrequency);

            // Declare the input stream.
            var inputStream = CepStream <XYPayload> .Create(
                queryName + ":input",
                typeof(ReplayablePointCsvInputAdapterFactory),
                inputConfig,
                EventShape.Point,
                null);

            // Do some aggregation by leading digit of x and y coordinate.
            var q = from e in inputStream
                    group e by new { XBucket = (int)(e.X * 10), YBucket = (int)(e.Y * 10) } into xygroups
            from window in xygroups.TumblingWindow(TimeSpan.FromDays(1))
            select new
            {
                XBucket = xygroups.Key.XBucket,
                YBucket = xygroups.Key.YBucket,
                Count   = window.Count(),
                AvgX    = window.Avg(e => e.X),
                AvgY    = window.Avg(e => e.Y)
            };

            // Create the query. This declares which output adapter to use, and also configures
            // the query for resiliency.
            Query rval = q.ToQuery(
                app,
                queryName,
                queryDescription,
                typeof(DedupingPointCsvOuputAdapterFactory),
                new DedupingPointCsvOutputAdapterConfig(Path.Combine(outputPath, GetOutputFileName(app.ShortName, queryName)), new string[] { "XBucket", "YBucket", "AvgX", "AvgY", "Count" }),
                EventShape.Point,
                StreamEventOrder.FullyOrdered,
                true); // <== *** This says that the query is resilient and enables it for checkpointing. ***

            return(rval);
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Compare USD and SEK stock prices using given exchange rate. Example of a cross join.
        /// </summary>
        /// <param name="application"></param>
        /// <param name="ericUSDConfig"></param>
        /// <param name="ericSEKConfig"></param>
        /// <param name="USDSEKConfig"></param>
        /// <param name="outputConfig"></param>
        /// <param name="inputAdapter"></param>
        /// <param name="outputAdapter"></param>
        /// <returns></returns>
        private static Query createCrossJoinExampleQuery(Application application, StockQuoteInputConfig ericUSDConfig, StockQuoteInputConfig ericSEKConfig, StockQuoteInputConfig USDSEKConfig, StockQuoteOutputConfig outputConfig, InputAdapter inputAdapter, OutputAdapter outputAdapter)
        {
            var ericUSDStream = CepStream <StockQuote> .Create("ericUSDStream");

            var ericSEKStream = CepStream <StockQuote> .Create("ericSEKStream");

            var USDSEKStream = CepStream <StockQuote> .Create("USDSEKStream");

            var ericRecalcCepStream = from eUSD in ericUSDStream
                                      from eXch in USDSEKStream // Cross join
                                      where eUSD.FieldID == "Close"
                                      select new StockQuote()
            {
                StockID = "ERIC-Recalc",
                FieldID = "Close",
                Value   = eUSD.Value * eXch.Value                         // Convert ERIC USD quote to SEK
            };

            var ericCompareCepStream = from eRecalc in ericRecalcCepStream
                                       from eSEK in ericSEKStream
                                       where eSEK.FieldID == "Close"
                                       select new StockQuote()
            {
                StockID = "ERIC-Compare",
                FieldID = "Diff",
                Value   = eSEK.Value - eRecalc.Value
            };
            var queryTemplate = application.CreateQueryTemplate("ericCompareTemplate", "Description...", ericCompareCepStream);

            var queryBinder = new QueryBinder(queryTemplate);

            queryBinder.BindProducer <StockQuote>("ericUSDStream", inputAdapter, ericUSDConfig, EventShape.Point);
            queryBinder.BindProducer <StockQuote>("ericSEKStream", inputAdapter, ericSEKConfig, EventShape.Point);
            queryBinder.BindProducer <StockQuote>("USDSEKStream", inputAdapter, USDSEKConfig, EventShape.Point);
            queryBinder.AddConsumer <StockQuote>("output", outputAdapter, outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            var query = application.CreateQuery("ericCompareQuery", "Description...", queryBinder);

            return(query);
        }
Ejemplo n.º 29
0
        public QueriesCore(string instance, bool distinctNeeded)
        {
            // TODO: Complete member initialization
            this._distinctNeeded = distinctNeeded;
             _cepServer = Server.Create(instance);
            _cepApplication = _cepServer.CreateApplication("Monitor");

            _pingSource = new InputCollection<PageRequest>();
            _pingSourceGathering = new InputCollection<PageRequest>();

            _pingInputStream = _pingSource.ToPointStream(
                _cepApplication,
                s => PointEvent.CreateInsert(DateTime.UtcNow, s),
                AdvanceTimeSettings.IncreasingStartTime,
                "PagePingStream");

            _pingInputStreamGathering = _pingSourceGathering.ToPointStream(
                _cepApplication,
                s => PointEvent.CreateInsert(DateTime.UtcNow, s),
                AdvanceTimeSettings.IncreasingStartTime,
                "PagePingStream");
        }
Ejemplo n.º 30
0
        private static void RunQuery(CepStream <Payload> cepStream, Application application)
        {
            // Configure output adapter

            // Create query and bind to the output adapter
            var query = cepStream.ToQuery(application, Guid.NewGuid().ToString(), "description", typeof(PayloadOutputFactory), outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            // Start query
            query.Start();

            // Wait until query change state
            DiagnosticView diagnosticView;

            do
            {
                Thread.Sleep(100);
                diagnosticView = query.Application.Server.GetDiagnosticView(query.Name);
            } while ((string)diagnosticView[DiagnosticViewProperty.QueryState] == "Running");

            // Stop query
            query.Stop();
        }
Ejemplo n.º 31
0
        /// <summary>[tQ1] "Every 3 minutes, report the number of vehicles processed
        /// that were being processed at some point during that period at
        /// the toll station since the last result. Report the result at a
        /// point in time, at the beginning of the 3 minute window"</summary>
        private static void RunTumblingCountDemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var queryStream = from w in inputStream.TumblingWindow(TimeSpan.FromMinutes(3), HoppingWindowOutputPolicy.ClipToWindowEnd)
                              select new TollCount {
                Count = w.Count()
            };

            BindAndRunQuery(
                "Tumbling",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "Count"
            });
        }
Ejemplo n.º 32
0
        public QueriesCore(string instance, bool distinctNeeded)
        {
            // TODO: Complete member initialization
            this._distinctNeeded = distinctNeeded;
            _cepServer           = Server.Create(instance);
            _cepApplication      = _cepServer.CreateApplication("Monitor");

            _pingSource          = new InputCollection <PageRequest>();
            _pingSourceGathering = new InputCollection <PageRequest>();

            _pingInputStream = _pingSource.ToPointStream(
                _cepApplication,
                s => PointEvent.CreateInsert(DateTime.UtcNow, s),
                AdvanceTimeSettings.IncreasingStartTime,
                "PagePingStream");

            _pingInputStreamGathering = _pingSourceGathering.ToPointStream(
                _cepApplication,
                s => PointEvent.CreateInsert(DateTime.UtcNow, s),
                AdvanceTimeSettings.IncreasingStartTime,
                "PagePingStream");
        }
Ejemplo n.º 33
0
        /// <summary>[Q8] “Report the top 2 toll amounts from the results of Q4 over a 3 minute tumbling window”</summary>
        private static void RunTopKDemo()
        {
            var inputStream = CepStream <TollReading> .Create("TollStream");

            var groupedSliding = from e in inputStream.AlterEventDuration(e => TimeSpan.FromMinutes((double)3))
                                 group e by e.TollId into perTollBooth
                                 from w in perTollBooth.SnapshotWindow(SnapshotWindowOutputPolicy.Clip)
                                 select new Toll
            {
                TollId       = perTollBooth.Key,
                TollAmount   = w.Sum(e => e.Toll),
                VehicleCount = w.Count()
            };
            var queryStream = (from window in groupedSliding.TumblingWindow(TimeSpan.FromMinutes((double)3), HoppingWindowOutputPolicy.ClipToWindowEnd)
                               from e in window
                               orderby e.TollAmount descending
                               select e).Take(
                (uint)2,
                e => new TopEvents
            {
                TollRank     = e.Rank,
                TollAmount   = e.Payload.TollAmount,
                TollId       = e.Payload.TollId,
                VehicleCount = e.Payload.VehicleCount
            });

            BindAndRunQuery(
                "Top-K",
                queryStream,
                EventShape.Interval,
                new List <string>()
            {
                "TollId", "LicensePlate", "State", "Make", "Model", "VehicleType", "VehicleWeight", "Toll", "Tag"
            },
                new List <string>()
            {
                "TollRank", "TollAmount", "TollId", "VehicleCount"
            });
        }
Ejemplo n.º 34
0
        /// <summary>
        /// Example of using a user-defined aggregate
        /// </summary>
        /// <param name="application"></param>
        /// <param name="inputConfig"></param>
        /// <param name="outputConfig"></param>
        /// <param name="inputAdapter"></param>
        /// <param name="outputAdapter"></param>
        /// <returns></returns>
        private static Query createStandardDeviationExampleQuery(Application application, StockQuoteInputConfig inputConfig, StockQuoteOutputConfig outputConfig, InputAdapter inputAdapter, OutputAdapter outputAdapter)
        {
            var input = CepStream <StockQuote> .Create("input");

            var stddevCepStream = from w in input.Where(e => e.FieldID == "Close")
                                  .HoppingWindow(TimeSpan.FromDays(7), TimeSpan.FromDays(1), HoppingWindowOutputPolicy.ClipToWindowEnd)
                                  select new StockQuote()
            {
                StockID = "ERIC",
                FieldID = "7-day Stddev",
                Value   = w.StandardDeviation()
            };
            var queryTemplate = application.CreateQueryTemplate("standardDeviationExampleTemplate", "Description...", stddevCepStream);

            var queryBinder = new QueryBinder(queryTemplate);

            queryBinder.BindProducer <StockQuote>("input", inputAdapter, inputConfig, EventShape.Point);
            queryBinder.AddConsumer <StockQuote>("output", outputAdapter, outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            var query = application.CreateQuery("standardDeviationExampleQuery", "Description...", queryBinder);

            return(query);
        }
Ejemplo n.º 35
0
 private static CepStream<double> detect(CepStream<double> inputStream)
 {
     return from win in inputStream.TumblingWindow<double>(TimeSpan.FromMinutes(6))
            select win.BraidAgg<double>(e => e);
 }
Ejemplo n.º 36
0
        private static void runQuery(CepStream<StockQuote> cepStream)
        {
            var observer = new Observer();

            // Create waithandle to signal when query is finished
            var adapterStopSignal = new EventWaitHandle(false, EventResetMode.AutoReset, "StockInsightSignal");

            // This starts the query
            var disposable = cepStream.ToObservable<StockQuote>().Subscribe(observer);

            // Wait for query to finish
            adapterStopSignal.WaitOne();

            // Write a blank line
            Console.WriteLine();

            // This line has been commented out because it hangs sometimes
            disposable.Dispose();
        }
Ejemplo n.º 37
0
        /// <summary>
        /// Example of utilising a user defined function for filtering
        /// </summary>
        /// <param name="ericUSDStream"></param>
        /// <param name="outputConfig"></param>
        /// <param name="adapterStopSignal"></param>
        private static void userFilterExample(CepStream<StockQuote> cepStream, Application application)
        {
            var filteredCepStream = from e in cepStream
                                    where UserDefinedFilter(e.FieldID)
                                    select e;

            runQuery(filteredCepStream, application);
        }
Ejemplo n.º 38
0
        /// <summary>
        /// Example of using a custom aggregation function for standard deviation calculation.
        /// </summary>
        /// <param name="ericUSDStream"></param>
        /// <param name="outputConfig"></param>
        /// <param name="adapterStopSignal"></param>
        private static void standardDeviationExample(CepStream<StockQuote> cepStream, Application application)
        {
            var stddevCepStream = from w in cepStream.Where(e => e.FieldID == "Close")
                                                             .HoppingWindow(TimeSpan.FromDays(7), TimeSpan.FromDays(1), HoppingWindowOutputPolicy.ClipToWindowEnd)
                                  select new StockQuote()
                                  {
                                      StockID = "ERIC",
                                      FieldID = "7-day Stddev",
                                      Value = w.StandardDeviation()
                                  };

            runQuery(stddevCepStream, application);
        }
Ejemplo n.º 39
0
        /// <summary>
        /// Binds a stream to output adapter and runs the query
        /// </summary>
        /// <param name="cepStream"></param>
        private static void runQuery(CepStream<StockQuote> cepStream, Application application)
        {
            // Configure output adapter
            var outputConfig = new StockQuoteOutputConfig();

            // Create query and bind to the output adapter
            var query = cepStream.ToQuery(application, Guid.NewGuid().ToString(), "description", typeof(StockQuoteOutputFactory), outputConfig, EventShape.Point, StreamEventOrder.ChainOrdered);

            // Start query
            query.Start();

            // Wait until query change state
            DiagnosticView diagnosticView;
            do
            {
                Thread.Sleep(100);
                diagnosticView = query.Application.Server.GetDiagnosticView(query.Name);
            } while ((string)diagnosticView[DiagnosticViewProperty.QueryState] == "Running");

            // Stop query
            query.Stop();
        }
Ejemplo n.º 40
0
        /// <summary>
        /// Example of a grouping and average calculation on the groups
        /// </summary>
        /// <param name="ericUSDStream"></param>
        /// <param name="outputConfig"></param>
        /// <param name="adapterStopSignal"></param>
        private static void groupApplyExample(CepStream<StockQuote> ericUSDStream, Application application)
        {
            var ericUSDGroupCepStream = from e in ericUSDStream
                                        group e by e.FieldID into eGroup
                                        from w in eGroup.HoppingWindow(TimeSpan.FromDays(7), TimeSpan.FromDays(1), HoppingWindowOutputPolicy.ClipToWindowEnd)
                                        select new StockQuote()
                                        {
                                            StockID = "ERIC 7-day avg",
                                            FieldID = eGroup.Key,
                                            Value = w.Avg(e => e.Value)
                                        };

            runQuery(ericUSDGroupCepStream, application);
        }
Ejemplo n.º 41
0
        /// <summary>
        /// Example of filter function
        /// </summary>
        /// <param name="cepStream"></param>
        /// <param name="outputConfig"></param>
        /// <param name="adapterStopSignal"></param>
        private static void filterExample(CepStream<StockQuote> cepStream, Application application)
        {
            // Return only "Close" values using a where-clause
            var filteredCepStream = from e in cepStream
                                    where e.FieldID == "Close"
                                    select e;

            runQuery(filteredCepStream, application);
        }
Ejemplo n.º 42
0
        /// <summary>
        /// Example of cross join and projections
        /// </summary>
        /// <param name="ericSEKStream"></param>
        /// <param name="ericUSDStream"></param>
        /// <param name="USDSEKStream"></param>
        private static void crossJoinProjectionExample(CepStream<StockQuote> ericSEKStream, CepStream<StockQuote> ericUSDStream, CepStream<StockQuote> USDSEKStream, Application application)
        {
            var ericRecalcCepStream = from eUSD in ericUSDStream
                                      from eXch in USDSEKStream
                                      where eUSD.FieldID == "Close"
                                      select new StockQuote()
                                      {
                                          StockID = "ERIC-Recalc",
                                          FieldID = "Close",
                                          Value = eUSD.Value * eXch.Value // Convert ERIC USD quote to SEK
                                      };

            var ericCompareCepStream = from eRecalc in ericRecalcCepStream
                                       from eSEK in ericSEKStream
                                       where eSEK.FieldID == "Close"
                                       select new StockQuote()
                                       {
                                           StockID = "ERIC-Compare",
                                           FieldID = "Diff",
                                           Value = eSEK.Value - eRecalc.Value
                                       };

            runQuery(ericCompareCepStream, application);
        }
Ejemplo n.º 43
0
        /// <summary>
        /// Example of detecting price drops larger than 10% in 7 days
        /// </summary>
        /// <param name="ericUSDStream"></param>
        /// <param name="outputConfig"></param>
        /// <param name="adapterStopSignal"></param>
        private static void bigLooserExample(CepStream<StockQuote> cepStream, Application application)
        {
            var bigLooserCepStream = (from e1 in cepStream
                                      from e2 in cepStream.ShiftEventTime(e => e.StartTime.AddDays(7))
                                      where e1.FieldID == "Close" && e2.FieldID == "Close"
                                      select new StockQuote()
                                      {
                                          StockID = "ERIC > 10% drop",
                                          FieldID = "Close",
                                          Value = (e1.Value - e2.Value) / e2.Value * 100
                                      }).Where(e => e.Value < -10);

            runQuery(bigLooserCepStream, application);
        }
Ejemplo n.º 44
0
        /// <summary>
        /// Example of window function
        /// </summary>
        /// <param name="cepStream"></param>
        /// <param name="outputConfig"></param>
        /// <param name="adapterStopSignal"></param>
        private static void avgExample(CepStream<StockQuote> cepStream, Application application)
        {
            var avgCepStream = from w in cepStream.Where(e => e.FieldID == "Close")
                                                             .HoppingWindow(TimeSpan.FromDays(7), TimeSpan.FromDays(1), HoppingWindowOutputPolicy.ClipToWindowEnd)
                               select new StockQuote()
                               {
                                   StockID = "ERIC",
                                   FieldID = "7-day avg",
                                   Value = w.Avg(e => e.Value)
                               };

            runQuery(avgCepStream, application);
        }