/// <summary> /// Create An iFolder Entry /// </summary> /// <param name="c"></param> /// <param name="parent"></param> /// <param name="type"></param> /// <param name="entryName"></param> /// <param name="path"></param> /// <returns></returns> internal static Node CreateEntry(Collection c, Node parent, iFolderEntryType type, string entryName, out string path, bool DontCheckPolicies) { Node result = null; // NOTE: a new entry off the iFolder is not allowed, it must be off the root directory node or lower if ((parent == null) || (c.ID.Equals(parent.ID))) { throw new EntryDoesNotExistException(parent.ID); } // NOTE: only directories can have children if (!parent.IsBaseType(NodeTypes.DirNodeType)) { throw new DirectoryEntryRequiredException(parent.ID); } // check the name CheckName(entryName); // create new path DirNode parentDirNode = (DirNode)parent; path = parentDirNode.GetFullPath(c); path = System.IO.Path.Combine(path, entryName); // check for existing entry (case insensitive test) if (SyncFile.DoesNodeExist(c, parentDirNode, entryName)) { throw new EntryAlreadyExistException(entryName); } // directory if (type == iFolderEntryType.Directory) { result = new DirNode(c, parentDirNode, entryName); } // file else { if (DontCheckPolicies == false) { // check file type policy FileTypeFilter filter = FileTypeFilter.Get(c); if (!filter.Allowed(entryName)) { throw new FileTypeException(entryName); } } result = new FileNode(c, parentDirNode, entryName); } return(result); }
/// <summary> /// Checks for a name conflict. /// </summary> /// <returns>True if conflict.</returns> protected bool CheckForNameConflict() { if (!NameConflict) { // Look up the FsPath property (StoreFileNodes don't have this property set). Property property = node.Properties.GetSingleProperty(PropertyTags.FileSystemPath); if (property != null) { string path = property.Value.ToString(); ICSList nodeList; nodeList = collection.Search(PropertyTags.FileSystemPath, path, SearchOp.Equal); foreach (ShallowNode sn in nodeList) { FileNode localFileNode = new FileNode(collection.GetNodeByID(sn.ID)); // Set name conflict true if both file doesn't match if (sn.ID != node.ID && String.Compare(new FileNode(node).GetRelativePath(), localFileNode.GetRelativePath(), false) != 0) { conflictingNode = collection.GetNodeByID(sn.ID); nameConflict = true; break; } } // Now make sure we don't have any illegal characters. if (!IsNameValid(path)) { nameConflict = true; } if (nameConflict) { node = Conflict.CreateNameConflict(collection, node) as BaseFileNode; file = Conflict.GetFileConflictPath(collection, node); if (conflictingNode != null) { string cnPath; FileNode tmpFn = conflictingNode as FileNode; DirNode tmpDn = conflictingNode as DirNode; if (tmpFn != null) { cnPath = tmpFn.GetFullPath(collection); } else { cnPath = tmpDn.GetFullPath(collection); } conflictingNode = Conflict.CreateNameConflict(collection, conflictingNode, cnPath); Conflict.LinkConflictingNodes(conflictingNode, node); } } } } return(nameConflict); }
/// <summary> /// Constructor /// </summary> /// <param name="c">The iFolder Collection</param> /// <param name="accessID">The Access User ID</param> protected iFolderDetails(Collection c, string accessID) : base(c, accessID) { this.FileCount = c.GetNodesByType(NodeTypes.FileNodeType).Count; this.DirectoryCount = c.GetNodesByType(NodeTypes.DirNodeType).Count; // paths this.ManagedPath = c.ManagedPath; DirNode dirNode = c.GetRootDirectory(); if (dirNode != null) { this.UnManagedPath = dirNode.GetFullPath(c); } }
//--------------------------------------------------------------------------- /// <summary> /// resolve file name conflict and commit /// </summary> public void Resolve(string newNodeName) { if (!SyncFile.IsNameValid(newNodeName)) { throw new MalformedException(newNodeName); } FileNode fn = node as FileNode; if (fn != null) { DirNode parent = fn.GetParent(collection); if (newNodeName == node.Name) { Log.log.Debug("Resolving the name conflict >>>>> name: {0} newName: {1}", node.Name, newNodeName); // We are resolving to the same name. if (Path.GetDirectoryName(FileNameConflictPath) != Path.GetDirectoryName(NonconflictedPath)) { // This file is in the conflict bin and has been sync-ed from the server. We do not need // To push it back up. Set internal. node.Properties.State = PropertyList.PropertyListState.Internal; try { File.Move(FileNameConflictPath, NonconflictedPath); } catch (IOException) { // The file exists it must have been modified locally create a node conflict. File.Move(FileNameConflictPath, GetUpdateConflictPath(collection, fn)); fn = (FileNode)RemoveNameConflict(collection, fn); collection.Commit(fn); Node serverNode = collection.GetNodeByID(fn.ID); // Now commit the node to update the file (size and dates); fn.UpdateFileInfo(collection); collection.Commit(fn); // Create the node conflict. fn = (FileNode)collection.CreateCollision(serverNode, false); collection.Commit(fn); return; } } } else { Log.log.Debug("Resolving the name conflict >>>>> name: {0} newName: {1}", node.Name, newNodeName); if (SyncFile.DoesNodeExist(collection, parent, newNodeName)) { throw new ExistsException(newNodeName); } //TODO: what if move succeeds but node rename or commit fails? File.Move(FileNameConflictPath, Path.Combine(Path.GetDirectoryName(NonconflictedPath), newNodeName)); string relativePath = fn.GetRelativePath(); relativePath = relativePath.Remove(relativePath.Length - node.Name.Length, node.Name.Length) + newNodeName; node.Properties.ModifyNodeProperty(new Property(PropertyTags.FileSystemPath, Syntax.String, relativePath)); node.Name = newNodeName; } node = RemoveNameConflict(collection, node); collection.Commit(node); } else { DirNode dn = node as DirNode; if (dn != null) { DirNode parent = dn.GetParent(collection); string oldname, newname; oldname = FileNameConflictPath; newname = Path.Combine(Path.GetDirectoryName(dn.GetFullPath(collection)), newNodeName); if (newNodeName != node.Name) { if (SyncFile.DoesNodeExist(collection, parent, newNodeName)) { throw new ExistsException(newNodeName); } if (Directory.Exists(oldname)) { Directory.Move(oldname, newname); } else { Directory.CreateDirectory(newname); } string oldRelativePath = dn.GetRelativePath(); string relativePath = oldRelativePath.Remove(oldRelativePath.Length - node.Name.Length, node.Name.Length) + newNodeName; node.Properties.ModifyNodeProperty(new Property(PropertyTags.FileSystemPath, Syntax.String, relativePath)); node.Name = newNodeName; node = RemoveNameConflict(collection, node); collection.Commit(node); FileWatcher.RenameDirsChildren(collection, dn, oldRelativePath); } else { // The name did not change. if (Directory.Exists(oldname)) { Directory.Move(oldname, newname); } else { Directory.CreateDirectory(newname); } node = RemoveNameConflict(collection, node); collection.Commit(node); } } } }
/// <summary> /// Delete An iFolder Entry /// </summary> /// <param name="ifolderID">The ID of the iFolder.</param> /// <param name="entryID">The ID of the Entry.</param> /// <param name="accessID">The Access User ID.</param> public static void DeleteEntry(string ifolderID, string entryID, string accessID) { Store store = Store.GetStore(); Collection c = store.GetCollectionByID(ifolderID); if (c == null) { throw new iFolderDoesNotExistException(ifolderID); } // impersonate iFolder.Impersonate(c, accessID); Node n = c.GetNodeByID(entryID); if (n == null) { throw new EntryDoesNotExistException(entryID); } // directory if (n.IsBaseType(NodeTypes.DirNodeType)) { DirNode dn = (DirNode)n; if (dn.IsRoot) { throw new DirectoryEntryRequiredException(entryID); } string path = dn.GetFullPath(c); if (Directory.Exists(path)) { Directory.Delete(path, true); } // delete recursivley c.Commit(c.Delete(dn, PropertyTags.Parent)); } // file else if (n.IsBaseType(NodeTypes.FileNodeType)) { FileNode fn = (FileNode)n; string path = fn.GetFullPath(c); if (File.Exists(path)) { File.Delete(path); } c.Commit(c.Delete(fn)); } // not an entry else { throw new EntryDoesNotExistException(entryID); } }
/// <summary> /// Constructor /// </summary> public iFolderWeb(Collection collection) { Member tmpMember = null; this.DomainID = collection.Domain; this.ID = collection.ID; this.CollectionID = collection.ID; this.LocalIncarnation = collection.LocalIncarnation; DirNode dirNode = collection.GetRootDirectory(); if (dirNode != null) { this.UnManagedPath = dirNode.GetFullPath(collection); } else { this.UnManagedPath = ""; } this.ManagedPath = collection.ManagedPath; this.MasterIncarnation = collection.MasterIncarnation; this.Name = collection.Name; tmpMember = collection.Owner; if (tmpMember != null) { this.OwnerID = tmpMember.UserID; Domain domain = Store.GetStore().GetDomain(this.DomainID); Member domainMember = domain.GetMemberByID(this.OwnerID); string fullName = domainMember.FN; this.Owner = (fullName != null) ? fullName : tmpMember.Name; this.EffectiveSyncInterval = tmpMember.EffectiveSyncPolicy(collection); } else { this.Owner = "Not available"; this.OwnerID = "0"; } this.SyncInterval = Simias.Policy.SyncInterval.GetInterval(collection); this.Synchronizable = collection.Synchronizable; this.Type = iFolderType; this.Description = ""; this.IsSubscription = false; this.EnumeratedState = -1; // There is no longer a WorkGroup domain ... for now return false. We // probably need to change this to return a type instead. this.IsWorkgroup = false; this.HasConflicts = collection.HasCollisions(); tmpMember = collection.GetCurrentMember(); this.CurrentUserID = tmpMember.UserID; this.CurrentUserRights = tmpMember.Rights.ToString(); int EffectiveSync = tmpMember.EffectiveSyncPolicy(collection); if (EffectiveSync > 0) { this.EffectiveSyncInterval = EffectiveSync; //Simias.Policy.SyncInterval.Set(collection, EffectiveSync); } DateTime lastSyncTime = Simias.Sync.SyncClient.GetLastSyncTime(collection.ID); if (collection.Role.Equals(SyncRoles.Master)) { this.LastSyncTime = string.Empty; this.State = "Local"; } else if (lastSyncTime.Equals(DateTime.MinValue)) { this.LastSyncTime = string.Empty; this.State = "WaitSync"; } else { this.LastSyncTime = lastSyncTime.ToString(); this.State = collection.IsProxy ? "WaitSync" : "Local"; } this.Role = collection.Role.ToString(); this.ssl = collection.SSL; if (collection.EncryptionAlgorithm == null || collection.EncryptionAlgorithm == "") { this.encryptionAlgorithm = ""; } else { this.encryptionAlgorithm = collection.EncryptionAlgorithm; } this.MigratediFolder = collection.MigratediFolder; ICSList memberList; memberList = collection.GetMemberList(); if (memberList.Count > 1) { this.shared = true; } else { this.shared = false; } this.iFolderSize = collection.StorageSize; }
/// <summary> /// Constructor /// </summary> /// <param name="collection">Collcetion</param> public iFolderWeb(Collection collection, int infoToFetch) { Member tmpMember = null; //base information that is mandatory this.DomainID = collection.Domain; this.ID = collection.ID; this.CollectionID = collection.ID; this.LocalIncarnation = collection.LocalIncarnation; //infoToFetch is a bitmap, for now using it as a boolean if (infoToFetch > 0) { DirNode dirNode = collection.GetRootDirectory(); if (dirNode != null) { this.UnManagedPath = dirNode.GetFullPath(collection); } else { this.UnManagedPath = ""; } this.ManagedPath = collection.ManagedPath; this.MasterIncarnation = collection.MasterIncarnation; this.Name = collection.Name; DateTime lastSyncTime = Simias.Sync.SyncClient.GetLastSyncTime(collection.ID); if (collection.Role.Equals(SyncRoles.Master)) { this.LastSyncTime = string.Empty; this.State = "Local"; } else if (lastSyncTime.Equals(DateTime.MinValue)) { this.LastSyncTime = string.Empty; this.State = "WaitSync"; } else { this.LastSyncTime = lastSyncTime.ToString(); this.State = collection.IsProxy ? "WaitSync" : "Local"; } this.HasConflicts = collection.HasCollisions(); tmpMember = collection.GetCurrentMember(); this.CurrentUserID = tmpMember.UserID; this.CurrentUserRights = tmpMember.Rights.ToString(); this.Role = collection.Role.ToString(); this.ssl = collection.SSL; if (collection.EncryptionAlgorithm == null || collection.EncryptionAlgorithm == "") { this.encryptionAlgorithm = ""; } else { this.encryptionAlgorithm = collection.EncryptionAlgorithm; } this.MigratediFolder = collection.MigratediFolder; tmpMember = collection.Owner; if (tmpMember != null) { this.Owner = tmpMember.Name; this.OwnerID = tmpMember.UserID; this.EffectiveSyncInterval = tmpMember.EffectiveSyncPolicy(collection); } else { this.Owner = "Not available"; this.OwnerID = "0"; } ICSList memberList; memberList = collection.GetMemberList(); if (memberList.Count > 1) { this.shared = true; } else { this.shared = false; } this.iFolderSize = collection.StorageSize; } }
/// <summary> /// Generates a report /// </summary> public void GenerateReport() { bool hadException = false; const double MB = 1024 * 1024; ReportConfig config = GetReportConfiguration(); string reportPath = null; if (config.IsiFolder) { DirNode dirNode = reportCollection.GetRootDirectory(); reportPath = dirNode.GetFullPath(reportCollection); } else { reportPath = ReportPath; } string fileName = String.Format("ifolder-{0}-{1}.csv", Environment.MachineName, currentReportTime.ToString("yyyyMMdd-HHmmss")); string filePath = Path.Combine(reportPath, fileName); log.Debug("Report file name = {0}", filePath); StreamWriter file = File.CreateText(filePath); try { Domain domain = store.GetDomain(store.DefaultDomain); // headers WriteHeaderRow(file, columns); // list iFolders ICSList ifolders = store.GetCollectionsByType("iFolder"); foreach (ShallowNode sn in ifolders) { object[] cells = new object[count]; Collection ifolder = store.GetCollectionByID(sn.ID); Member owner = domain.GetMemberByID(ifolder.Owner.UserID); // cells if (cli != null) { cells[(int)ColumnID.ReportTime] = currentReportTime.ToString(cli); cells[(int)ColumnID.OwnerLastLogin] = owner.Properties.GetSingleProperty("LastLogin").ToString(cli); cells[(int)ColumnID.LastSyncTime] = ifolder.Properties.GetSingleProperty("LastModified").ToString(cli); } else { cells[(int)ColumnID.ReportTime] = currentReportTime.ToString("F"); cells[(int)ColumnID.OwnerLastLogin] = owner.Properties.GetSingleProperty("LastLogin").ToString("F"); cells[(int)ColumnID.LastSyncTime] = ifolder.Properties.GetSingleProperty("LastModified").ToString("F"); } cells[( int )ColumnID.iFolderSystem] = domain.Name; cells[( int )ColumnID.iFolderServer] = Environment.MachineName; cells[( int )ColumnID.iFolderID] = ifolder.ID; cells[( int )ColumnID.iFolderName] = ifolder.Name; cells[( int )ColumnID.iFolderSize] = ifolder.StorageSize / MB; cells[( int )ColumnID.iFolderPath] = ifolder.UnmanagedPath; cells[( int )ColumnID.iFolderQuota] = DiskSpaceQuota.GetLimit(ifolder) / MB; cells[( int )ColumnID.MemberCount] = ifolder.GetMemberList().Count; cells[( int )ColumnID.FileCount] = ifolder.GetNodesByType(NodeTypes.FileNodeType).Count; cells[( int )ColumnID.DirectoryCount] = ifolder.GetNodesByType(NodeTypes.DirNodeType).Count; cells[( int )ColumnID.OwnerID] = owner.UserID; cells[( int )ColumnID.OwnerName] = owner.FN; cells[( int )ColumnID.OwnerCN] = owner.Name; cells[( int )ColumnID.OwnerDN] = owner.Properties.GetSingleProperty("DN"); cells[( int )ColumnID.OwnerQuota] = DiskSpaceQuota.Get(owner).Limit / MB; cells[( int )ColumnID.OwnerDisabled] = domain.IsLoginDisabled(owner.UserID); cells[( int )ColumnID.PreviousOwner] = ifolder.PreviousOwner; cells[( int )ColumnID.OrphanedOwner] = ifolder.Properties.GetSingleProperty("OrphanedOwner"); WriteRow(file, columns, cells); } } catch (Exception ex) { hadException = true; file.WriteLine(); file.WriteLine(); file.WriteLine(ex); file.WriteLine(ex.StackTrace); } finally { file.Close(); if (hadException == false) { // If this is an iFolder create the file node for the report file. if (config.IsiFolder) { CreateFileNode(fileName); } // Set the time of the last successful report. SetLastReportTime(currentReportTime); } } }