protected virtual void threadLoop() { QueueStorageMessage active_message = new QueueStorageMessage(); bool pending_statements = false; while (running || pending_statements == true) { pending_statements = false; TLC.Report(); try { bool message_found = false; lock (queueStatements) { int statements_count = queueStatements.Count(); if (statements_count > 0) { if (statements_count > 1) { pending_statements = true; } QueueStorageMessage candidate = queueStatements[0]; active_message = candidate; queueStatements.Remove(candidate); message_found = true; } } if (message_found) { if (active_message.code == QueueStorageCode.insertTransaction) { insertTransactionInternal((Transaction)active_message.data); } else if (active_message.code == QueueStorageCode.insertBlock) { insertBlockInternal((Block)active_message.data); } } else { // Sleep for 10ms to prevent cpu waste Thread.Sleep(10); } } catch (Exception e) { Logging.error("Exception occured in storage thread loop: " + e); } Thread.Yield(); } cleanupCache(); }
public static async System.Threading.Tasks.Task RunAsync([QueueTrigger("mapqueue", Connection = "AzureWebJobsStorage")] string queueMessage, TraceWriter log) { try { // Create the HttpClient var client = new HttpClient(); // Convert Json message back to its original object (lon, lat, blobname, blobcontainerreference) QueueStorageMessage queueStorageMessage = JsonConvert.DeserializeObject <QueueStorageMessage>(queueMessage); // Retrieve storage account CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("AzureWebJobsStorage")); // Retrieve container if it exists, create one if not CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); var container = blobClient.GetContainerReference("mapblob"); await container.CreateIfNotExistsAsync(); // Create the blob CloudBlockBlob blockBlob = container.GetBlockBlobReference(queueStorageMessage.blobName); // Retrieve the picture for the given city using its lat and lon var url = String.Format("https://atlas.microsoft.com/map/static/png?subscription-key={0}&api-version=1.0¢er={1},{2}", Environment.GetEnvironmentVariable("MapsAPIKey"), queueStorageMessage.lon, queueStorageMessage.lat); client.BaseAddress = new Uri(url); HttpResponseMessage responseMessage = await client.GetAsync(url); if (responseMessage.IsSuccessStatusCode) { Stream stream = await responseMessage.Content.ReadAsStreamAsync(); // Check if the the temprature is high enough to have a beer string bier = checkForBier(queueStorageMessage); // Format the string to add the celcius degree symbol string temprature = String.Format("Temp: {0} \u2103", queueStorageMessage.temp.ToString()); // Draw on the image using the ImageHelper class Stream renderedImage = ImageHelper.AddTextToImage(stream, (temprature, (10, 20)), (bier, (10, 50))); // Upload the image to the blob await blockBlob.UploadFromStreamAsync(renderedImage); log.Info("City has been found and image was uploaded succesfully"); } else { log.Error("Could not retrieve the map for the given coordinates"); } } catch { log.Error("Something went wrong."); } }
public virtual void insertTransaction(Transaction transaction) { // Make a copy of the transaction for the queue storage message processing QueueStorageMessage message = new QueueStorageMessage { code = QueueStorageCode.insertTransaction, data = new Transaction(transaction) }; lock (queueStatements) { queueStatements.Add(message); } }
public virtual void insertBlock(Block block) { // Make a copy of the block for the queue storage message processing QueueStorageMessage message = new QueueStorageMessage { code = QueueStorageCode.insertBlock, data = new Block(block) }; lock (queueStatements) { queueStatements.Add(message); } }
public static void insertActivity(Activity activity) { // Make a copy of the block for the queue storage message processing QueueStorageMessage message = new QueueStorageMessage { code = QueueStorageCode.insertActivity, retryCount = 0, data = activity }; lock (queueStatements) { queueStatements.Add(message); } }
public static void updateValue(byte[] data, IxiNumber value) { // Make a copy of the block for the queue storage message processing QueueStorageMessage message = new QueueStorageMessage { code = QueueStorageCode.updateValue, retryCount = 0, data = new MessageDataValue { data = data, value = value } }; lock (queueStatements) { queueStatements.Add(message); } }
public static void updateStatus(byte[] data, ActivityStatus status, ulong block_height) { // Make a copy of the block for the queue storage message processing QueueStorageMessage message = new QueueStorageMessage { code = QueueStorageCode.updateStatus, retryCount = 0, data = new MessageDataStatus { data = data, status = status, blockHeight = block_height } }; lock (queueStatements) { queueStatements.Add(message); } }
public static string checkForBier(QueueStorageMessage queueStorageMessage) { const double BIERMIN = 15.00; string bier; if (queueStorageMessage.temp >= BIERMIN) { return(bier = "Time for beer !"); } else if (queueStorageMessage.temp == BIERMIN) { return(bier = "Water maybe?"); } else { return(bier = "Id go for a hot chocolate"); } }
private void debugDumpCrashObject(QueueStorageMessage message) { Logging.error("Crashed on message: (code: {0}, retry count: {1})", message.code.ToString(), message.retryCount); if (message.retryCount == 1 || message.retryCount >= 10) { if (message.code == QueueStorageCode.insertBlock) { debugDumpCrashBlock((Block)message.data); } else if (message.code == QueueStorageCode.insertTransaction) { debugDumpCrashTX((Transaction)message.data); } else { Logging.error("Message is 'updateTXAppliedFlag'."); } } }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)] HttpRequestMessage req, TraceWriter log) { try { //Get streetname from query parameter string city = req.GetQueryNameValuePairs() .FirstOrDefault(q => string.Compare(q.Key, "city", true) == 0) .Value; if (city == null) { dynamic data = await req.Content.ReadAsAsync <object>(); city = data?.city; } //Get country from query parameter string country = req.GetQueryNameValuePairs() .FirstOrDefault(q => string.Compare(q.Key, "country", true) == 0) .Value; if (country == null) { dynamic data = await req.Content.ReadAsAsync <object>(); country = data?.country; } //Als er wel een stad en land is ingevuld if (country != null && city != null) { //Google api key ophalen en API url opstellen om te checken of de combinatie bestaat en de long en lat op te halen. string googleapikey = Environment.GetEnvironmentVariable("GoogleAPIkey"); var url = String.Format("https://maps.googleapis.com/maps/api/geocode/json?address={0},+{1}&key={2}", city, country, googleapikey); log.Info("Google api link: " + url); using (var client = new HttpClient()) { //Wachten op een response client.BaseAddress = new Uri(url); HttpResponseMessage response = await client.GetAsync(url); //Als de response een sucess was if (response.IsSuccessStatusCode) { //String ophalen en omzetten naar een json object string strResult = await response.Content.ReadAsStringAsync(); dynamic googlemapsobject = JsonConvert.DeserializeObject <dynamic>(strResult); //De status uit het json object lezen string status = (string)googlemapsobject.status; //Als er geen resultaten waren voor de opgegeven combinatie if (status == "ZERO_RESULTS") { return(req.CreateErrorResponse(HttpStatusCode.NotFound, "Your combination of city and country could not be found, please enter a valid city and country!")); } //Als er wel resultaten waren else { //Geocoordinaten ophalen voor de locatie string latitude = googlemapsobject.results[0].geometry.location.lat; string longtitude = googlemapsobject.results[0].geometry.location.lng; //Bloblocatie opstellen string blobname = String.Format("Generatedmap-{0},{1}-{2}.png", city, country, DateTime.Now.ToFileTime()); string blobcontainerreference = "mapblob"; log.Info(Environment.GetEnvironmentVariable("StorageConnectionString")); CloudStorageAccount account = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("StorageConnectionString") + ";EndpointSuffix=core.windows.net"); string blobUrl = account.BlobStorageUri.PrimaryUri.AbsoluteUri + blobcontainerreference + "/" + blobname; log.Info("bloburl= " + blobUrl); //Object voor het doorsturen naar de queue aanmaken QueueStorageMessage message = new QueueStorageMessage(longtitude, latitude, blobname, blobcontainerreference); //Als json string doorsturen naar de queue storage string json = JsonConvert.SerializeObject(message); CloudStorageAccount storageAccount = CloudStorageAccount.Parse(Environment.GetEnvironmentVariable("StorageConnectionString") + ";EndpointSuffix=core.windows.net"); CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); CloudQueue queue = queueClient.GetQueueReference("bierapi-queue"); queue.CreateIfNotExists(); CloudQueueMessage queueumessage = new CloudQueueMessage(json); queue.AddMessage(queueumessage); var myObj = new { status = "request made", url = blobUrl, message = "Your requested map will be available at the url shortly" }; var jsonToReturn = JsonConvert.SerializeObject(myObj); return(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(jsonToReturn, Encoding.UTF8, "application/json") }); } } } } else { var myObj = new { status = "ERROR", message = "Please use a valid country name and city name!" }; var jsonToReturn = JsonConvert.SerializeObject(myObj); return(new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(jsonToReturn, Encoding.UTF8, "application/json") }); } } catch (Exception ex) { log.Info("Exception" + ex.Message + " " + ex.InnerException); } return(null); }
public static void threadLoop() { QueueStorageMessage active_message = new QueueStorageMessage(); bool pending_statements = false; while (running || pending_statements == true) { bool message_found = false; pending_statements = false; TLC.Report(); try { lock (queueStatements) { int statements_count = queueStatements.Count(); if (statements_count > 0) { if (statements_count > 1) { pending_statements = true; } QueueStorageMessage candidate = queueStatements[0]; active_message = candidate; message_found = true; } } if (message_found) { if (active_message.code == QueueStorageCode.insertActivity) { insertActivityInternal((Activity)active_message.data); } else if (active_message.code == QueueStorageCode.updateStatus) { MessageDataStatus mds = (MessageDataStatus)active_message.data; updateStatusInternal(mds.data, mds.status, mds.blockHeight); } else if (active_message.code == QueueStorageCode.updateValue) { MessageDataValue mdv = (MessageDataValue)active_message.data; updateValueInternal(mdv.data, mdv.value); } lock (queueStatements) { queueStatements.RemoveAt(0); } } else { // Sleep for 50ms to yield CPU schedule slot Thread.Sleep(50); } } catch (Exception e) { Logging.error("Exception occured in Activity storage thread loop: " + e); if (message_found) { active_message.retryCount += 1; if (active_message.retryCount > 10) { lock (queueStatements) { queueStatements.RemoveAt(0); } Logging.error("Too many retries, aborting..."); shutdown(); throw new Exception("Too many Activity storage retries. Aborting storage thread."); } } } Thread.Yield(); } shutdown(); }
protected virtual void threadLoop() { QueueStorageMessage active_message = new QueueStorageMessage(); bool pending_statements = false; while (running || pending_statements == true) { bool message_found = false; pending_statements = false; TLC.Report(); try { lock (queueStatements) { int statements_count = queueStatements.Count(); if (statements_count > 0) { if (statements_count > 1) { pending_statements = true; } QueueStorageMessage candidate = queueStatements[0]; active_message = candidate; message_found = true; } } if (message_found) { if (active_message.code == QueueStorageCode.insertTransaction) { insertTransactionInternal((Transaction)active_message.data); } else if (active_message.code == QueueStorageCode.insertBlock) { insertBlockInternal((Block)active_message.data); } lock (queueStatements) { queueStatements.RemoveAt(0); } } else { long cur_time = Clock.getTimestamp(); if (cur_time - lastCleanupPass > 60) { lastCleanupPass = cur_time; // this is only enabled on Rocks for now if (this is RocksDBStorage) { cleanupCache(); } } // Sleep for 50ms to yield CPU schedule slot Thread.Sleep(50); } } catch (Exception e) { Logging.error("Exception occured in storage thread loop: " + e); if (message_found) { debugDumpCrashObject(active_message); active_message.retryCount += 1; if (active_message.retryCount > 10) { lock (queueStatements) { queueStatements.RemoveAt(0); } Logging.error("Too many retries, aborting..."); shutdown(); throw new Exception("Too many storage retries. Aborting storage thread."); } } } Thread.Yield(); } shutdown(); Logging.info("Storage stopped."); }