Example #1
0
        /// <summary>
        /// Append the given profile to the Xml document stored in the given list of locations
        /// </summary>
        /// <param name="profile">The profile to be appended</param>
        /// <param name="locations">The list of locations containing the Xml documents for which
        /// the given profile is to be appended to</param>
        public static void AppendProfile(Profile profile, List<string> locations)
        {
            foreach (string path in locations)
            {
                try
                {
                    XmlDocument xmlDoc = CommonXmlHelper.LoadXml(path);
                    if (xmlDoc == null)
                    {
                        //if the xml does not exist, just write it to the place
                        SaveProfile(profile, path);
                    }
                    else
                    {
                        //Loaded XML , replace the old profile data with a new.
                        //Find the Profile with the same name
                        XmlNode node = xmlDoc.SelectSingleNode(@"//" + ELE_PROFILE_ROOT + "[@" + ATTR_PROFILE_NAME + @"='" + profile.ProfileName + @"']");
                        XmlElement profileNode = CreateProfileElement(profile, xmlDoc);
                        XmlNode profilingRootNode = xmlDoc.SelectSingleNode(@"//" + ELE_PROFILING_ROOT);
                        if (node != null)
                        {
                            profilingRootNode.RemoveChild(node);
                        }
                        profilingRootNode.AppendChild(profileNode);
                    }
                }
                catch (Exception)
                {

                }
            }
        }
Example #2
0
        public static Profile CreateDefaultProfile(string path)
        {
            Profile profile = new Profile("Unnamed Profile");
            XmlDocument xml = ConvertToXMLDocument(profile);
            FileInfo fileInfo = new FileInfo(path);
            if (!fileInfo.Exists)
            {
                FileStream fs = null;
                try
                {
                    fs = fileInfo.Create();

                }
                catch (DirectoryNotFoundException)
                {
                    Directory.CreateDirectory(fileInfo.Directory.FullName);
                    fs = fileInfo.Create();
                }
                finally
                {
                    Debug.Assert(fs != null);
                    try
                    {
                        fs.Close();
                    }
                    catch (IOException)
                    {

                    }
                }

            }
            SaveProfile(xml, fileInfo.FullName);
            return profile;
        }
Example #3
0
 /// <summary>
 /// Save the given profile to the given location
 /// </summary>
 /// <param name="profile">The profile to be saved</param>
 /// <param name="location">The location for which the profile is to be saved to</param>
 public static void SaveProfile(Profile profile, string location)
 {
     XmlDocument xmlDoc = new XmlDocument();
     XmlElement root = xmlDoc.CreateElement(ELE_PROFILING_ROOT);
     xmlDoc.AppendChild(root);
     XmlElement profileEle = CreateProfileElement(profile, xmlDoc);
     root.AppendChild(profileEle);
     CommonXmlHelper.SaveXml(xmlDoc, location);
 }
Example #4
0
 /// <summary>
 /// Merge the current profile to the list of profiles if they have the same profile name
 /// </summary>
 /// <param name="currentProfile">The current profile</param>
 /// <param name="profileList">The list of profiles for which the current profile is to be merged with</param>
 /// <returns>The current profile</returns>
 public static Profile Merge(Profile currentProfile, List<Profile> profileList)
 {
     foreach (Profile profile in profileList)
     {
         if (profile.ProfileName.ToLower().Equals(currentProfile.ProfileName.ToLower())){
             currentProfile = Merge(currentProfile, profile);
         }
     }
     return currentProfile;
 }
Example #5
0
 public static bool SaveToAllDrive(Profile profile)
 {
     DriveInfo[] drives = DriveInfo.GetDrives();
     XmlDocument xml = ConvertToXMLDocument(profile);
     UpdateLastUpdateTime(xml, DateTime.Now.Ticks);
     //Save to Root Directory
     FileInfo profileInfo = new FileInfo(ProfilingLayer.RELATIVE_PROFILING_ROOT_SAVE_PATH);
     SaveProfile(xml, profileInfo.FullName);
     foreach (DriveInfo driveInfo in drives)
     {
         FileInfo fileInfo = new FileInfo(ProfilingHelper.ExtractDriveName(driveInfo) + ":" + ProfilingLayer.RELATIVE_GUID_SAVE_PATH);
         if (fileInfo.Exists)
         {
             //GUID Exist
             profileInfo = new FileInfo(ProfilingHelper.ExtractDriveName(driveInfo) + ":" + ProfilingLayer.RELATIVE_PROFILING_SAVE_PATH);
             SaveProfile(xml, profileInfo.FullName);
         }
     }
     return true;
 }
Example #6
0
 /// <summary>
 /// Merge the current profile with the new profile
 /// </summary>
 /// <param name="currentProfile">The current profile</param>
 /// <param name="newProfile">The new profile</param>
 /// <returns>The current profile</returns>
 public static Profile Merge(Profile currentProfile, Profile newProfile)
 {
     foreach (ProfileDrive drive in newProfile.ProfileDriveList)
     {
         ProfileDrive curDrive = currentProfile.FindProfileDriveFromGUID(drive.Guid);
         if (curDrive == null)
         {
             currentProfile.AddProfileDrive(drive);
         }
         else
         {
             if (drive.DriveName.ToLower().Equals(curDrive.DriveName.ToLower()))
             {
                 continue;
             }
             if (drive.LastUpdated > curDrive.LastUpdated)
             {
                 curDrive.DriveName = drive.DriveName;
                 curDrive.LastUpdated = DateTime.UtcNow.Ticks;
             }
         }
     }
     return currentProfile;
 }
Example #7
0
 /// <summary>
 /// Create a profile xml element storing the attributes of the given profile
 /// </summary>
 /// <param name="profile">The profile to be used to create the xml element</param>
 /// <param name="xmlDoc">The xml document for which the created xml element belongs to</param>
 /// <returns></returns>
 private static XmlElement CreateProfileElement(Profile profile, XmlDocument xmlDoc)
 {
     XmlElement profileElement = xmlDoc.CreateElement(ELE_PROFILE_ROOT);
     profileElement.SetAttribute(ATTR_PROFILE_NAME, profile.ProfileName);
     profileElement.SetAttribute(ATTR_PROFILE_LAST_UPDATED, profile.LastUpdatedTime + "");
     PopulateDrive(profile.ProfileDriveList, profileElement, xmlDoc);
     return profileElement;
 }
Example #8
0
        /// <summary>
        /// Initialize the profiling layer
        /// </summary>
        /// <param name="paths">The list of paths to Init</param>
        /// <returns>True if the profile is load.</returns>
        public bool Init(List<string> paths)
        {
            string path = paths[0];
            try
            {
                Profile p = ProfilingXMLHelper.LoadSingleProfile(path);
                if (p == null)
                {
                    throw new ProfileLoadException();
                }
                _profile = p;
            }
            catch (FileNotFoundException)
            {
                Profile profile = ProfilingXMLHelper.CreateDefaultProfile(path);
                _profile = profile;
                //Since the profile is newly created , no need to traverse all the drive
            }
            for (int i = 1; i < paths.Count; i++)
            {

                if (File.Exists(paths[i]))
                {
                    List<Profile> profileList = ProfilingXMLHelper.LoadProfile(paths[i]);
                    if (profileList == null)
                    {
                        continue;
                    }
                    ProfileMerger.Merge(_profile, profileList);
                }
            }

            DriveInfo[] driveList = DriveInfo.GetDrives();

            foreach (DriveInfo driveinfo in driveList)
            {
                UpdateDrive(driveinfo);
            }
            return true;
        }
Example #9
0
 public static Profile ConvertToProfile(XmlDocument profilexml)
 {
     XmlNodeList list = profilexml.GetElementsByTagName("profile");
     if (list.Count != 0)
     {
         XmlElement element = (XmlElement)list.Item(0);
         string profilename = element.GetAttribute("name");
         string lastupdate = element.GetAttribute("lastupdated");
         long lastUpdatedLong = long.Parse(lastupdate);
         Profile profile = new Profile(profilename);
         profile.LastUpdatedTime = lastUpdatedLong;
         profile = ProcessListing(profile, element);
         return profile;
     }
     return null;
 }
Example #10
0
 public static Profile ProcessListing(Profile profile, XmlElement root)
 {
     XmlNodeList nodeList = root.GetElementsByTagName("drive");
     foreach (XmlNode node in nodeList)
     {
         XmlElement drive = (XmlElement)node;
         XmlElement logical = (XmlElement)drive.GetElementsByTagName("logical").Item(0);
         
         XmlElement guid = (XmlElement)drive.GetElementsByTagName("guid").Item(0);
         profile.CreateMapping(logical.InnerText, "", guid.InnerText);
     }
     return profile;
 }
Example #11
0
 public static XmlDocument ConvertToXMLDocument(Profile profile)
 {
     XmlDocument profilexml = new XmlDocument();
     XmlElement root = CreateRoot(profilexml, profile);
     foreach (ProfileMapping mapping in profile.Mappings)
     {
         XmlElement map = CreateElementForMapping(profilexml, mapping);
         root.AppendChild(map);
     }
     profilexml.AppendChild(root);
     return profilexml;
 }
Example #12
0
 public static XmlElement CreateRoot(XmlDocument profilexml, Profile profile)
 {
     XmlElement root = profilexml.CreateElement("profile");
     XmlAttribute nameAttr = profilexml.CreateAttribute("name");
     XmlAttribute timeAttr = profilexml.CreateAttribute("lastupdated");
     nameAttr.Value = profile.ProfileName;
     timeAttr.Value = profile.LastUpdatedTime+"";
     root.SetAttributeNode(nameAttr);
     root.SetAttributeNode(timeAttr);
     return root;
 }
Example #13
0
        /// <summary>
        /// Load only the default saved location
        /// </summary>
        /// <param name="path">The path for which the profile is to be loaded from</param>
        public void Init(string path)
        {
            try
            {
                Profile p = ProfilingXMLHelper.LoadSingleProfile(path);
                if (p == null)
                {
                    throw new ProfileLoadException();
                }
                _profile = p;

            }
            catch (FileNotFoundException)
            {
                Profile profile = ProfilingXMLHelper.CreateDefaultProfile(path);
                _profile = profile;
            }
            SetupDrives();
        }
Example #14
0
 /// <summary>
 /// Creates a new ProfilingLayer object
 /// </summary>
 private ProfilingLayer()
 {
     _profile = new Profile("");
 }
Example #15
0
 public Profile Merge(Profile profile)
 {
     if (CanMerge(profile))
     {
         foreach (ProfileMapping mapping in profile.Mappings)
         {
             if(!Contains(mapping))
             {
                 CreateMapping(mapping);
             }
         }
     }
     return profile;
 }
Example #16
0
        public bool Init(string path)
        {
            try
            {
                Profile p = ProfilingXMLHelper.ConvertToProfile(path);
                Debug.Assert(p != null);
                _profile = p;
            }
            catch (FileNotFoundException)
            {
                Profile profile = ProfilingXMLHelper.CreateDefaultProfile(path);
                _profile = profile;
                //Since the profile is newly created , no need to traverse all the drive
                return true;
            }
            DriveInfo[] driveList = DriveInfo.GetDrives();

            foreach (DriveInfo driveinfo in driveList)
            {
                #region Get Profiling XML
                FileInfo info = new FileInfo(driveinfo.RootDirectory.Name + RELATIVE_PROFILING_SAVE_PATH);
                if (info.Exists)
                {
                    Profile profile = null;
                    try
                    {
                        profile = ProfilingXMLHelper.ConvertToProfile(info.FullName);
                    }
                    catch (FileNotFoundException)
                    {

                    }
                    if (profile == null)
                    {
                        //TODO throw EXCEPTION
                    }
                    else
                    {
                        try
                        {
                            _profile.Merge(profile);
                        }
                        catch (ProfileConflictException pce)
                        {
                            //Log ?
                        }
                    }
                }
                #endregion
            }
            
            foreach (DriveInfo driveinfo in driveList)
            {
                UpdateDrive(driveinfo);
            }
            SaveToAllUsedDrive();
            return true;
        }
Example #17
0
        /// <summary>
        /// Create a profile from the attributes of the given profile xml element
        /// </summary>
        /// <param name="profileElement">The xml element for which the profile is to be created from</param>
        /// <returns>The profile created from the given profile xml element</returns>
        private static Profile CreateProfile(XmlElement profileElement)
        {
            string profileName = profileElement.GetAttribute(ATTR_PROFILE_NAME);
            Profile profile = new Profile(profileName);
            XmlNodeList driveList = profileElement.GetElementsByTagName(ELE_PROFILE_DRIVE_ROOT);
            foreach (XmlNode drive in driveList)
            {
                XmlElement driveElement = drive as XmlElement;
                if (driveElement != null)
                {
                    ProfileDrive driveObj = CreateProfileDrive(driveElement);
                    if (driveObj == null)
                    {
                        //Fail Load
                        return null;
                    }
                    profile.AddProfileDrive(driveObj);
                }
            }

            return profile;
        }
Example #18
0
 /// <summary>
 /// Check whether the current profile has the same name as the new profile
 /// </summary>
 /// <param name="currentProfile">The current profile</param>
 /// <param name="newProfile">The new profile</param>
 /// <returns>True if current profile has the same name as new profile, else false</returns>
 public static bool CanMerge(Profile currentProfile, Profile newProfile)
 {
     return currentProfile.ProfileName.ToLower().Equals(newProfile.ProfileName.ToLower());
 }
Example #19
0
        /// <summary>
        /// Create and save the default profile at the given path
        /// </summary>
        /// <param name="path">The path for which the default profile is to be saved to</param>
        /// <returns>The default profile created</returns>
        public static Profile CreateDefaultProfile(string path)
        {
            Profile profile = new Profile(DEFAULT_NAME);

            SaveProfile(profile, path);
            return profile;
        }
Example #20
0
 private ProfilingLayer()
 {
     _profile = new Profile("Unnamed");
 }
Example #21
0
        public bool CanMerge(Profile profile)
        {
            try
            {
                foreach (ProfileMapping mapping in profile.Mappings)
                {
                    Contains(mapping);
                }
                foreach (ProfileMapping mapping in Mappings)
                {
                    profile.Contains(mapping);
                }
            }
            catch (ProfileMappingConflictException pmce)
            {
                throw new ProfileConflictException(pmce);
            }

            return true;
        }