コード例 #1
0
        private void RouteTheKey(string typeName, ReceiveFeedv2 feed, dbEntities db)
        {
            switch (typeName)
            {
            case "odds_change":
                OddsChange(UtcHelper.Deserialize <odds_change>(feed.Data), db, feed.RouteKey);
                break;

            case "bet_stop":
                BetStop(UtcHelper.Deserialize <bet_stop>(feed.Data), db, feed.RouteKey);
                break;

            case "bet_settlement":
                BetSettlement(UtcHelper.Deserialize <bet_settlement>(feed.Data), db, feed.RouteKey);
                break;

            case "cancelbet":
                BetCancel(UtcHelper.Deserialize <bet_cancel>(feed.Data), db, feed.RouteKey);
                break;

            case "producer_down":
                ProducerUpDown(UtcHelper.Deserialize <ProducerModel>(feed.Data), db, feed.RouteKey);
                break;

            case "producer_up":
                ProducerUpDown(UtcHelper.Deserialize <ProducerModel>(feed.Data), db, feed.RouteKey);
                break;

            case "rollback_betsettlement":
                SerilogHelper.Error($"{feed.RouteKey}");
                break;

            case "rollback_cancelbet":
                SerilogHelper.Error($"{feed.RouteKey}");
                break;

            case "fixture_change":
                FixtureChange(UtcHelper.Deserialize <fixture_change>(feed.Data), db, feed.RouteKey);
                break;

            default:
                SerilogHelper.Error($"{feed.RouteKey}");
                break;
            }
        }
コード例 #2
0
        /*public void ReceiveFeeds()
         * {
         *  var _rbService = new RabbitMQService();
         *  var conn = _rbService.GetRabbitMQConnection();
         *  var _feed = conn.CreateModel();
         *
         *  _feed.ExchangeDeclare("FeedsV2", durable: true, type: ExchangeType.Fanout);
         *  var queName = _feed.QueueDeclare().QueueName;
         *  _feed.QueueBind(queName, "FeedsV2", "UOFFeeder");
         *  _feed.BasicQos(0, 1, false);
         *  var consumer = new EventingBasicConsumer(_feed);
         *  _feed.BasicConsume(queName, false, consumer);
         *  SerilogHelper.Information($"Connected FeedsV2 {queName}");
         *
         *  consumer.Received += (model, ea) =>
         *  {
         *
         *      var body = ea.Body;
         *      var data = Encoding.UTF8.GetString(body);
         *      var _data = JsonConvert.DeserializeObject<ReceiveFeed>(data);
         *      switch (_data.TypeName)
         *      {
         *          case "OddsChange":
         *              Program.feedMainQueue.Enqueue(_data);
         *              break;
         *          case "FixtureChange":
         *              Program.feedSecondQueue.Enqueue(_data);
         *              break;
         *          case "BetSettlement":
         *              Program.feedSecondQueue.Enqueue(_data);
         *              break;
         *          case "BetCancel":
         *              Program.feedSecondQueue.Enqueue(_data);
         *              break;
         *          case "BetStop":
         *              Program.feedMainQueue.Enqueue(_data);
         *              break;
         *          default:
         *              Program.feedMainQueue.Enqueue(_data);
         *              break;
         *      }
         *      _feed.BasicAck(ea.DeliveryTag, false);
         *  };
         * }
         * public void FeedMainQueueToDb()
         * {
         *  while (true)
         *  {
         *      try
         *      {
         *          if (!Program.feedMainQueue.Any()) continue;
         *
         *          using (dbEntities db = new dbEntities())
         *          {
         *              db.Database.Log = SerilogHelper.Verbose;
         *              while (Program.feedMainQueue.TryDequeue(out ReceiveFeed feed))
         *              {
         *                  switch (feed.TypeName)
         *                  {
         *                      case "OddsChange":
         *                          OddsChange(UtcHelper.Deserialize<odds_change>(feed.Data), db);
         *                          break;
         *                      case "BetStop":
         *                          BetStop(UtcHelper.Deserialize<bet_stop>(feed.Data), db);
         *                          break;
         *                      default:
         *                          SerilogHelper.Error($"{feed.TypeName}");
         *                          break;
         *                  }
         *
         *                  if (Program.feedMainQueue.Count() > 10)
         *                      SerilogHelper.Error($"{Program.feedMainQueue.Count()} -> Queue count for feedMainQueue");
         *              }
         *          }
         *      }
         *      catch (Exception ex)
         *      {
         *          SerilogHelper.Exception("FeedToDb", $"Error when importing process!", ex);
         *      }
         *  }
         *
         * }
         * public void FeedSecondQueueToDb()
         * {
         *  while (true)
         *  {
         *      try
         *      {
         *          if (!Program.feedSecondQueue.Any()) continue;
         *
         *          using (dbEntities db = new dbEntities())
         *          {
         *              db.Database.Log = SerilogHelper.Verbose;
         *              while (Program.feedSecondQueue.TryDequeue(out ReceiveFeed feed))
         *              {
         *                  switch (feed.TypeName)
         *                  {
         *                      case "FixtureChange":
         *                          FixtureChange(UtcHelper.Deserialize<fixture_change>(feed.Data), db);
         *                          break;
         *                      case "BetSettlement":
         *                          BetSettlement(UtcHelper.Deserialize<bet_settlement>(feed.Data), db);
         *                          break;
         *                      case "BetCancel":
         *                          BetCancel(UtcHelper.Deserialize<bet_cancel>(feed.Data), db);
         *                          break;
         *                      default:
         *                          break;
         *                  }
         *
         *                  if (Program.feedSecondQueue.Count() > 10)
         *                      SerilogHelper.Error($"{Program.feedSecondQueue.Count()} -> Queue count for feedSecondQueue");
         *              }
         *          }
         *
         *      }
         *      catch (Exception ex)
         *      {
         *          SerilogHelper.Exception("FeedToDb", $"Error when importing process!", ex);
         *      }
         *  }
         *
         * }*/
        #endregion

        #region Proxy vie SDK v2
        public static void ReceiveFeeds()
        {
            var rbService = new RabbitMQService();
            var conn      = rbService.GetRabbitMQConnection();
            var feed      = conn.CreateModel();

            feed.ExchangeDeclare("FeedsV2", durable: true, type: ExchangeType.Fanout);
            var queName = feed.QueueDeclare().QueueName;

            feed.QueueBind(queName, "FeedsV2", "");
            feed.BasicQos(0, 1, false);
            var consumer = new EventingBasicConsumer(feed);

            feed.BasicConsume(queName, false, consumer);
            SerilogHelper.Information($"Connected FeedsV2 {queName}");

            consumer.Received += (model, ea) =>
            {
                var data = new ReceiveFeedv2()
                {
                    Data = Encoding.UTF8.GetString(ea.Body), RouteKey = ea.RoutingKey
                };

                switch (ea.RoutingKey.Split('.').Skip(1).FirstOrDefault())
                {
                case "-":
                    Program.feedHiQueue.Enqueue(data);
                    break;

                case "pre":
                    Program.feedLoQueue.Enqueue(data);
                    break;

                case "virt":
                    Program.feedLoQueue.Enqueue(data);
                    break;

                default:
                    Program.feedHiQueue.Enqueue(data);
                    break;
                }

                feed.BasicAck(ea.DeliveryTag, false);
            };
        }