// get or create an reference to the given entity in the UserFolder EntityRefs list public Item GetEntityRef(User user, ServerEntity entity) { Item entityRefsList = GetEntityRefsList(user); if (entityRefsList == null) { return(null); } var entityID = entity.ID.ToString(); try { // get existing reference to given entity if (storage.Items.Include("FieldValues").Any(i => i.UserID == user.ID && i.FolderID == entityRefsList.FolderID && i.ParentID == entityRefsList.ID && i.FieldValues.Any(fv => fv.FieldName == FieldNames.EntityRef && fv.Value == entityID))) { return(storage.Items.Include("FieldValues").Single(i => i.UserID == user.ID && i.FolderID == entityRefsList.FolderID && i.ParentID == entityRefsList.ID && i.FieldValues.Any(fv => fv.FieldName == FieldNames.EntityRef && fv.Value == entityID))); } else { // create new reference to given entity DateTime now = DateTime.UtcNow; var entityRefItemID = Guid.NewGuid(); var entityRefItem = new Item() { ID = entityRefItemID, Name = entity.Name, FolderID = entityRefsList.FolderID, UserID = user.ID, ItemTypeID = SystemItemTypes.Reference, ParentID = entityRefsList.ID, Created = now, LastModified = now, FieldValues = new List <FieldValue>() { new FieldValue() { ItemID = entityRefItemID, FieldName = FieldNames.EntityRef, Value = entityID }, new FieldValue() { ItemID = entityRefItemID, FieldName = FieldNames.EntityType, Value = entity.GetType().Name }, } }; storage.Items.Add(entityRefItem); storage.SaveChanges(); TraceLog.TraceInfo(String.Format("Created entity ref item {0} for user {1}", entity.Name, user.Name)); return(entityRefItem); } } catch (Exception ex) { TraceLog.TraceException(String.Format("Created entity ref item {0} for user {1}", entity.Name, user.Name), ex); return(null); } }
public static void InitializeSplunkLogging() { lock (splunkLock) { // splunk only needs to be initialized once - when trace directory is created if (!IsSplunkInitialized) { // make sure this only runs in azure if (HostEnvironment.IsAzure) { // configure splunk to monitor trace directory try { // construct the splunk executable path var programFiles = Environment.GetEnvironmentVariable("ProgramFiles"); var splunkExe = Path.Combine(programFiles, @"SplunkUniversalForwarder", @"bin", @"Splunk.exe"); var traceDir = HostEnvironment.TraceDirectory; string cmdline = String.Format("add monitor {0} -auth admin:changeme", traceDir); // configure the environment for the splunk process ProcessStartInfo startinfo = new ProcessStartInfo(); startinfo.CreateNoWindow = true; startinfo.UseShellExecute = false; startinfo.FileName = splunkExe; startinfo.Arguments = cmdline; startinfo.WorkingDirectory = traceDir; startinfo.RedirectStandardOutput = true; startinfo.RedirectStandardError = true; // run the splunk process to start monitoring the directory Process exeProcess = Process.Start(startinfo); string stdout = exeProcess.StandardOutput.ReadToEnd(); string stderr = exeProcess.StandardError.ReadToEnd(); exeProcess.WaitForExit(); // write the log file and trace the result string message = String.Format("Finished executing {0} {1}\nStdout: {2}Stderr: {3}", splunkExe, cmdline, stdout, stderr); using (var fs = File.Create(Path.Combine(traceDir, SplunkLogFile))) using (var writer = new StreamWriter(fs)) { writer.WriteLine(message); } TraceLog.TraceInfo(message); IsSplunkInitialized = true; } catch (Exception ex) { TraceException("Splunk initialization failed", ex); } } } } }
public static void Initialize() { // create the queue if it doesn't yet exist // this call returns false if the queue was already created if (Queue.CreateIfNotExist()) { TraceLog.TraceInfo(String.Format("Created queue named '{0}'", queueName)); } else { TraceLog.TraceDetail(String.Format("Queue named '{0}' already exists", queueName)); } }
// get or create an Item by name in given folder for given user (include FieldValues if NOT a List) public Item GetOrCreateItem(User user, Folder folder, string name, Guid?itemTypeID = null, bool isList = false) { if (itemTypeID == null) { itemTypeID = SystemItemTypes.NameValue; } try { // get the list with given name in given folder if (Items.Any(i => i.UserID == user.ID && i.FolderID == folder.ID && i.Name == name)) { if (isList) { return(Items.Single(i => i.UserID == user.ID && i.FolderID == folder.ID && i.Name == name)); } else { return(Items.Include("FieldValues").Single(i => i.UserID == user.ID && i.FolderID == folder.ID && i.Name == name)); } } else { // create new item with given name in given folder DateTime now = DateTime.UtcNow; var item = new Item() { ID = Guid.NewGuid(), Name = name, FolderID = folder.ID, UserID = user.ID, IsList = isList, ItemTypeID = itemTypeID.Value, ParentID = null, Created = now, LastModified = now }; Items.Add(item); SaveChanges(); TraceLog.TraceInfo(string.Format("Created item named '{0}' in folder '{1}' for user '{2}'", name, folder.Name, user.Name)); return(item); } } catch (Exception ex) { TraceLog.TraceException(string.Format("Could not find or create item named '{0}' in folder '{1}' for user '{2}'", name, folder.Name, user.Name), ex); return(null); } }
public static void WriteTraceFile(string filename, Stream stream) { try { bool created = TraceContainer.CreateIfNotExist(); if (created == true) { TraceLog.TraceInfo("Created container " + TraceContainerName); } var blob = TraceContainer.GetBlobReference(filename); blob.UploadFromStream(stream); TraceLog.TraceInfo(String.Format("Uploaded trace file {0}", filename)); } catch (Exception ex) { TraceLog.TraceException(String.Format("Failed to upload trace file {0}", filename), ex); } }
// get or create a List by value in given folder for given user public Item GetOrCreateListByValue(User user, Folder folder, string value, string name, Guid?itemTypeID = null) { if (itemTypeID == null) { itemTypeID = SystemItemTypes.NameValue; } try { // get the list with given value in given folder if (Items.Any(i => i.UserID == user.ID && i.FolderID == folder.ID && i.FieldValues.Any(fv => fv.FieldName == FieldNames.Value && fv.Value == value))) { return(Items.Single(i => i.UserID == user.ID && i.FolderID == folder.ID && i.FieldValues.Any(fv => fv.FieldName == FieldNames.Value && fv.Value == value))); } else { // create new list with given value and name in given folder DateTime now = DateTime.UtcNow; var list = new Item() { ID = Guid.NewGuid(), Name = name, FolderID = folder.ID, UserID = user.ID, IsList = true, ItemTypeID = itemTypeID.Value, ParentID = null, Created = now, LastModified = now, FieldValues = new List <FieldValue>() }; list.GetFieldValue(FieldNames.Value, true).Value = value; Items.Add(list); SaveChanges(); TraceLog.TraceInfo(string.Format("Created list by value '{0}' in folder '{1}' for user '{2}'", value, folder.Name, user.Name)); return(list); } } catch (Exception ex) { TraceLog.TraceException(string.Format("Could not find or create list by value '{0}' in folder '{1}' for user '{2}'", value, folder.Name, user.Name), ex); return(null); } }
public static void WriteBlobData(string containerName, string filename, string data) { try { var container = BlobClient.GetContainerReference(containerName); bool created = container.CreateIfNotExist(); if (created == true) { TraceLog.TraceInfo("Created container " + containerName); } var blob = container.GetBlobReference(filename); blob.UploadText(data); TraceLog.TraceInfo(String.Format("Added file {0} to container {1}", filename, containerName)); } catch (Exception ex) { TraceLog.TraceException(String.Format("Failed to add file {0} to container {1}", filename, containerName), ex); } }
public static bool DeleteMessage(object message) { var msg = message as CloudQueueMessage; if (msg == null) { TraceLog.TraceError("Wrong message type: " + message.GetType().Name); return(false); } try { TraceLog.TraceInfo("Deleting message ID " + msg.Id); Queue.DeleteMessage(msg); return(true); } catch (Exception ex) { TraceLog.TraceException("DeleteMessage failed", ex); return(false); } }
public static void EnqueueMessage(object obj) { DataContractJsonSerializer dcs = new DataContractJsonSerializer(obj.GetType()); var ms = new MemoryStream(); dcs.WriteObject(ms, obj); ms.Position = 0; byte[] bytes = new byte[ms.Length]; int len = ms.Read(bytes, 0, (int)ms.Length); // messages can only be 8K so the cast is safe if (len < ms.Length) { var newbytes = new byte[len]; Array.Copy(bytes, newbytes, len); bytes = newbytes; } var msg = new CloudQueueMessage(bytes); Queue.AddMessage(msg); TraceLog.TraceInfo(String.Format("Enqueued a {0}: {1}", obj.GetType().Name, obj.ToString())); }
// get or create a Folder by name for given user public Folder GetOrCreateFolder(User user, string name, Guid itemTypeID) { try { // get the folder by name for user if (Folders.Any(f => f.UserID == user.ID && f.Name == name)) { return(Folders.Single(f => f.UserID == user.ID && f.Name == name)); } else { // create the folder with given name and itemTypeID for user var folderUser = new FolderUser() { ID = Guid.NewGuid(), FolderID = Guid.NewGuid(), UserID = user.ID, PermissionID = BuiltSteady.Zaplify.Shared.Entities.Permissions.Full }; var folder = new Folder() { ID = folderUser.FolderID, SortOrder = 0, Name = name, UserID = user.ID, ItemTypeID = itemTypeID, Items = new List <Item>(), FolderUsers = new List <FolderUser>() { folderUser } }; Folders.Add(folder); SaveChanges(); TraceLog.TraceInfo(string.Format("Created folder named '{0}' for user '{1}'", name, user.Name)); return(folder); } } catch (Exception ex) { TraceLog.TraceException(string.Format("Could not find or create folder named '{0}' for user '{1}'", name, user.Name), ex); return(null); } }
public static MQMessage <T> DequeueMessage <T>() { var msg = Queue.GetMessage(TimeSpan.FromMinutes(1.0d)); if (msg == null) // GetMessage doesn't block for a message { return(null); } TraceLog.TraceDetail(String.Format("Dequeued message ID {0} inserted {1}", msg.Id, msg.InsertionTime.ToString())); byte[] bytes = msg.AsBytes; var ms = new MemoryStream(bytes); DataContractJsonSerializer dcs = new DataContractJsonSerializer(typeof(T)); T content = (T)dcs.ReadObject(ms); MQMessage <T> returnMessage = new MQMessage <T>() { Content = content, MessageRef = msg }; TraceLog.TraceInfo(String.Format("Dequeued a {0}: {1}", content.GetType().Name, content.ToString())); return(returnMessage); }
public override bool ProcessCreate(Item item) { // base method extracts intent if (base.ProcessCreate(item)) { return(true); } // assign category to the grocery item // create a new category fieldvalue in the item to process var categoryFV = item.GetFieldValue(FieldNames.Category, true); // check if the category for this item's name has already been saved under the $User/Grocery list // in this case, store the category in the incoming item var groceryCategoryFV = GetGroceryCategoryFieldValue(item); if (groceryCategoryFV != null && groceryCategoryFV.Value != null) { categoryFV.Value = groceryCategoryFV.Value; return(true); } // get the "intent" which in this case is the normalized name var intentName = item.Name.ToLower(); var intentFV = item.GetFieldValue(ExtendedFieldNames.Intent); if (intentFV != null && intentFV.Value != null) { intentName = intentFV.Value; } // set up the grocery API endpoint GroceryAPI gApi = new GroceryAPI(); gApi.EndpointBaseUri = string.Format("{0}{1}/", HostEnvironment.DataServicesEndpoint, "Grocery"); TraceLog.TraceDetail("GroceryAPI Endpoint: " + gApi.EndpointBaseUri); // try to find the category from the local Grocery Controller try { var results = gApi.Query(GroceryQueries.GroceryCategory, intentName).ToList(); // this should only return one result if (results.Count > 0) { // get the category foreach (var entry in results) { categoryFV.Value = entry[GroceryQueryResult.Category]; if (!String.IsNullOrEmpty(entry[GroceryQueryResult.ImageUrl])) { item.GetFieldValue(FieldNames.Picture, true).Value = entry[GroceryQueryResult.ImageUrl]; } // only grab the first category break; } TraceLog.TraceInfo(String.Format("Grocery API assigned {0} category to item {1}", categoryFV.Value, item.Name)); return(true); } } catch (Exception ex) { TraceLog.TraceException("Grocery API or database commit failed", ex); } // use the Supermarket API to get the grocery category SupermarketAPI smApi = new SupermarketAPI(); #if FALSE // use the synchronous codepath for now // execute the call asynchronously so as to not block the response smApi.BeginQuery(SupermarketQueries.SearchByProductName, item.Name, new AsyncCallback((iar) => { try { var results = smApi.EndQuery(iar); // find the item using a new context var context = Storage.NewUserContext; var groceryItem = context.Items.Single(i => i.ID == item.ID); FieldValue categoryFV = groceryItem.GetFieldValue(FieldNames.Category, true); // get the category foreach (var entry in results) { categoryFV.Value = entry[SupermarketQueryResult.Category]; // only grab the first category TraceLog.TraceInfo(String.Format("ProcessCreate: assigned {0} category to item {1}", categoryFV.Value, item.Name)); return(true); } } catch (Exception ex) { TraceLog.TraceException("ProcessCreate: Supermarket API or database commit failed", ex); } }), null); #else try { var results = smApi.Query(SupermarketQueries.SearchByProductName, intentName); // get the category and image foreach (var entry in results) { categoryFV.Value = entry[SupermarketQueryResult.Category]; if (!String.IsNullOrEmpty(entry[SupermarketQueryResult.Image])) { item.GetFieldValue(FieldNames.Picture, true).Value = entry[SupermarketQueryResult.Image]; } // write the data to the blob store BlobStore.WriteBlobData(BlobStore.GroceryContainerName, entry[SupermarketQueryResult.Name], entry.ToString()); // only grab the first category TraceLog.TraceInfo(String.Format("Supermarket API assigned {0} category to item {1}", categoryFV.Value, item.Name)); return(true); } } catch (Exception ex) { TraceLog.TraceException("Supermarket API or database commit failed", ex); } #endif return(false); }
// update constants in Suggestion database to current version defined in WorkflowConstants public bool VersionConstants(string me) { try { bool updateDB = false; if (Versions.Any(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == WorkflowConstants.ConstantsVersion) == false) { // no database - create and lock the new version entry TraceLog.TraceInfo(String.Format("Suggestions database version {0} not found", WorkflowConstants.ConstantsVersion)); // remove any existing database version (there should never be more than one) foreach (var existingVersion in Versions.Where(v => v.VersionType == DatabaseVersion.Constants).ToList()) { Versions.Remove(existingVersion); } SaveChanges(); // create the new version entry DatabaseVersion ver = new DatabaseVersion() { VersionType = DatabaseVersion.Constants, VersionString = WorkflowConstants.ConstantsVersion, Status = me }; Versions.Add(ver); SaveChanges(); updateDB = true; } else { var dbVersion = Versions.Single(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == WorkflowConstants.ConstantsVersion); if (dbVersion.Status == DatabaseVersion.Corrupted) { // try to update the database again - take a lock TraceLog.TraceInfo("Suggestions database corrupted"); dbVersion.Status = me; SaveChanges(); updateDB = true; } } if (updateDB == false) { TraceLog.TraceInfo(String.Format("Suggestions database version {0} is up to date", WorkflowConstants.ConstantsVersion)); return(true); } } catch (Exception ex) { TraceLog.TraceException("Could not find database version", ex); return(false); } // update the default database values DatabaseVersion version = null; SuggestionsStorageContext versionContext = Storage.NewSuggestionsContext; try { // verify that this unit of execution owns the update lock for the database version version = versionContext.Versions.Single(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == WorkflowConstants.ConstantsVersion); if (version.Status != me) { return(true); } TraceLog.TraceInfo(String.Format("{0} updating Suggestions database to version {1}", me, WorkflowConstants.ConstantsVersion)); // remove existing intents foreach (var entity in Intents.ToList()) { Intents.Remove(entity); } var intents = WorkflowConstants.DefaultIntents(); if (intents == null) { TraceLog.TraceError("Could not find or load intents"); version.Status = DatabaseVersion.Corrupted; versionContext.SaveChanges(); return(false); } // add current intents foreach (var entity in intents) { Intents.Add(entity); } SaveChanges(); TraceLog.TraceInfo("Replaced intents"); // remove existing workflow types foreach (var entity in WorkflowTypes.ToList()) { WorkflowTypes.Remove(entity); } var workflowTypes = WorkflowConstants.DefaultWorkflowTypes(); if (workflowTypes == null) { TraceLog.TraceError("Could not find or load workflow definitions"); version.Status = DatabaseVersion.Corrupted; versionContext.SaveChanges(); return(false); } // add current workflow types foreach (var entity in workflowTypes) { WorkflowTypes.Add(entity); } SaveChanges(); TraceLog.TraceInfo("Replaced workflow types"); // save the new version number version.Status = DatabaseVersion.OK; versionContext.SaveChanges(); return(true); } catch (Exception ex) { TraceLog.TraceException("VersionConstants failed", ex); // mark the version as corrupted version.Status = DatabaseVersion.Corrupted; versionContext.SaveChanges(); return(false); } }
// update constants in User database to current version defined in EntityConstants public bool VersionConstants(string me) { try { bool updateDB = false; if (Versions.Any(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == UserConstants.ConstantsVersion) == false) { // no database - create and lock the new version entry TraceLog.TraceInfo(String.Format("User database version {0} not found", UserConstants.ConstantsVersion)); // remove an existing database version (there should never be more than one) foreach (var existingVersion in Versions.Where(v => v.VersionType == DatabaseVersion.Constants).ToList()) { Versions.Remove(existingVersion); } SaveChanges(); // create the new version entry DatabaseVersion ver = new DatabaseVersion() { VersionType = DatabaseVersion.Constants, VersionString = UserConstants.ConstantsVersion, Status = me }; Versions.Add(ver); SaveChanges(); updateDB = true; } else { var dbVersion = Versions.Single(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == UserConstants.ConstantsVersion); if (dbVersion.Status == DatabaseVersion.Corrupted) { // try to update the database again - take a lock TraceLog.TraceInfo("User database corrupted"); dbVersion.Status = me; SaveChanges(); updateDB = true; } } if (updateDB == false) { TraceLog.TraceInfo(String.Format("User database version {0} is up to date", UserConstants.ConstantsVersion)); return(true); } } catch (Exception ex) { TraceLog.TraceException("Could not find database version", ex); return(false); } // update the default database values DatabaseVersion version = null; UserStorageContext versionContext = Storage.NewUserContext; try { // verify that this unit of execution owns the update lock for the database version version = versionContext.Versions.Single(v => v.VersionType == DatabaseVersion.Constants && v.VersionString == UserConstants.ConstantsVersion); if (version.Status != me) { return(true); } TraceLog.TraceInfo(String.Format("{0} updating User datatbase to version {1}", me, UserConstants.ConstantsVersion)); // update existing action types, add new action types foreach (var entity in UserConstants.DefaultActionTypes()) { if (ActionTypes.Any(e => e.ActionTypeID == entity.ActionTypeID)) { ActionTypes.Single(e => e.ActionTypeID == entity.ActionTypeID).Copy(entity); } else { ActionTypes.Add(entity); } } SaveChanges(); TraceLog.TraceInfo("Replaced action types"); // update existing colors, add new colors foreach (var entity in UserConstants.DefaultColors()) { if (Colors.Any(e => e.ColorID == entity.ColorID)) { Colors.Single(e => e.ColorID == entity.ColorID).Copy(entity); } else { Colors.Add(entity); } } SaveChanges(); TraceLog.TraceInfo("Replaced colors"); // update existing permissions, add new permissions foreach (var entity in UserConstants.DefaultPermissions()) { if (Permissions.Any(e => e.PermissionID == entity.PermissionID)) { Permissions.Single(e => e.PermissionID == entity.PermissionID).Copy(entity); } else { Permissions.Add(entity); } } SaveChanges(); TraceLog.TraceInfo("Replaced permissions"); // update existing priorities, add new priorities foreach (var entity in UserConstants.DefaultPriorities()) { if (Priorities.Any(e => e.PriorityID == entity.PriorityID)) { Priorities.Single(e => e.PriorityID == entity.PriorityID).Copy(entity); } else { Priorities.Add(entity); } } SaveChanges(); TraceLog.TraceInfo("Replaced priorities"); // update existing or add new built-in users foreach (var user in UserConstants.DefaultUsers()) { if (Users.Any(u => u.ID == user.ID)) { var existing = Users.Single(u => u.ID == user.ID); existing.Name = user.Name; existing.Email = user.Email; existing.CreateDate = user.CreateDate; } else { Users.Add(user); } } SaveChanges(); TraceLog.TraceInfo("Replaced users"); // update existing or add new built-in itemtypes and fields foreach (var itemType in UserConstants.DefaultItemTypes()) { if (ItemTypes.Any(it => it.ID == itemType.ID)) { var existing = ItemTypes.Include("Fields").Single(it => it.ID == itemType.ID); existing.Copy(itemType); if (itemType.Fields == null) { continue; } foreach (var field in itemType.Fields) { if (existing.Fields.Any(f => f.ID == field.ID)) { var existingField = existing.Fields.Single(f => f.ID == field.ID); existingField.Copy(field); } else { existing.Fields.Add(field); } } } else { ItemTypes.Add(itemType); } } SaveChanges(); TraceLog.TraceInfo("Replaced item types and fields"); // save the new version number version.Status = DatabaseVersion.OK; versionContext.SaveChanges(); return(true); } catch (Exception ex) { TraceLog.TraceException("VersionConstants failed", ex); // mark the version as corrupted version.Status = DatabaseVersion.Corrupted; versionContext.SaveChanges(); return(false); } }