/// <summary> /// Gets the pages in the selected namespace. /// </summary> /// <returns>The pages.</returns> private IList <PageContent> GetPages(NamespaceInfo nspace) { List <PageContent> pages = Pages.GetPages(currentWiki, nspace); var orphanPages = new List <string>(Pages.GetOrphanedPages(currentWiki, nspace)); List <PageContent> result = new List <PageContent>(pages.Count); string filter = txtFilter.Text.Trim().ToLower(System.Globalization.CultureInfo.CurrentCulture); foreach (PageContent page in pages) { if (NameTools.GetLocalName(page.FullName).ToLower(System.Globalization.CultureInfo.CurrentCulture).Contains(filter)) { if (chkOrphansOnly.Checked && !orphanPages.Contains(page.FullName)) { continue; } else { result.Add(page); } } } result.Sort(new PageNameComparer()); return(result); }
public DummyJournalManager(Configuration conf, URI u, NamespaceInfo nsInfo) { // Set static vars so the test case can verify them. TestGenericJournalConf.DummyJournalManager.conf = conf; TestGenericJournalConf.DummyJournalManager.uri = u; TestGenericJournalConf.DummyJournalManager.nsInfo = nsInfo; }
/// <summary> /// Detects the permissions for the current user. /// </summary> /// <remarks><b>currentPage</b> should be set before calling this method.</remarks> private void DetectPermissions() { string currentUser = SessionFacade.GetCurrentUsername(); string[] currentGroups = SessionFacade.GetCurrentGroupNames(currentWiki); AuthChecker authChecker = new AuthChecker(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); if (currentPage != null) { Pages.CanEditPage(currentPage.Provider.CurrentWiki, currentPage.FullName, currentUser, currentGroups, out canEdit, out canEditWithApproval); canCreateNewPages = false; // Least privilege canCreateNewCategories = authChecker.CheckActionForNamespace(Pages.FindNamespace(currentWiki, NameTools.GetNamespace(currentPage.FullName)), Actions.ForNamespaces.ManageCategories, currentUser, currentGroups); canManagePageCategories = authChecker.CheckActionForPage(currentPage.FullName, Actions.ForPages.ManageCategories, currentUser, currentGroups); canDownloadAttachments = authChecker.CheckActionForPage(currentPage.FullName, Actions.ForPages.DownloadAttachments, currentUser, currentGroups); } else { NamespaceInfo ns = DetectNamespaceInfo(); canCreateNewPages = authChecker.CheckActionForNamespace(ns, Actions.ForNamespaces.CreatePages, currentUser, currentGroups); canCreateNewCategories = authChecker.CheckActionForNamespace(ns, Actions.ForNamespaces.ManageCategories, currentUser, currentGroups); canManagePageCategories = canCreateNewCategories; canDownloadAttachments = authChecker.CheckActionForNamespace(ns, Actions.ForNamespaces.DownloadAttachments, currentUser, currentGroups); } }
/// <summary> /// Activates the page editor. /// </summary> private void ActivatePageEditor() { lblCurrentPage.Text = txtCurrentPage.Value; txtNewName.Text = NameTools.GetLocalName(txtCurrentPage.Value); // Enable/disable page sections PageContent page = Pages.FindPage(currentWiki, txtCurrentPage.Value); NamespaceInfo nspace = Pages.FindNamespace(currentWiki, NameTools.GetNamespace(page.FullName)); string currentUser = SessionFacade.GetCurrentUsername(); string[] currentGroups = SessionFacade.GetCurrentGroupNames(currentWiki); AuthChecker authChecker = new AuthChecker(Collectors.CollectorsBox.GetSettingsProvider(currentWiki)); bool canApproveReject = AdminMaster.CanApproveDraft(page.Provider.CurrentWiki, page.FullName, currentUser, currentGroups); bool canDeletePages = authChecker.CheckActionForNamespace(nspace, Actions.ForNamespaces.DeletePages, currentUser, currentGroups); bool canManageAllPages = authChecker.CheckActionForNamespace(nspace, Actions.ForNamespaces.ManagePages, currentUser, currentGroups); bool canManagePage = authChecker.CheckActionForPage(page.FullName, Actions.ForPages.ManagePage, currentUser, currentGroups); bool canManageDiscussion = authChecker.CheckActionForPage(page.FullName, Actions.ForPages.ManageDiscussion, currentUser, currentGroups); bool namespaceAvailable = PopulateTargetNamespaces(page); // Approve/reject // Rename // Migrate // Rollback // Delete Backups // Clear discussion // Delete pnlApproveRevision.Enabled = canApproveReject; pnlRename.Enabled = canDeletePages; pnlMigrate.Enabled = canManageAllPages && namespaceAvailable; pnlRollback.Enabled = canManagePage; pnlDeleteBackups.Enabled = canManagePage; pnlClearDiscussion.Enabled = canManageDiscussion; pnlDelete.Enabled = canDeletePages; // Disable rename, migrate, delete for default page NamespaceInfo currentNamespace = Pages.FindNamespace(currentWiki, lstNamespace.SelectedValue); string currentDefaultPage = currentNamespace != null ? currentNamespace.DefaultPageFullName : Settings.GetDefaultPage(currentWiki); if (txtCurrentPage.Value == currentDefaultPage) { btnRename.Enabled = false; btnMigrate.Enabled = false; btnDeletePage.Enabled = false; } LoadDraft(txtCurrentPage.Value); LoadBackups(txtCurrentPage.Value); btnRollback.Enabled = lstRevision.Items.Count > 0; btnDeleteBackups.Enabled = lstBackup.Items.Count > 0; pnlList.Visible = false; pnlEditPage.Visible = true; ClearResultLabels(); }
static Image LoadImage (NamespaceInfo ns) { var isIcon = IsIcon(ns.Namespace); if (isIcon) return Icon.FromResource(ns.Namespace, ns.Assembly); return Bitmap.FromResource(ns.Namespace, ns.Assembly); }
public void Two_namespaces_should_be_equal_if_alias_and_connection_string_are_case_insensitive_equal(string alias1, string alias2) { var namespaceInfo1 = new NamespaceInfo(alias1, ConnectionStringValue.Sample); var namespaceInfo2 = new NamespaceInfo(alias2, ConnectionStringValue.Sample); Assert.AreEqual(namespaceInfo1, namespaceInfo2); }
public WikiInfo(string userAgent, string baseUrl = null, string apiPath = null, IEnumerable<Namespace> namespaces = null) { PagesSourcePageSize = 50; if (string.IsNullOrWhiteSpace(userAgent)) throw new ArgumentException("User agent has to be set.", "userAgent"); UserAgent = userAgent; if (baseUrl == null) baseUrl = "en.wikipedia.org"; if (!baseUrl.StartsWith("http")) baseUrl = "http://" + baseUrl; BaseUrl = new Uri(baseUrl); if (apiPath == null) apiPath = "/w/api.php"; ApiUrl = new Uri(BaseUrl, apiPath); Downloader = new Downloader(this); if (namespaces == null) Namespaces = new NamespaceInfo(this); else Namespaces = new NamespaceInfo(namespaces); }
public virtual void SetUp() { mockDnConf = Org.Mockito.Mockito.Mock <DNConf>(); Org.Mockito.Mockito.DoReturn(VersionInfo.GetVersion()).When(mockDnConf).GetMinimumNameNodeVersion (); DataNode mockDN = Org.Mockito.Mockito.Mock <DataNode>(); Org.Mockito.Mockito.DoReturn(true).When(mockDN).ShouldRun(); Org.Mockito.Mockito.DoReturn(mockDnConf).When(mockDN).GetDnConf(); BPOfferService mockBPOS = Org.Mockito.Mockito.Mock <BPOfferService>(); Org.Mockito.Mockito.DoReturn(mockDN).When(mockBPOS).GetDataNode(); actor = new BPServiceActor(InvalidAddr, mockBPOS); fakeNsInfo = Org.Mockito.Mockito.Mock <NamespaceInfo>(); // Return a a good software version. Org.Mockito.Mockito.DoReturn(VersionInfo.GetVersion()).When(fakeNsInfo).GetSoftwareVersion (); // Return a good layout version for now. Org.Mockito.Mockito.DoReturn(HdfsConstants.NamenodeLayoutVersion).When(fakeNsInfo ).GetLayoutVersion(); DatanodeProtocolClientSideTranslatorPB fakeDnProt = Org.Mockito.Mockito.Mock <DatanodeProtocolClientSideTranslatorPB >(); Org.Mockito.Mockito.When(fakeDnProt.VersionRequest()).ThenReturn(fakeNsInfo); actor.SetNameNode(fakeDnProt); }
/// <summary>Format a block pool slice storage.</summary> /// <param name="dnCurDir">DataStorage current directory</param> /// <param name="nsInfo">the name space info</param> /// <exception cref="System.IO.IOException">Signals that an I/O exception has occurred. /// </exception> internal virtual void Format(FilePath dnCurDir, NamespaceInfo nsInfo) { FilePath curBpDir = GetBpRoot(nsInfo.GetBlockPoolID(), dnCurDir); Storage.StorageDirectory bpSdir = new Storage.StorageDirectory(curBpDir); Format(bpSdir, nsInfo); }
public virtual void TestCapabilitiesInited() { NamespaceInfo nsInfo = new NamespaceInfo(); NUnit.Framework.Assert.IsTrue(nsInfo.IsCapabilitySupported(NamespaceInfo.Capability .StorageBlockReportBuffers)); }
private bool TryFindNamespaceNode( SyntaxNode syntaxRoot, NamespaceInfo namespaceInfo, #if VS2022 out BaseNamespaceDeclarationSyntax?fNamespace #else out NamespaceDeclarationSyntax?fNamespace
/// <exception cref="System.IO.IOException"/> public override void Format(NamespaceInfo ns) { // Formatting file journals is done by the StorageDirectory // format code, since they may share their directory with // checkpoints, etc. throw new NotSupportedException(); }
/// <summary> /// Retrieves the subjects that have ACL entries set for a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The subjects.</returns> public SubjectInfo[] RetrieveSubjectsForNamespace(NamespaceInfo nspace) { string resourceName = Actions.ForNamespaces.ResourceMasterPrefix; if (nspace != null) { resourceName += nspace.Name; } AclEntry[] entries = _settingsProvider.AclManager.RetrieveEntriesForResource(resourceName); List <SubjectInfo> result = new List <SubjectInfo>(entries.Length); for (int i = 0; i < entries.Length; i++) { SubjectType type = AuthTools.IsGroup(entries[i].Subject) ? SubjectType.Group : SubjectType.User; // Remove the subject qualifier ('U.' or 'G.') string name = entries[i].Subject.Substring(2); if (result.Find(delegate(SubjectInfo x) { return(x.Name == name && x.Type == type); }) == null) { result.Add(new SubjectInfo(name, type)); } } return(result.ToArray()); }
// Constructor. public XmlNamespaceManager(XmlNameTable nameTable) { // Validate the parameters. if(nameTable == null) { throw new ArgumentNullException("nameTable"); } // Record the name table for later. this.nameTable = nameTable; // Add special namespaces for "xml" and "xmlns". xmlCompareQuick = nameTable.Add("xml"); xmlNsCompareQuick = nameTable.Add("xmlns"); namespaces = new NamespaceInfo (xmlCompareQuick, nameTable.Add(XmlDocument.xmlnsXml), null); namespaces = new NamespaceInfo (xmlNsCompareQuick, nameTable.Add(XmlDocument.xmlns), namespaces); // Mark the position of the outermost scope level. namespaces = new NamespaceInfo(null, String.Empty, namespaces); }
/// <summary> /// Detects the correct <see cref="T:NamespaceInfo" /> object associated to the current namespace using the <b>NS</b> parameter in the query string. /// </summary> /// <returns>The correct <see cref="T:NamespaceInfo" /> object, or <c>null</c>.</returns> public static NamespaceInfo DetectCurrentNamespaceInfo() { var nspace = HttpContext.Current.Request["NS"]; NamespaceInfo nsinfo = nspace != null?Pages.FindNamespace(nspace) : null; return(nsinfo); }
public ResourceExtension(string resourceName, string assemblyName) { if (!string.IsNullOrEmpty(assemblyName)) Resource = new NamespaceInfo(resourceName, Assembly.Load(assemblyName)); else Resource = new NamespaceInfo(resourceName); }
/// <summary> /// Gets the pages in the selected namespace. /// </summary> /// <returns>The pages.</returns> private IList <PageInfo> GetPages() { NamespaceInfo nspace = Pages.FindNamespace(lstNamespace.SelectedValue); List <PageInfo> pages = Pages.GetPages(nspace); var orphanPages = Pages.GetOrphanedPages(pages); var result = new List <PageInfo>(pages.Count); var filter = txtFilter.Text.Trim().ToLower(System.Globalization.CultureInfo.CurrentCulture); foreach (PageInfo page in pages) { if (NameTools.GetLocalName(page.FullName).ToLower(System.Globalization.CultureInfo.CurrentCulture).Contains(filter)) { if (chkOrphansOnly.Checked && !orphanPages.Contains(page.FullName)) { continue; } else { result.Add(page); } } } result.Sort(new PageNameComparer()); return(result); }
public DefaultNamespaceManager() { var asm = typeof(Eto.Forms.Application).Assembly; DefaultNamespace = new NamespaceInfo("Eto.Forms", asm); Namespaces.Add("drawing", new NamespaceInfo("Eto.Drawing", asm)); }
public void AssertOnNamespace(Address addr, NamespaceInfo namespaceInfo) { const string NS1 = "myspace"; const string NS2 = "myspace.subspace"; const string NS3 = "spacetest"; const string NS4 = "nis1porttest"; Debug.WriteLine(string.Format("AssertOnNamespace: NamespaceInfo received for namespace '{0}', owned by {1}", namespaceInfo.NamespaceId, addr.Pretty)); Assert.AreEqual(Config.TACCOUNT_TO_WATCH2, namespaceInfo.Owner.Pretty); switch (namespaceInfo.NamespaceId) { case NS1: Assert.AreEqual((ulong)1516704, namespaceInfo.Height); break; case NS2: Assert.AreEqual((ulong)1516704, namespaceInfo.Height); break; case NS3: Assert.AreEqual((ulong)1494919, namespaceInfo.Height); break; case NS4: Assert.AreEqual((ulong)1494918, namespaceInfo.Height); break; default: throw new Exception("AssertOnOwnedNamespace: Unsupported Namespace"); } }
/// <exception cref="System.IO.IOException"/> internal QuorumJournalManager(Configuration conf, URI uri, NamespaceInfo nsInfo, AsyncLogger.Factory loggerFactory) { // Timeouts for which the QJM will wait for each of the following actions. // Since these don't occur during normal operation, we can // use rather lengthy timeouts, and don't need to make them // configurable. Preconditions.CheckArgument(conf != null, "must be configured"); this.conf = conf; this.uri = uri; this.nsInfo = nsInfo; this.loggers = new AsyncLoggerSet(CreateLoggers(loggerFactory)); this.connectionFactory = URLConnectionFactory.NewDefaultURLConnectionFactory(conf ); // Configure timeouts. this.startSegmentTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalStartSegmentTimeoutKey , DFSConfigKeys.DfsQjournalStartSegmentTimeoutDefault); this.prepareRecoveryTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalPrepareRecoveryTimeoutKey , DFSConfigKeys.DfsQjournalPrepareRecoveryTimeoutDefault); this.acceptRecoveryTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalAcceptRecoveryTimeoutKey , DFSConfigKeys.DfsQjournalAcceptRecoveryTimeoutDefault); this.finalizeSegmentTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalFinalizeSegmentTimeoutKey , DFSConfigKeys.DfsQjournalFinalizeSegmentTimeoutDefault); this.selectInputStreamsTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalSelectInputStreamsTimeoutKey , DFSConfigKeys.DfsQjournalSelectInputStreamsTimeoutDefault); this.getJournalStateTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalGetJournalStateTimeoutKey , DFSConfigKeys.DfsQjournalGetJournalStateTimeoutDefault); this.newEpochTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalNewEpochTimeoutKey, DFSConfigKeys.DfsQjournalNewEpochTimeoutDefault); this.writeTxnsTimeoutMs = conf.GetInt(DFSConfigKeys.DfsQjournalWriteTxnsTimeoutKey , DFSConfigKeys.DfsQjournalWriteTxnsTimeoutDefault); }
public virtual void TestEmptyInprogressLedger() { URI uri = BKJMUtil.CreateJournalURI("/hdfsjournal-emptyInprogressLedger"); NamespaceInfo nsi = NewNSInfo(); BookKeeperJournalManager bkjm = new BookKeeperJournalManager(conf, uri, nsi); bkjm.Format(nsi); EditLogOutputStream @out = bkjm.StartLogSegment(1, NameNodeLayoutVersion.CurrentLayoutVersion ); for (long i = 1; i <= 100; i++) { FSEditLogOp op = FSEditLogTestUtil.GetNoOpInstance(); op.SetTransactionId(i); @out.Write(op); } @out.Close(); bkjm.FinalizeLogSegment(1, 100); @out = bkjm.StartLogSegment(101, NameNodeLayoutVersion.CurrentLayoutVersion); @out.Close(); bkjm.Close(); bkjm = new BookKeeperJournalManager(conf, uri, nsi); bkjm.RecoverUnfinalizedSegments(); @out = bkjm.StartLogSegment(101, NameNodeLayoutVersion.CurrentLayoutVersion); for (long i_1 = 1; i_1 <= 100; i_1++) { FSEditLogOp op = FSEditLogTestUtil.GetNoOpInstance(); op.SetTransactionId(i_1); @out.Write(op); } @out.Close(); bkjm.FinalizeLogSegment(101, 200); bkjm.Close(); }
public virtual void TestSimpleRead() { NamespaceInfo nsi = NewNSInfo(); BookKeeperJournalManager bkjm = new BookKeeperJournalManager(conf, BKJMUtil.CreateJournalURI ("/hdfsjournal-simpleread"), nsi); bkjm.Format(nsi); long numTransactions = 10000; EditLogOutputStream @out = bkjm.StartLogSegment(1, NameNodeLayoutVersion.CurrentLayoutVersion ); for (long i = 1; i <= numTransactions; i++) { FSEditLogOp op = FSEditLogTestUtil.GetNoOpInstance(); op.SetTransactionId(i); @out.Write(op); } @out.Close(); bkjm.FinalizeLogSegment(1, numTransactions); IList <EditLogInputStream> @in = new AList <EditLogInputStream>(); bkjm.SelectInputStreams(@in, 1, true); try { NUnit.Framework.Assert.AreEqual(numTransactions, FSEditLogTestUtil.CountTransactionsInStream (@in[0])); } finally { @in[0].Close(); } }
protected void btnNormal_Click(object sender, EventArgs e) { NamespaceInfo nspace = Pages.FindNamespace(txtCurrentNamespace.Value); RemoveAllPermissions(nspace); // Set permissions AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.FullControl, Users.FindUserGroup(Settings.AdministratorsGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.CreatePages, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ManageCategories, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.PostDiscussion, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.DownloadAttachments, Users.FindUserGroup(Settings.UsersGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ReadPages, Users.FindUserGroup(Settings.AnonymousGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.ReadDiscussion, Users.FindUserGroup(Settings.AnonymousGroup)); AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, nspace, Actions.ForNamespaces.DownloadAttachments, Users.FindUserGroup(Settings.AnonymousGroup)); RefreshPermissionsManager(); }
public virtual void TestSimpleRecovery() { NamespaceInfo nsi = NewNSInfo(); BookKeeperJournalManager bkjm = new BookKeeperJournalManager(conf, BKJMUtil.CreateJournalURI ("/hdfsjournal-simplerecovery"), nsi); bkjm.Format(nsi); EditLogOutputStream @out = bkjm.StartLogSegment(1, NameNodeLayoutVersion.CurrentLayoutVersion ); for (long i = 1; i <= 100; i++) { FSEditLogOp op = FSEditLogTestUtil.GetNoOpInstance(); op.SetTransactionId(i); @out.Write(op); } @out.SetReadyToFlush(); @out.Flush(); @out.Abort(); @out.Close(); NUnit.Framework.Assert.IsNull(zkc.Exists(bkjm.FinalizedLedgerZNode(1, 100), false )); NUnit.Framework.Assert.IsNotNull(zkc.Exists(bkjm.InprogressZNode(1), false)); bkjm.RecoverUnfinalizedSegments(); NUnit.Framework.Assert.IsNotNull(zkc.Exists(bkjm.FinalizedLedgerZNode(1, 100), false )); NUnit.Framework.Assert.IsNull(zkc.Exists(bkjm.InprogressZNode(1), false)); }
protected List <TreeElement> ctPages_Populate(object sender, PopulateEventArgs e) { List <TreeElement> result = new List <TreeElement>(100); NamespaceInfo selectedNamespace = Pages.FindNamespace(currentWiki, lstNamespace.SelectedValue); NamespaceInfo currentNamespace = DetectNamespaceInfo(); foreach (PageContent pi in Pages.GetPages(currentWiki, selectedNamespace)) { string formattedTitle = FormattingPipeline.PrepareTitle(currentWiki, pi.Title, false, FormattingContext.Other, pi.FullName); string onClickJavascript = "javascript:"; // Populate the page title box if the title is different to the page name if (pi.FullName != pi.Title) { // Supply the page title to the Javascript that sets the page title on the page // We can safely escape the \ character, but the " character is interpreted by the browser even if it is escaped to Javascript, so we can't allow it. // The non-wysiwyg version escapes ' and replaces " with escaped ', but ' breaks the html insertion, so remove it altogether // Similarly, < on it's own is fine, but causes problems when combined with text and > to form a tag. Safest to remove < characters to prevent // breaking the drop-down. onClickJavascript += "SetValue('txtPageTitle', '" + pi.Title.Replace("\\", "\\\\").Replace("'", "").Replace("\"", "").Replace("<", "") + "');"; } else { onClickJavascript += "SetValue('txtPageTitle', '');"; } // Populate the page name (#468: add ++ to all ReverseFormatter to work) onClickJavascript += "return SetValue('txtPageName', '" + (selectedNamespace != currentNamespace ? "++" : "") + pi.FullName + "');"; TreeElement item = new TreeElement((selectedNamespace != currentNamespace ? "++" : "") + pi.FullName, formattedTitle, onClickJavascript); result.Add(item); } return(result); }
public virtual void TestTwoWriters() { long start = 1; NamespaceInfo nsi = NewNSInfo(); BookKeeperJournalManager bkjm1 = new BookKeeperJournalManager(conf, BKJMUtil.CreateJournalURI ("/hdfsjournal-dualWriter"), nsi); bkjm1.Format(nsi); BookKeeperJournalManager bkjm2 = new BookKeeperJournalManager(conf, BKJMUtil.CreateJournalURI ("/hdfsjournal-dualWriter"), nsi); EditLogOutputStream out1 = bkjm1.StartLogSegment(start, NameNodeLayoutVersion.CurrentLayoutVersion ); try { bkjm2.StartLogSegment(start, NameNodeLayoutVersion.CurrentLayoutVersion); NUnit.Framework.Assert.Fail("Shouldn't have been able to open the second writer"); } catch (IOException ioe) { Log.Info("Caught exception as expected", ioe); } finally { out1.Close(); } }
/// <summary> /// Adds a new Navigation Path. /// </summary> /// <param name="nspace">The target namespace (<c>null</c> for the root).</param> /// <param name="name">The Name.</param> /// <param name="pages">The Pages.</param> /// <param name="provider">The Provider to use for the new Navigation Path, or <c>null</c> for the default provider.</param> /// <returns>True if the Path is added successfully.</returns> public static bool AddNavigationPath(NamespaceInfo nspace, string name, List <PageInfo> pages, IPagesStorageProviderV30 provider) { var namespaceName = nspace != null ? nspace.Name : null; var fullName = NameTools.GetFullName(namespaceName, name); if (Exists(fullName)) { return(false); } if (provider == null) { provider = Collectors.PagesProviderCollector.GetProvider(Settings.DefaultPagesProvider); } NavigationPath newPath = provider.AddNavigationPath(namespaceName, name, pages.ToArray()); if (newPath != null) { Log.LogEntry("Navigation Path " + fullName + " added", EntryType.General, Log.SystemUsername); } else { Log.LogEntry("Creation failed for Navigation Path " + fullName, EntryType.Error, Log.SystemUsername); } return(newPath != null); }
/// <summary> /// Adds some ACL entries for a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <param name="grants">The granted actions.</param> /// <param name="denials">The denied actions.</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool AddAclEntriesForNamespace(string subject, string nspace, string[] grants, string[] denials) { bool isGroup = subject.StartsWith("G."); subject = subject.Substring(2); NamespaceInfo namespaceInfo = Pages.FindNamespace(nspace); UserGroup group = null; UserInfo user = null; if (isGroup) { group = Users.FindUserGroup(subject); } else { user = Users.FindUser(subject); } foreach (string action in grants) { bool done = false; if (isGroup) { done = AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, namespaceInfo, action, group); } else { done = AuthWriter.SetPermissionForNamespace(AuthStatus.Grant, namespaceInfo, action, user); } if (!done) { return(false); } } foreach (string action in denials) { bool done = false; if (isGroup) { done = AuthWriter.SetPermissionForNamespace(AuthStatus.Deny, namespaceInfo, action, group); } else { done = AuthWriter.SetPermissionForNamespace(AuthStatus.Deny, namespaceInfo, action, user); } if (!done) { return(false); } } return(true); }
public virtual void TestEditLogFileNotExistsWhenReadingMetadata() { URI uri = BKJMUtil.CreateJournalURI("/hdfsjournal-editlogfile"); NamespaceInfo nsi = NewNSInfo(); BookKeeperJournalManager bkjm = new BookKeeperJournalManager(conf, uri, nsi); bkjm.Format(nsi); try { // start new inprogress log segment with txid=1 // and write transactions till txid=50 string zkpath1 = StartAndFinalizeLogSegment(bkjm, 1, 50); // start new inprogress log segment with txid=51 // and write transactions till txid=100 string zkpath2 = StartAndFinalizeLogSegment(bkjm, 51, 100); // read the metadata from ZK. Here simulating the situation // when reading,the edit log metadata can be removed by purger thread. ZooKeeper zkspy = Org.Mockito.Mockito.Spy(BKJMUtil.ConnectZooKeeper()); bkjm.SetZooKeeper(zkspy); Org.Mockito.Mockito.DoThrow(new KeeperException.NoNodeException(zkpath2 + " doesn't exists" )).When(zkspy).GetData(zkpath2, false, null); IList <EditLogLedgerMetadata> ledgerList = bkjm.GetLedgerList(false); NUnit.Framework.Assert.AreEqual("List contains the metadata of non exists path.", 1, ledgerList.Count); NUnit.Framework.Assert.AreEqual("LogLedgerMetadata contains wrong zk paths.", zkpath1 , ledgerList[0].GetZkPath()); } finally { bkjm.Close(); } }
/// <summary> /// Populates the namespaces list for migration. /// </summary> /// <param name="page">The selected page.</param> /// <returns><c>true</c> if there is at least one valid target namespace, <c>false</c> otherwise.</returns> private bool PopulateTargetNamespaces(PageInfo page) { string currentUser = SessionFacade.GetCurrentUsername(); string[] currentGroups = SessionFacade.GetCurrentGroupNames(); lstTargetNamespace.Items.Clear(); NamespaceInfo pageNamespace = Pages.FindNamespace(NameTools.GetNamespace(page.FullName)); if (pageNamespace != null) { // Try adding Root as target namespace bool canManagePages = AuthChecker.CheckActionForNamespace(null, Actions.ForNamespaces.ManagePages, currentUser, currentGroups); if (canManagePages) { lstTargetNamespace.Items.Add(new ListItem("<root>", "")); } } // Try adding all other namespaces foreach (NamespaceInfo nspace in Pages.GetNamespaces().FindAll(n => n.Provider == page.Provider)) { if (pageNamespace == null || (pageNamespace != null && nspace.Name != pageNamespace.Name)) { bool canManagePages = AuthChecker.CheckActionForNamespace(nspace, Actions.ForNamespaces.ManagePages, currentUser, currentGroups); if (canManagePages) { lstTargetNamespace.Items.Add(new ListItem(nspace.Name, nspace.Name)); } } } return(lstTargetNamespace.Items.Count > 0); }
protected void btnRename_Click(object sender, EventArgs e) { lblRenameResult.CssClass = ""; lblRenameResult.Text = ""; txtNewName.Text = txtNewName.Text.Trim(); Page.Validate("rename"); if (!Page.IsValid) { return; } NamespaceInfo nspace = Pages.FindNamespace(txtCurrentNamespace.Value); string theme = Settings.GetTheme(nspace.Name); if (Pages.RenameNamespace(nspace, txtNewName.Text)) { Settings.SetTheme(txtNewName.Text, theme); RefreshList(); lblRenameResult.CssClass = "resultok"; lblRenameResult.Text = Properties.Messages.NamespaceRenamed; ReturnToList(); } else { lblRenameResult.CssClass = "resulterror"; lblRenameResult.Text = Properties.Messages.CouldNotRenameNamespace; } }
/// <summary> /// Removes all the ACL Entries for a namespace that are bound to a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private bool RemoveEntriesForNamespace(string subject, NamespaceInfo nspace) { string resourceName = Actions.ForNamespaces.ResourceMasterPrefix; if (nspace != null) { resourceName += nspace.Name; } AclEntry[] entries = _settingsProvider.AclManager.RetrieveEntriesForSubject(subject); foreach (AclEntry entry in entries) { if (entry.Resource == resourceName) { // This call automatically logs the operation result bool done = SetPermissionForNamespace(AuthStatus.Delete, nspace, entry.Action, subject); if (!done) { return(false); } } } return(true); }
/// <summary> /// Loads the available pages and selects the current one. /// </summary> private void LoadDefaultPages() { // Populate default page, if there is a namespace selected if (!string.IsNullOrEmpty(txtCurrentNamespace.Value)) { NamespaceInfo nspace = Pages.FindNamespace( txtCurrentNamespace.Value != RootName ? txtCurrentNamespace.Value : null); List <PageInfo> pages = Pages.GetPages(nspace); string currentDefaultPage = nspace != null ? nspace.DefaultPage.FullName : Settings.DefaultPage; lstDefaultPage.Items.Clear(); foreach (PageInfo page in pages) { ListItem item = new ListItem(NameTools.GetLocalName(page.FullName), page.FullName); if (page.FullName == currentDefaultPage) { item.Selected = true; } lstDefaultPage.Items.Add(item); } } }
/// <summary> /// Retrieves the subjects that have ACL entries set for a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The subjects.</returns> public static SubjectInfo[] RetrieveSubjectsForNamespace(NamespaceInfo nspace) { var resourceName = Actions.ForNamespaces.ResourceMasterPrefix; if (nspace != null) { resourceName += nspace.Name; } var entries = SettingsProvider.AclManager.RetrieveEntriesForResource(resourceName); var result = new List <SubjectInfo>(); foreach (var entry in entries) { SubjectType type = AuthTools.IsGroup(entry.Subject) ? SubjectType.Group : SubjectType.User; // Remove the subject qualifier ('U.' or 'G.') var name = entry.Subject.Substring(2); if (result.Find(delegate(SubjectInfo x) { return(x.Name == name && x.Type == type); }) == null) { result.Add(new SubjectInfo(name, type)); } } return(result.ToArray()); }
/// <summary> /// Adds a new Navigation Path. /// </summary> /// <param name="nspace">The target namespace (<c>null</c> for the root).</param> /// <param name="name">The Name.</param> /// <param name="pages">The Pages.</param> /// <param name="provider">The Provider to use for the new Navigation Path, or <c>null</c> for the default provider.</param> /// <returns>True if the Path is added successfully.</returns> public static bool AddNavigationPath(NamespaceInfo nspace, string name, List<PageInfo> pages, IPagesStorageProviderV30 provider) { string namespaceName = nspace != null ? nspace.Name : null; string fullName = NameTools.GetFullName(namespaceName, name); if(Exists(fullName)) return false; if(provider == null) provider = Collectors.PagesProviderCollector.GetProvider(Settings.DefaultPagesProvider); NavigationPath newPath = provider.AddNavigationPath(namespaceName, name, pages.ToArray()); if(newPath != null) Log.LogEntry("Navigation Path " + fullName + " added", EntryType.General, Log.SystemUsername); else Log.LogEntry("Creation failed for Navigation Path " + fullName, EntryType.Error, Log.SystemUsername); return newPath != null; }
/// <summary> /// Gets the list of Navigation Paths in a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The navigation paths.</returns> public NavigationPath[] GetNavigationPaths(NamespaceInfo nspace) { return NavigationPaths.GetNavigationPaths(nspace).ToArray(); }
/// <summary> /// Gets the List of Categories in a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The categories.</returns> public CategoryInfo[] GetCategories(NamespaceInfo nspace) { return Pages.GetCategories(nspace).ToArray(); }
/// <summary> /// Checks whether an action is allowed for a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <param name="action">The action (see <see cref="Actions.ForNamespaces" /> class)</param> /// <param name="user">The user.</param> /// <returns><c>true</c> if the action is allowed, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">If <b>action</b> or <b>user</b> are <c>null</c>.</exception> /// <exception cref="ArgumentException">If <b>action</b> is empty.</exception> public bool CheckActionForNamespace(NamespaceInfo nspace, string action, UserInfo user) { if(action == null) throw new ArgumentNullException("action"); if(action.Length == 0) throw new ArgumentException("Action cannot be empty", "action"); var temp = user != null ? user : Users.GetAnonymousAccount(); return AuthChecker.CheckActionForNamespace(nspace, action, temp.Username, temp.Groups); }
private void AssertNamespaceInfosAreEqual(NamespaceInfo expected, NamespaceInfo actual, bool checkProvider) { Assert.AreEqual(expected.Name, actual.Name, "Wrong name"); if(expected.DefaultPage == null) Assert.IsNull(actual.DefaultPage, "DefaultPage should be null"); else AssertPageInfosAreEqual(expected.DefaultPage, actual.DefaultPage, true); if(checkProvider) Assert.AreSame(expected.Provider, actual.Provider); }
/// <summary> /// Gets all the Categories in a namespace. /// </summary> /// <param name="nspace">The namespace.</param> /// <returns>All the Categories in the namespace, sorted by name.</returns> public CategoryInfo[] GetCategories(NamespaceInfo nspace) { lock(this) { CategoryInfo[] allCategories = GetAllCategories(); // Sorted // Preallocate assuming that there are 4 namespaces and that they are distributed evenly among them: // categories might be a few dozens at most, so preallocating a smaller number of items is not a problem List<CategoryInfo> selectedCategories = new List<CategoryInfo>(allCategories.Length / 4); // Select categories that have the same namespace as the requested one, // either null-null or same name foreach(CategoryInfo cat in allCategories) { string catNamespace = NameTools.GetNamespace(cat.FullName); if(nspace == null && catNamespace == null) selectedCategories.Add(cat); else if(nspace != null && catNamespace != null && StringComparer.OrdinalIgnoreCase.Compare(nspace.Name, catNamespace) == 0) selectedCategories.Add(cat); } return selectedCategories.ToArray(); } }
/// <summary> /// Fires the NamespaceActivity event. /// </summary> /// <param name="nspace">The namespace the activity refers to.</param> /// <param name="nspaceOldName">The old name of the renamed namespace, or <c>null</c>.</param> /// <param name="activity">The activity.</param> public void OnNamespaceActivity(NamespaceInfo nspace, string nspaceOldName, NamespaceActivity activity) { if(NamespaceActivity != null) { NamespaceActivity(this, new NamespaceActivityEventArgs(nspace, nspaceOldName, activity)); } }
/// <summary> /// Gets the list of the Wiki Pages in a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The pages.</returns> public PageInfo[] GetPages(NamespaceInfo nspace) { return Pages.GetPages(nspace).ToArray(); }
/// <summary> /// Gets the canonical URL tag for a page. /// </summary> /// <param name="requestUrl">The request URL.</param> /// <param name="currentPage">The current page.</param> /// <param name="nspace">The namespace.</param> /// <returns>The canonical URL, or an empty string if <paramref name="requestUrl"/> is already canonical.</returns> public static string GetCanonicalUrlTag(string requestUrl, PageInfo currentPage, NamespaceInfo nspace) { string url = ""; if(nspace == null && currentPage.FullName == Settings.DefaultPage) url = Settings.GetMainUrl().ToString(); else url = Settings.GetMainUrl().ToString().TrimEnd('/') + "/" + currentPage.FullName + Settings.PageExtension; // Case sensitive if(url == requestUrl) return ""; else return "<link rel=\"canonical\" href=\"" + url + "\" />"; }
/// <summary> /// Gets all the pages in a namespace that are bound to zero categories. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The pages, sorted by name.</returns> public PageInfo[] GetUncategorizedPages(NamespaceInfo nspace) { lock(this) { PageInfo[] pages = GetPages(nspace); CategoryInfo[] categories = GetCategories(nspace); List<PageInfo> result = new List<PageInfo>(pages.Length); foreach(PageInfo p in pages) { bool found = false; foreach(CategoryInfo c in categories) { foreach(string name in c.Pages) { if(StringComparer.OrdinalIgnoreCase.Compare(name, p.FullName) == 0) { found = true; break; } } } if(!found) result.Add(p); } return result.ToArray(); } }
/// <summary> /// Gets the theme in use for a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>The theme.</returns> public string GetTheme(NamespaceInfo nspace) { return Settings.GetTheme(nspace != null ? nspace.Name : null); }
/// <summary> /// Finds a namespace. /// </summary> /// <param name="name">The name of the namespace to find.</param> /// <param name="namespaces">The namespaces array.</param> /// <returns>The found namespace, or <c>null</c>.</returns> private NamespaceInfo FindNamespace(string name, NamespaceInfo[] namespaces) { if(name == null) return null; NamespaceInfo target = new NamespaceInfo(name, this, null); NamespaceComparer comp = new NamespaceComparer(); NamespaceInfo result = Array.Find(namespaces, delegate(NamespaceInfo n) { return comp.Compare(n, target) == 0; }); return result; }
/// <summary> /// Sets the default page of a namespace. /// </summary> /// <param name="nspace">The namespace of which to set the default page.</param> /// <param name="page">The page to use as default page, or <c>null</c>.</param> /// <returns>The correct <see cref="T:NamespaceInfo" /> object.</returns> /// <exception cref="ArgumentNullException">If <b>nspace</b> is <c>null</c>.</exception> public NamespaceInfo SetNamespaceDefaultPage(NamespaceInfo nspace, PageInfo page) { if(nspace == null) throw new ArgumentNullException("nspace"); lock(this) { // Find requested namespace and page: if they don't exist, return null NamespaceInfo[] allNamespaces = GetNamespaces(); NamespaceInfo targetNamespace = FindNamespace(nspace.Name, allNamespaces); if(targetNamespace == null) return null; LocalPageInfo localPage = null; if(page != null) { localPage = LoadLocalPageInfo(page); if(localPage == null) return null; } targetNamespace.DefaultPage = localPage; DumpNamespaces(allNamespaces); namespacesCache = null; return new NamespaceInfo(targetNamespace.Name, this, targetNamespace.DefaultPage); } }
/// <summary> /// Moves the backups of a page into a new namespace. /// </summary> /// <param name="page">The page that is being moved.</param> /// <param name="destination">The destination namespace (<c>null</c> for the root).</param> /// <remarks>This method should be invoked <b>before</b> moving the corresponding page.</remarks> private void MoveBackups(PageInfo page, NamespaceInfo destination) { lock(this) { int[] backups = GetBackups(page); if(backups == null) return; // Page does not exist LocalPageInfo local = (LocalPageInfo)page; string extension = Path.GetExtension(local.File); string currDir = GetNamespacePartialPathForPageContent(NameTools.GetNamespace(page.FullName)); string newDir = GetNamespacePartialPathForPageContent(destination != null ? destination.Name : null); string currPartialName = currDir + Path.GetFileNameWithoutExtension(local.File) + "."; string newPartialName = newDir + NameTools.GetLocalName(page.FullName) + "."; for(int i = 0; i < backups.Length; i++) { File.Move(GetFullPathForPageContent(currPartialName + Tools.GetVersionString(backups[i]) + extension), GetFullPathForPageContent(newPartialName + Tools.GetVersionString(backups[i]) + extension)); } } }
/// <summary> /// Removes a namespace. /// </summary> /// <param name="nspace">The namespace to remove.</param> /// <returns><c>true</c> if the namespace is removed, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">If <b>nspace</b> is <c>null</c>.</exception> public bool RemoveNamespace(NamespaceInfo nspace) { if(nspace == null) throw new ArgumentNullException("nspace"); lock(this) { // Load all namespaces and remove the one to remove List<NamespaceInfo> allNamespaces = new List<NamespaceInfo>(GetNamespaces()); NamespaceComparer comp = new NamespaceComparer(); int index = allNamespaces.FindIndex(delegate(NamespaceInfo x) { return comp.Compare(x, nspace) == 0; }); if(index >= 0) { // Delete all categories foreach(CategoryInfo cat in GetCategories(nspace)) { RemoveCategory(cat); } // Delete all pages in the namespace (RemovePage removes the page from the search engine index) nspace.DefaultPage = null; // TODO: Remove this trick (needed in order to delete the default page) foreach(PageInfo page in GetPages(nspace)) { RemovePage(page); } // Update namespaces file allNamespaces.RemoveAt(index); DumpNamespaces(allNamespaces.ToArray()); // Remove namespace folder Directory.Delete(GetFullPathForPageContent(GetNamespacePartialPathForPageContent(nspace.Name)), true); // Remove drafts folder string oldDraftsFullPath = GetFullPathForPageDrafts(nspace.Name); if(Directory.Exists(oldDraftsFullPath)) { Directory.Delete(oldDraftsFullPath, true); } // Remove messages folder Directory.Delete(GetFullPathForMessages(GetNamespacePartialPathForPageContent(nspace.Name)), true); namespacesCache = null; pagesCache = null; categoriesCache = null; return true; } else return false; } }
/// <summary> /// Dumps namespaces on disk. /// </summary> /// <param name="namespaces">The namespaces to dump.</param> private void DumpNamespaces(NamespaceInfo[] namespaces) { StringBuilder sb = new StringBuilder(namespaces.Length * 20); foreach(NamespaceInfo ns in namespaces) { sb.Append(ns.Name); sb.Append("|"); sb.Append(ns.DefaultPage != null ? ns.DefaultPage.FullName : ""); sb.Append("\r\n"); } File.WriteAllText(GetFullPath(NamespacesFile), sb.ToString()); }
/// <summary> /// Sets a permission for a namespace. /// </summary> /// <param name="status">The authorization status.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <param name="action">The action of which to modify the authorization status.</param> /// <param name="subject">The subject of the authorization change.</param> /// <returns><c>true</c> if the authorization status is changed, <c>false</c> otherwise.</returns> private static bool SetPermissionForNamespace(AuthStatus status, NamespaceInfo nspace, string action, string subject) { if(action == null) throw new ArgumentNullException("action"); if(action.Length == 0) throw new ArgumentException("Action cannot be empty", "action"); if(action != Actions.FullControl && !AuthTools.IsValidAction(action, Actions.ForNamespaces.All)) { throw new ArgumentException("Invalid action", "action"); } string namespaceName = nspace != null ? nspace.Name : ""; if(status == AuthStatus.Delete) { bool done = SettingsProvider.AclManager.DeleteEntry(Actions.ForNamespaces.ResourceMasterPrefix + namespaceName, action, subject); if(done) { Log.LogEntry(MessageDeleteSuccess + GetLogMessage(Actions.ForNamespaces.ResourceMasterPrefix, namespaceName, action, subject, Delete), EntryType.General, Log.SystemUsername); } else { Log.LogEntry(MessageDeleteFailure + GetLogMessage(Actions.ForNamespaces.ResourceMasterPrefix, namespaceName, action, subject, Delete), EntryType.Error, Log.SystemUsername); } return done; } else { bool done = SettingsProvider.AclManager.StoreEntry(Actions.ForNamespaces.ResourceMasterPrefix + namespaceName, action, subject, status == AuthStatus.Grant ? Value.Grant : Value.Deny); if(done) { Log.LogEntry(MessageSetSuccess + GetLogMessage(Actions.ForNamespaces.ResourceMasterPrefix, namespaceName, action, subject, Set + status.ToString()), EntryType.General, Log.SystemUsername); } else { Log.LogEntry(MessageSetFailure + GetLogMessage(Actions.ForNamespaces.ResourceMasterPrefix, namespaceName, action, subject, Set + status.ToString()), EntryType.Error, Log.SystemUsername); } return done; } }
/// <summary> /// Renames a namespace. /// </summary> /// <param name="nspace">The namespace to rename.</param> /// <param name="newName">The new name of the namespace.</param> /// <returns>The correct <see cref="T:NamespaceInfo" /> object.</returns> /// <exception cref="ArgumentNullException">If <b>nspace</b> or <b>newName</b> are <c>null</c>.</exception> /// <exception cref="ArgumentException">If <b>newName</b> is empty.</exception> public NamespaceInfo RenameNamespace(NamespaceInfo nspace, string newName) { if(nspace == null) throw new ArgumentNullException("nspace"); if(newName == null) throw new ArgumentNullException("newName"); if(newName.Length == 0) throw new ArgumentException("New Name cannot be empty", "newName"); lock(this) { if(NamespaceExists(newName)) return null; string oldName = nspace.Name; // Remove all pages and their messages from search engine index foreach(PageInfo page in GetPages(nspace)) { PageContent content = GetContent(page); UnindexPage(content); Message[] messages = GetMessages(page); foreach(Message msg in messages) { UnindexMessageTree(page, msg); } } // Load namespace list and change name NamespaceInfo[] allNamespaces = GetNamespaces(); NamespaceComparer comp = new NamespaceComparer(); NamespaceInfo result = FindNamespace(nspace.Name, allNamespaces); if(result == null) return null; result.Name = newName; // Change default page full name if(result.DefaultPage != null) { result.DefaultPage = new LocalPageInfo(NameTools.GetFullName(newName, NameTools.GetLocalName(result.DefaultPage.FullName)), this, result.DefaultPage.CreationDateTime, GetNamespacePartialPathForPageContent(newName) + Path.GetFileName(((LocalPageInfo)result.DefaultPage).File)); } DumpNamespaces(allNamespaces); // Update Category list with new namespace name CategoryInfo[] allCategories = GetAllCategories(); for(int k = 0; k < allCategories.Length; k++) { CategoryInfo category = allCategories[k]; string catNamespace = NameTools.GetNamespace(category.FullName); if(catNamespace != null && StringComparer.OrdinalIgnoreCase.Compare(catNamespace, oldName) == 0) { category.FullName = NameTools.GetFullName(newName, NameTools.GetLocalName(category.FullName)); for(int i = 0; i < category.Pages.Length; i++) { category.Pages[i] = NameTools.GetFullName(newName, NameTools.GetLocalName(category.Pages[i])); } } } DumpCategories(allCategories); // Rename namespace folder Directory.Move(GetFullPathForPageContent(GetNamespacePartialPathForPageContent(oldName)), GetFullPathForPageContent(GetNamespacePartialPathForPageContent(newName))); // Rename drafts folder string oldDraftsFullPath = GetFullPathForPageDrafts(nspace.Name); if(Directory.Exists(oldDraftsFullPath)) { string newDraftsFullPath = GetFullPathForPageDrafts(newName); Directory.Move(oldDraftsFullPath, newDraftsFullPath); } // Rename messages folder Directory.Move(GetFullPathForMessages(GetNamespacePartialPathForPageContent(oldName)), GetFullPathForMessages(GetNamespacePartialPathForPageContent(newName))); // Update Page list with new namespace name and file PageInfo[] allPages = GetAllPages(); foreach(PageInfo page in allPages) { string pageNamespace = NameTools.GetNamespace(page.FullName); if(pageNamespace != null && StringComparer.OrdinalIgnoreCase.Compare(pageNamespace, oldName) == 0) { LocalPageInfo local = (LocalPageInfo)page; local.FullName = NameTools.GetFullName(newName, NameTools.GetLocalName(local.FullName)); local.File = GetNamespacePartialPathForPageContent(newName) + Path.GetFileName(local.File); } } DumpPages(allPages); namespacesCache = null; pagesCache = null; categoriesCache = null; // Re-add all pages and their messages to the search engine index foreach(PageInfo page in GetPages(result)) { // result contains the new name PageContent content = GetContent(page); IndexPage(content); Message[] messages = GetMessages(page); foreach(Message msg in messages) { IndexMessageTree(page, msg); } } return result; } }
/// <summary> /// Sets a permission for a namespace. /// </summary> /// <param name="status">The authorization status.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <param name="action">The action of which to modify the authorization status.</param> /// <param name="user">The user subject of the authorization change.</param> /// <returns><c>true</c> if the authorization status is changed, <c>false</c> otherwise.</returns> public static bool SetPermissionForNamespace(AuthStatus status, NamespaceInfo nspace, string action, UserInfo user) { if(user == null) throw new ArgumentNullException("user"); return SetPermissionForNamespace(status, nspace, action, AuthTools.PrepareUsername(user.Username)); }
/// <summary> /// Moves a page from its namespace into another. /// </summary> /// <param name="page">The page to move.</param> /// <param name="destination">The destination namespace (null for the root).</param> /// <param name="copyCategories">A value indicating whether to copy the page categories in the destination /// namespace, if not already available.</param> /// <returns>The correct instance of <see cref="T:PageInfo" />.</returns> /// <exception cref="ArgumentNullException">If <b>page</b> is <c>null</c>.</exception> public PageInfo MovePage(PageInfo page, NamespaceInfo destination, bool copyCategories) { if(page == null) throw new ArgumentNullException("page"); string destinationName = destination != null ? destination.Name : null; NamespaceInfo currentNs = FindNamespace(NameTools.GetNamespace(page.FullName), GetNamespaces()); NamespaceComparer nsComp = new NamespaceComparer(); if((currentNs == null && destination == null) || nsComp.Compare(currentNs, destination) == 0) return null; if(PageExists(new PageInfo(NameTools.GetFullName(destinationName, NameTools.GetLocalName(page.FullName)), this, page.CreationDateTime))) return null; if(!NamespaceExists(destinationName)) return null; if(currentNs != null && currentNs.DefaultPage != null) { // Cannot move the default page if(new PageNameComparer().Compare(currentNs.DefaultPage, page) == 0) return null; } // Store categories for copying them, if needed CategoryInfo[] pageCategories = GetCategoriesForPage(page); // Update categories names with new namespace (don't modify the same instance because it's actually the cache!) for(int i = 0; i < pageCategories.Length; i++) { string[] pages = pageCategories[i].Pages; pageCategories[i] = new CategoryInfo(NameTools.GetFullName(destinationName, NameTools.GetLocalName(pageCategories[i].FullName)), this); pageCategories[i].Pages = new string[pages.Length]; for(int k = 0; k < pages.Length; k++) { pageCategories[i].Pages[k] = NameTools.GetFullName(destinationName, NameTools.GetLocalName(pages[k])); } } // Delete category bindings RebindPage(page, new string[0]); // Change namespace and file PageInfo[] allPages = GetAllPages(); PageNameComparer comp = new PageNameComparer(); PageInfo newPage = null; foreach(PageInfo current in allPages) { if(comp.Compare(current, page) == 0) { // Page found, update data // Change namespace and file LocalPageInfo local = (LocalPageInfo)current; // Update search engine index PageContent oldPageContent = GetContent(local); UnindexPage(oldPageContent); foreach(Message msg in GetMessages(local)) { UnindexMessageTree(local, msg); } // Move backups in new folder MoveBackups(page, destination); string newFile = GetNamespacePartialPathForPageContent(destinationName) + Path.GetFileName(local.File); // Move data file File.Move(GetFullPathForPageContent(local.File), GetFullPathForPageContent(newFile)); // Move messages file string messagesFullPath = GetFullPathForMessages(local.File); if(File.Exists(messagesFullPath)) { File.Move(messagesFullPath, GetFullPathForMessages(newFile)); } // Move draft file string draftFullPath = GetFullPathForPageDrafts(local.File); if(File.Exists(draftFullPath)) { string newDraftFullPath = GetFullPathForPageDrafts(newFile); if(!Directory.Exists(Path.GetDirectoryName(newDraftFullPath))) { Directory.CreateDirectory(Path.GetDirectoryName(newDraftFullPath)); } File.Move(draftFullPath, newDraftFullPath); } //local.Namespace = destinationName; local.FullName = NameTools.GetFullName(destinationName, NameTools.GetLocalName(local.FullName)); local.File = newFile; newPage = local; DumpPages(allPages); // Update search engine index IndexPage(new PageContent(newPage, oldPageContent.Title, oldPageContent.User, oldPageContent.LastModified, oldPageContent.Comment, oldPageContent.Content, oldPageContent.Keywords, oldPageContent.Description)); foreach(Message msg in GetMessages(local)) { IndexMessageTree(newPage, msg); } break; } } // Rebind page, if needed if(copyCategories) { // Foreach previously bound category, verify that is present in the destination namespace, if not then create it List<string> newCategories = new List<string>(pageCategories.Length); foreach(CategoryInfo oldCategory in pageCategories) { if(!CategoryExists(new CategoryInfo(oldCategory.FullName, this))) { AddCategory(destination != null ? destination.Name : null, NameTools.GetLocalName(oldCategory.FullName)); } newCategories.Add(oldCategory.FullName); } RebindPage(newPage, newCategories.ToArray()); } namespacesCache = null; pagesCache = null; categoriesCache = null; return newPage; }
public ResourceExtension(string resourceName) { Resource = new NamespaceInfo(resourceName); }
/// <summary> /// Removes all the ACL Entries for a namespace that are bound to a subject. /// </summary> /// <param name="subject">The subject.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns><c>true</c> if the operation succeeded, <c>false</c> otherwise.</returns> private static bool RemoveEntriesForNamespace(string subject, NamespaceInfo nspace) { string resourceName = Actions.ForNamespaces.ResourceMasterPrefix; if(nspace != null) resourceName += nspace.Name; AclEntry[] entries = SettingsProvider.AclManager.RetrieveEntriesForSubject(subject); foreach(AclEntry entry in entries) { if(entry.Resource == resourceName) { // This call automatically logs the operation result bool done = SetPermissionForNamespace(AuthStatus.Delete, nspace, entry.Action, subject); if(!done) return false; } } return true; }
/// <summary> /// Gets all the Navigation Paths in a Namespace. /// </summary> /// <param name="nspace">The Namespace.</param> /// <returns>All the Navigation Paths, sorted by name.</returns> public NavigationPath[] GetNavigationPaths(NamespaceInfo nspace) { lock(this) { NavigationPath[] allNavigationPaths = GetAllNavigationPaths(); List<NavigationPath> selectedNavigationPaths = new List<NavigationPath>(allNavigationPaths.Length / 4); foreach(NavigationPath path in allNavigationPaths) { string pathNamespace = NameTools.GetNamespace(path.FullName); if(nspace == null && pathNamespace == null) selectedNavigationPaths.Add(path); if(nspace != null && pathNamespace != null && StringComparer.OrdinalIgnoreCase.Compare(nspace.Name, pathNamespace) == 0) selectedNavigationPaths.Add(path); } selectedNavigationPaths.Sort(new NavigationPathComparer()); return selectedNavigationPaths.ToArray(); } }
/// <summary> /// Sets a permission for a namespace. /// </summary> /// <param name="status">The authorization status.</param> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <param name="action">The action of which to modify the authorization status.</param> /// <param name="group">The group subject of the authorization change.</param> /// <returns><c>true</c> if the authorization status is changed, <c>false</c> otherwise.</returns> public static bool SetPermissionForNamespace(AuthStatus status, NamespaceInfo nspace, string action, UserGroup group) { if(group == null) throw new ArgumentNullException("group"); return SetPermissionForNamespace(status, nspace, action, AuthTools.PrepareGroup(group.Name)); }
public override object ProvideValue(IServiceProvider serviceProvider) { var provideValue = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget; var propertyInfo = provideValue?.TargetProperty as PropertyInfo; var contextProvider = serviceProvider.GetService(typeof(IXamlSchemaContextProvider)) as IXamlSchemaContextProvider; if (contextProvider != null) { var context = contextProvider.SchemaContext as EtoXamlSchemaContext; if (context != null && context.DesignMode) { // TODO: Lookup resource file using ide service so we can actually show the image or use the resource if (propertyInfo != null) { if (typeof(Bitmap).IsAssignableFrom(propertyInfo.PropertyType)) return new Bitmap(24, 24, PixelFormat.Format32bppRgba); if (typeof(Icon).IsAssignableFrom(propertyInfo.PropertyType)) return new Icon(1, new Bitmap(24, 24, PixelFormat.Format32bppRgba)); // return its current value if not a known type to handle return propertyInfo.GetValue(provideValue.TargetObject, null); } return null; } } Assembly assembly; NamespaceInfo resource; if (!string.IsNullOrEmpty(AssemblyName)) { assembly = Assembly.Load(new AssemblyName(AssemblyName)); resource = new NamespaceInfo(ResourceName, assembly); } else { try { resource = new NamespaceInfo(ResourceName); } catch (ArgumentException) { var rootProvider = serviceProvider.GetService(typeof(IRootObjectProvider)) as IRootObjectProvider; if (rootProvider == null) throw; assembly = rootProvider.RootObject.GetType().GetTypeInfo().Assembly; resource = new NamespaceInfo(ResourceName, assembly); } } if (propertyInfo != null && !propertyInfo.PropertyType.GetTypeInfo().IsAssignableFrom(typeof(Stream).GetTypeInfo())) { var converter = TypeDescriptor.GetConverter(propertyInfo.PropertyType); if (converter != null) { if (converter.CanConvertFrom(typeof(NamespaceInfo))) return converter.ConvertFrom(resource); if (converter.CanConvertFrom(typeof(Stream))) return converter.ConvertFrom(resource.FindResource()); } var streamArgs = new [] { typeof(Stream) }; var constructor = propertyInfo.PropertyType.GetConstructor(streamArgs); if (constructor != null) { return constructor.Invoke(new[] { resource.FindResource() }); } } Stream stream = null; if (resource != null && resource.Assembly != null) stream = resource.FindResource(); return stream; }
/// <summary> /// Gets all the Pages in a namespace. /// </summary> /// <param name="nspace">The namespace (<c>null</c> for the root).</param> /// <returns>All the Pages in the namespace. The array is not sorted.</returns> public PageInfo[] GetPages(NamespaceInfo nspace) { lock(this) { PageInfo[] allPages = GetAllPages(); // Preallocate assuming that there are 2 namespaces and that they are evenly distributed across them: // pages can be as much as many thousands, so preallocating a smaller number can cause a performance loss List<PageInfo> selectedPages = new List<PageInfo>(allPages.Length / 2); // Select pages that have the same namespace as the requested one, // either null-null or same name foreach(PageInfo page in allPages) { string pageNamespace = NameTools.GetNamespace(page.FullName); if(nspace == null && pageNamespace == null) selectedPages.Add(page); if(nspace != null && pageNamespace != null && StringComparer.OrdinalIgnoreCase.Compare(nspace.Name, pageNamespace) == 0) selectedPages.Add(page); } return selectedPages.ToArray(); } }