Esempio n. 1
0
 public RunController(IConfiguration configuration, UserManager <ApplicationUser> userManager)
 {
     _userManager         = userManager;
     _configuration       = configuration;
     _runnerRepository    = new RunnerRepository(_configuration["ConnectionStrings:DB"]);
     _activityRepository  = new ActivityRepository(_configuration["ConnectionStrings:DB"]);
     _telemetryRepository = new TelemetryRepository(_configuration["ConnectionStrings:DB"]);
 }
        public void CreateNewRepositoryAndDoubleOpen()
        {
            if (File.Exists(TestConstants.RAMDISK + "\\logs1.xml"))
                File.Delete(TestConstants.RAMDISK + "\\logs1.xml");

            TelemetryRepository repo1 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs1.xml");
            TelemetryRepository repo2 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs1.xml");

            // should not throw errors, because the file hasn't been created yet.
            repo1.Export();

            Assert.IsTrue(File.Exists(TestConstants.RAMDISK+"\\logs1.xml"));

            TelemetryRepository repo3 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs1.xml");
        }
Esempio n. 3
0
        public void CreateNewRepositoryAndDoubleOpen()
        {
            if (File.Exists(TestConstants.RAMDISK + "\\logs1.xml"))
            {
                File.Delete(TestConstants.RAMDISK + "\\logs1.xml");
            }

            TelemetryRepository repo1 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs1.xml");
            TelemetryRepository repo2 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs1.xml");

            // should not throw errors, because the file hasn't been created yet.
            repo1.Export();

            Assert.IsTrue(File.Exists(TestConstants.RAMDISK + "\\logs1.xml"));

            TelemetryRepository repo3 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs1.xml");
        }
        public void CreateNewRepositoryAndReadIt()
        {
            if(File.Exists(TestConstants.RAMDISK + "\\logs.xml"))
                File.Delete(TestConstants.RAMDISK + "\\logs.xml");
            TelemetryRepository repo = new TelemetryRepository(TestConstants.RAMDISK + "\\logs.xml");

            Assert.AreEqual(0, repo.GetAll().Count());

            repo.Add(new TelemetryLog(1, "test/test.zip"));

            Assert.AreEqual(1, repo.GetAll().Count());

            repo.Export();

            TelemetryRepository repo2 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs.xml");
            Assert.AreEqual(1, repo2.GetAll().Count());
        }
        public static void Run([EventHubTrigger("itsrunningeventhub", Connection = "EventHubCS")] string myEventHubMessage, TraceWriter log)
        {
            log.Info($"C# Event Hub trigger function processed a message: {myEventHubMessage}");
            var message = JsonConvert.DeserializeObject <TelemetryData>(myEventHubMessage);

            string cs        = Environment.GetEnvironmentVariable("SqlConnectionString");
            var    db        = new TelemetryRepository(cs);
            var    telemetry = new Telemetry()
            {
                Latitude   = message.Latitude,
                Longitude  = message.Longitude,
                Instant    = message.Instant,
                IdActivity = message.IdActivity
            };

            db.Insert(telemetry, message.Username);
        }
Esempio n. 6
0
        public void CreateNewRepositoryAndReadIt()
        {
            if (File.Exists(TestConstants.RAMDISK + "\\logs.xml"))
            {
                File.Delete(TestConstants.RAMDISK + "\\logs.xml");
            }
            TelemetryRepository repo = new TelemetryRepository(TestConstants.RAMDISK + "\\logs.xml");

            Assert.AreEqual(0, repo.GetAll().Count());

            repo.Add(new TelemetryLog(1, "test/test.zip"));

            Assert.AreEqual(1, repo.GetAll().Count());

            repo.Export();

            TelemetryRepository repo2 = new TelemetryRepository(TestConstants.RAMDISK + "\\logs.xml");

            Assert.AreEqual(1, repo2.GetAll().Count());
        }
Esempio n. 7
0
        public static void Run([QueueTrigger("coordinates-queue", Connection = "StorageConnectionString")] string queueItem, TraceWriter log)
        {
            var listOfCoordinates = JsonConvert.DeserializeObject <IEnumerable <TelemetryMessageModel> >(queueItem);

            string cs = Environment.GetEnvironmentVariable("RunnersDbConnectionString", EnvironmentVariableTarget.Process);
            TelemetryRepository repository = new TelemetryRepository(cs);

            foreach (TelemetryMessageModel item in listOfCoordinates)
            {
                var telemetry = new Telemetry()
                {
                    Latitude   = item.Latitude,
                    Longitude  = item.Longitude,
                    Instant    = DateTimeOffset.Now,
                    IdRunner   = 1,
                    IdActivity = 1,
                    SelfiUri   = "fodengURI"
                };
                //ERROR: file or assembly not found
                repository.Insert(telemetry);
            }
        }
Esempio n. 8
0
        public void SetUp()
        {
            _mockfactory             = new MockRepository(MockBehavior.Default);
            _fakeTelemetry           = _mockfactory.Create <ITelemetry>();
            _fakeTelemetryRepository = _mockfactory.Create <ITelemetryRepository>();

            _fakeTelemetry.SetupGet(x => x.Id).Returns(It.IsAny <Guid>());
            _fakeTelemetry.SetupGet(x => x.Car).Returns(It.IsAny <Car>());
            _fakeTelemetry.SetupGet(x => x.Lap).Returns(It.IsAny <Lap>());
            _fakeTelemetry.SetupGet(x => x.TimeStamp).Returns(It.IsAny <DateTime>());


            _fakeTelemetryRepository.Setup(x => x.GetById(It.IsAny <Guid>())).Returns(new Telemetry()
            {
                Car       = _fakeTelemetry.Object.Car,
                Id        = _fakeTelemetry.Object.Id,
                Lap       = _fakeTelemetry.Object.Lap,
                TimeStamp = _fakeTelemetry.Object.TimeStamp
            });


            _repository = new TelemetryRepository(new ReadData());
        }
 public TelemetryController(TelemetryRepository repository, TelemetryHub hub)
 {
     _repository = repository;
     _hub        = hub;
 }
Esempio n. 10
0
 public TelemetryService(TelemetryRepository telemetryRepository)
 {
     this.telemetryRepository = telemetryRepository;
 }
Esempio n. 11
0
        static async Task Main(string[] args)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
            IConfigurationRoot configuration = builder.Build();

            // Retrieve storage account from connection string.
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
                configuration.GetConnectionString("StorageConnectionString"));

            // Create the queue client.
            CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();

            // Retrieve a reference to a queue.
            CloudQueue queue = queueClient.GetQueueReference(
                configuration.GetConnectionString("QueueName"));

            TelemetryRepository repository = new TelemetryRepository(
                configuration.GetConnectionString("RunnersDbConnectionString"));

            while (true)
            {
                var message = await queue.GetMessageAsync();

                if (message == null)
                {
                    await Task.Delay(1000);

                    continue;
                }

                /*
                 * JObject jsonMessage = JObject.Parse(message.AsString);
                 *
                 * int idActivity = (int)jsonMessage["ActivityId"];
                 * int idRunner = (int)jsonMessage["RunnerId"];
                 *
                 * IList<JToken> results = jsonMessage["Telemetry"].Children().ToList();
                 * var listOfCoordinates = new List<TelemetryModel>();
                 * foreach (JToken result in results)
                 * {
                 *  TelemetryModel searchResult = result.ToObject<TelemetryModel>();
                 *  listOfCoordinates.Add(searchResult);
                 * }
                 */

                var messageDeserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <TelemetryModel>(message.AsString);

                var telemetry = new Telemetry()
                {
                    Latitude   = messageDeserialized.Latitude,
                    Longitude  = messageDeserialized.Longitude,
                    Instant    = messageDeserialized.Instant,
                    IdActivity = messageDeserialized.ActivityId,
                    SelfiUri   = null
                };
                repository.Insert(telemetry);

                Console.WriteLine(message.Id + " - is on databese");

                //delete item in queue when message is inserted on database
                await queue.DeleteMessageAsync(message);
            }
        }
Esempio n. 12
0
        static async Task Main(string[] args)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile(
                "appsettings.json",
                optional: true,
                reloadOnChange: true);
            var configuration = builder.Build();

            string sqlConnectionString = configuration["ConnectionStrings:SqlDb"];
            IActivityRepository  activityRepository  = new ActivityRepository(sqlConnectionString);
            IRunnerRepository    runnerRepository    = new RunnerRepository(sqlConnectionString);
            ITelemetryRepository telemetryRepository = new TelemetryRepository(sqlConnectionString);

            string       serviceBusConnectionString = configuration["ConnectionStrings:ServiceBus"];
            string       queueName             = configuration["ServiceBusQueueName"];
            IQueueClient queueClient           = new QueueClient(serviceBusConnectionString, queueName);
            var          messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
            {
                MaxConcurrentCalls = 1,
                AutoComplete       = false
            };

            queueClient.RegisterMessageHandler(
                async(message, cancellationToken) =>
            {
                var bytes         = message.Body;
                var json          = Encoding.UTF8.GetString(bytes);
                var content       = JsonConvert.DeserializeObject <JObject>(json);
                var requestType   = content.Value <string>("RequestType");
                Boolean completed = false;

                switch (requestType)
                {
                case "NewTrainingRequest":
                    {
                        var runnerUsername = content.Value <string>("RunnerUsername");
                        Runner runner      = runnerRepository.GetByUsername(runnerUsername);
                        var activity       = new Activity()
                        {
                            Name         = content.Value <string>("Name"),
                            IdRunner     = runner.Id,
                            CreationDate = content.Value <DateTime>("Date"),
                            Location     = content.Value <string>("Location"),
                            UriMatch     = content.Value <string>("UriMatch"),
                            Type         = 1,
                            State        = 0
                        };
                        activityRepository.Insert(activity);
                        completed = true;
                        break;
                    }

                case "StartTrainingRequest":
                    {
                        var idActivity = content.Value <int>("IdActivity");
                        var activity   = activityRepository.Get(idActivity);
                        activity.State = 1;
                        activityRepository.Update(activity);
                        completed = true;
                        break;
                    }

                /*case "ListTrainingRequest":
                 *  {
                 *      var runnerUsername = content.Value<string>("RunnerUsername");
                 *      var response = new ListTrainingResponse()
                 *      {
                 *          Activities = activityRepository.GetByTypeAndUsername(1, runnerUsername),
                 *          RunnerUsername = runnerUsername
                 *      };
                 *      var notificationJson = JsonConvert.SerializeObject(response);
                 *      var notificationBytes = Encoding.UTF8.GetBytes(notificationJson);
                 *      var topicMessage = new Message(notificationBytes);
                 *
                 *      string serviceBusTopicConnectionString = configuration["ConnectionStrings:ServiceBusTopic"];
                 *      string topicName = configuration["ServiceBusTopicName"];
                 *      var topicClient = new TopicClient(serviceBusTopicConnectionString, topicName);
                 *      await topicClient.SendAsync(topicMessage);
                 *      await topicClient.CloseAsync();
                 *      completed = true;
                 *      break;
                 *  }*/
                case "DeleteActivityRequest":
                    {
                        var idActivity = content.Value <int>("IdActivity");
                        activityRepository.Delete(idActivity);
                        completed = true;
                        break;
                    }

                case "UpdateSelfieRequest":
                    {
                        var uriPic     = content.Value <string>("UriPic");
                        var idActivity = content.Value <int>("IdActivity");
                        var instant    = content.Value <DateTime>("Instant");
                        telemetryRepository.Update(uriPic, idActivity, instant);
                        completed = true;
                        break;
                    }

                default:
                    await queueClient.AbandonAsync(message.SystemProperties.LockToken);
                    break;
                }
                if (completed)
                {
                    await queueClient.CompleteAsync(message.SystemProperties.LockToken);
                }
                else
                {
                    await queueClient.AbandonAsync(message.SystemProperties.LockToken);
                }
            }, messageHandlerOptions);
            //insert an option to don't make the worker always active with no messages in the queue
            await Task.Delay(Timeout.Infinite);

            //await queueClient.CloseAsync();
        }
Esempio n. 13
0
        static void Main(string[] args)
        {
            /*
             * This must:
             * Receive EventHub messages from configuration["EventHubToOrganizerEntityPath"]
             * Send EventHub messages from the organizer client to the other worker
             */


            // Read configuration file to get the storage connection string
            var builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            var configuration = builder.Build();

            /*
             * First of all, initialize all repositories.
             * They all connect to the same database (here, it's the local "Organizer" database)
             */
            Console.WriteLine("Initializing repositories...");

            var sqlConnectionString = configuration["SqlConnectionString"];

            activityRepository  = new ActivityRepository(sqlConnectionString);
            telemetryRepository = new TelemetryRepository(sqlConnectionString);
            userRepository      = new UserRepository(sqlConnectionString);



            Console.WriteLine("Connecting to queue...");

            /*
             * Connect to the queue used to send messages to the other worker
             */
            queueToOtherWorker = new ServiceBusManager(configuration["ServiceBusConnectionString"], configuration["ServiceBusQueueName"]);

            //--



            /*
             * Listen to messages on the Event Hub
             * (entity path for messages sent both by the organizer web app and the other worker)
             */
            Console.WriteLine("Listening for messages...");
            var eventProcessorHost = new EventProcessorHost(
                configuration["EventHubToOrganizerEntityPath"],
                PartitionReceiver.DefaultConsumerGroupName,
                configuration["EventHubConnectionString"],
                configuration["StorageConnectionString"],
                configuration["HubToOrganizerContainerName"]);

            eventProcessorHost.RegisterEventProcessorAsync <WorkerCommandManager>().GetAwaiter().GetResult();

            /*
             * Wait until something happened.
             */
            while (true)
            {
                Task.Delay(1000);
            }
        }
Esempio n. 14
0
        static void Main(string[] args)
        {
            // Read configuration file to get the storage connection string
            var builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            var configuration = builder.Build();



            /*
             * Initialize the required repositories
             */
            Console.WriteLine("Initializing repositories...");
            var sqlConnectionString = configuration["SqlConnectionString"];

            activityRepository  = new ActivityRepository(sqlConnectionString);
            userRepository      = new UserRepository(sqlConnectionString);
            telemetryRepository = new TelemetryRepository(sqlConnectionString);

            /*
             * Connect to the Service Bus Queues
             */
            var storageConnectionString = configuration["StorageConnectionString"];

            /*
             * BLOB Storage
             */
            blobStorage = new BlobManager(storageConnectionString);
            Console.WriteLine("Connecting to blob containers...");
            // For telemetry pictures
            var activityContainerName = configuration["BlobContainerName"];

            blobSend = blobStorage.GetContainerReference(activityContainerName);

            // For user account pictures
            var userpicContainerName = configuration["UserpicContainerName"];

            userpicSend = blobStorage.GetContainerReference(userpicContainerName);


            Console.WriteLine("Connecting to queues...");

            /*
             * Service Bus
             */

            /*
             * Service bus for sending messages back to the runner (used for redirects)
             */
            var busConnectionString  = configuration["ServiceBusConnectionString"];
            var busQueueToRunnerName = configuration["ServiceBusQueueToRunnerName"];

            responseClient = new ServiceBusManager(busConnectionString, busQueueToRunnerName);

            /*
             * Service bus to receive messages from the runner
             */
            var busQueueName = configuration["ServiceBusQueueName"];

            queueClient = new QueueClient(busConnectionString, busQueueName);
            var messageHandlerOptions = new MessageHandlerOptions(new Func <Microsoft.Azure.ServiceBus.ExceptionReceivedEventArgs, Task>(
                                                                      async(e) => {
                var x = e.ToString();
                throw e.Exception;
            }))
            {
                MaxConcurrentCalls = 1,
                AutoComplete       = false
            };

            queueClient.RegisterMessageHandler(ProcessBusMessage, messageHandlerOptions);


            /*
             * Event Hubs
             */
            var hubConnectionString = configuration["EventHubConnectionString"];

            /*
             * Event Hub to send messages to the other worker (name is a misnomer)
             */
            var hubToOrganizerEntityPath = configuration["EventHubToOrganizerEntityPath"];

            eventHubSendToOrganizer = new EventHubManager(hubConnectionString, hubToOrganizerEntityPath);

            /*
             * Event Hub to receive telemetry data (from the runner)
             * REQUIRES a table storage to keep data
             */

            var hubToWorkerContainerName = configuration["HubToWorkerContainerName"];
            var hubToWorkerEntityPath    = configuration["EventHubToWorkerEntityPath"]; // Name
            var eventProcessorHost       = new EventProcessorHost(
                hubToWorkerEntityPath,
                PartitionReceiver.DefaultConsumerGroupName,
                hubConnectionString,
                storageConnectionString,
                hubToWorkerContainerName);

            eventProcessorHost.RegisterEventProcessorAsync <WorkerCommandManager>().GetAwaiter().GetResult();

            // eventHubReceive.RegisterEventProcessor<WorkerCommandManager>(hubToWorkerEntityPath, connectionString,
            //    hubToWorkerContainerName).GetAwaiter().GetResult();

            while (true)
            {
                Task.Delay(1000);
            }
        }