// Token: 0x06000E5B RID: 3675 RVA: 0x00056660 File Offset: 0x00054860 private SharingPolicyCache(SharingPolicy policy, bool isDehydrated) { ArgumentValidator.ThrowIfNull("policy", policy); this.policy = policy; this.BelongsToDehydratedContainer = isDehydrated; this.PopulatePolicyHash(); }
internal InMemoryPlan(QueueMetrics queueMetrics, SharingPolicy policy, ReservationAgent agent, Org.Apache.Hadoop.Yarn.Api.Records.Resource totalCapacity, long step, ResourceCalculator resCalc, Org.Apache.Hadoop.Yarn.Api.Records.Resource minAlloc, Org.Apache.Hadoop.Yarn.Api.Records.Resource maxAlloc, string queueName, Planner replanner, bool getMoveOnExpiry) : this(queueMetrics, policy, agent, totalCapacity, step, resCalc, minAlloc, maxAlloc , queueName, replanner, getMoveOnExpiry, new UTCClock()) { }
/// <summary> /// Factory for <see cref="EvaluationContext" /> /// </summary> public static EvaluationContext Create(SharingPolicy policy) { var context = new EvaluationContext(policy); TestOnlyHookOnCreate?.Invoke(context); return(context); }
// Token: 0x06000E4C RID: 3660 RVA: 0x00055DB0 File Offset: 0x00053FB0 private bool ApplyPolicy(MailboxSession mailboxSession, SharingPolicy policy) { using (MailboxData mailboxData = new MailboxData(mailboxSession, policy)) { if (mailboxData.MaxAnonymousDetailLevel == 0) { SharingPolicyAssistant.Tracer.TraceDebug <IExchangePrincipal>((long)this.GetHashCode(), "Anonymous access is disabled. Clearing AD SharingAnonymousIdentities entries for user:{0}", mailboxData.MailboxSession.MailboxOwner); ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate() { ADUser aduser = mailboxData.RecipientSession.Read(mailboxData.MailboxSession.MailboxOwner.ObjectId) as ADUser; aduser.SharingAnonymousIdentities.Clear(); mailboxData.RecipientSession.Save(aduser); }, 3); if (!adoperationResult.Succeeded) { SharingPolicyAssistant.Tracer.TraceError <IExchangePrincipal, Exception>((long)this.GetHashCode(), "Failed to clear AD SharingAnonymousIdentities entries for user:{0}, Error: {1}", mailboxData.MailboxSession.MailboxOwner, adoperationResult.Exception); return(false); } } using (Folder folder = Folder.Bind(mailboxSession, DefaultFolderType.Configuration)) { using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.DeepTraversal, null, null, SharingPolicyAssistant.FolderQueryProperties)) { for (;;) { object[][] rows = queryResult.GetRows(64); if (rows == null || rows.Length == 0) { break; } foreach (object[] array2 in rows) { string arg = array2[1] as string; StoreId storeId = array2[0] as StoreId; if (storeId == null) { SharingPolicyAssistant.Tracer.TraceError <IExchangePrincipal, object, string>((long)this.GetHashCode(), "{0}: cannot process folder row due unknown id: {1} - {2}", mailboxSession.MailboxOwner, array2[0], arg); } else { using (FolderData folderData = new FolderData(mailboxSession, storeId)) { this.ApplyPolicyForExternalSharing(array2, mailboxData, folderData); this.ApplyPolicyForAnonymousSharing(array2, mailboxData, folderData); if (folderData.IsChanged) { folderData.Folder.Save(); } } } } } } } } return(true); }
public static void GetObjectPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store) { SharingPolicy sharingPolicy = store.GetDataObject("SharingPolicy") as SharingPolicy; if (dataTable.Rows.Count == 1 && sharingPolicy != null) { SharingPolicyAssistor.UpdateFormattedNameAndDomains(dataTable.Rows[0]); } }
// Token: 0x06000E2E RID: 3630 RVA: 0x000556F4 File Offset: 0x000538F4 internal MailboxData(MailboxSession mailboxSession, SharingPolicy sharingPolicy) { if (mailboxSession == null) { throw new ArgumentNullException("mailboxSession"); } this.mailboxSession = mailboxSession; this.sharingPolicy = sharingPolicy; }
internal EvaluationContext(SharingPolicy policy) { Policy = policy; SdkResolverService = new CachingSdkResolverService(); FileEntryExpansionCache = new ConcurrentDictionary <string, ImmutableArray <string> >(); FileSystem = new CachingFileSystemWrapper(FileSystems.Default); EngineFileUtilities = new EngineFileUtilities(new FileMatcher(FileSystem, FileEntryExpansionCache)); }
// Token: 0x06000E60 RID: 3680 RVA: 0x00056750 File Offset: 0x00054950 private static SharingPolicyCache GetHydratedPolicyFromCacheOrAD(OrganizationId orgId, ADObjectId policyId) { SharingPolicyCache sharingPolicyCache; lock (SharingPolicyCache.cacheSyncLock) { if (policyId == SharingPolicyCache.DynamicDefaultPolicy) { if (SharingPolicyCache.hydratedDefaultCache.TryGetValue(orgId, out sharingPolicyCache)) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId, OrganizationId>(0L, "Found Default Sharing Policy {0} in hydratedDefaultCache for Org {1}.", policyId, orgId); return(sharingPolicyCache); } } else if (SharingPolicyCache.hydratedCache.TryGetValue(policyId.ObjectGuid, out sharingPolicyCache)) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId, OrganizationId>(0L, "Found Sharing Policy {0} in hydratedCache for Org {1}.", policyId, orgId); return(sharingPolicyCache); } } IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(orgId), 211, "GetHydratedPolicyFromCacheOrAD", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\SharingPolicy\\SharingPolicyCache.cs"); tenantOrTopologyConfigurationSession.SessionSettings.IsSharedConfigChecked = true; bool flag2 = policyId == SharingPolicyCache.DynamicDefaultPolicy; if (flag2) { policyId = SharingPolicyCache.GetDefaultSharingPolicyId(tenantOrTopologyConfigurationSession); if (policyId == null) { return(null); } } SharingPolicy sharingPolicy = tenantOrTopologyConfigurationSession.Read <SharingPolicy>(policyId); if (sharingPolicy == null) { SharingPolicyCache.Tracer.TraceWarning <ADObjectId, bool>(0L, "Unable to find SharingPolicy {0} in the AD. PolicyId is default:{1}", policyId, flag2); sharingPolicyCache = null; } else { sharingPolicyCache = new SharingPolicyCache(sharingPolicy, false); } lock (SharingPolicyCache.cacheSyncLock) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId>(0L, "Add the Sharing Policy {0} to cache.", policyId); SharingPolicyCache.hydratedCache[policyId.ObjectGuid] = sharingPolicyCache; if (sharingPolicyCache != null && flag2) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId, OrganizationId>(0L, "Add Default Sharing Policy {0} of Org {1} to hydrated cache ", policyId, orgId); SharingPolicyCache.hydratedDefaultCache[orgId] = sharingPolicyCache; } } return(sharingPolicyCache); }
/// <summary> /// Factory for <see cref="EvaluationContext" /> /// </summary> /// <param name="policy"> The <see cref="SharingPolicy"/> to use.</param> /// <param name="fileSystem">The <see cref="IFileSystem"/> to use. /// This parameter is compatible only with <see cref="SharingPolicy.Shared"/>. /// The method throws if a file system is used with <see cref="SharingPolicy.Isolated"/>. /// The reasoning is that <see cref="SharingPolicy.Isolated"/> means not reusing any caches between evaluations, /// and the passed in <paramref name="fileSystem"/> might cache state. /// </param> public static EvaluationContext Create(SharingPolicy policy, MSBuildFileSystemBase fileSystem) { var context = new EvaluationContext( policy, fileSystem); TestOnlyHookOnCreate?.Invoke(context); return(context); }
private EvaluationContext(SharingPolicy policy, IFileSystem fileSystem, ISdkResolverService sdkResolverService = null, ConcurrentDictionary <string, IReadOnlyList <string> > fileEntryExpansionCache = null) { Policy = policy; SdkResolverService = sdkResolverService ?? new CachingSdkResolverService(); FileEntryExpansionCache = fileEntryExpansionCache ?? new ConcurrentDictionary <string, IReadOnlyList <string> >(); FileSystem = fileSystem ?? new CachingFileSystemWrapper(FileSystems.Default); FileMatcher = new FileMatcher(FileSystem, FileEntryExpansionCache); }
// Token: 0x06000E4F RID: 3663 RVA: 0x00056108 File Offset: 0x00054308 private void ApplyPolicyToFolder(SharingPolicy policy, FolderData folderData) { StoreObjectType objectType = ObjectClass.GetObjectType(folderData.Folder.ClassName); List <PermissionSecurityPrincipal> list = new List <PermissionSecurityPrincipal>(); PermissionSet permissionSet = folderData.Folder.GetPermissionSet(); foreach (Permission permission in permissionSet) { if (permission.Principal.Type == PermissionSecurityPrincipal.SecurityPrincipalType.ExternalUserPrincipal) { SharingPolicyAction sharingPolicyAction = (SharingPolicyAction)0; if (policy != null) { sharingPolicyAction = (permission.Principal.ExternalUser.IsReachUser ? policy.GetAllowedForAnonymousCalendarSharing() : policy.GetAllowed(permission.Principal.ExternalUser.SmtpAddress.Domain)); } MemberRights memberRights = MemberRights.None; if (sharingPolicyAction != (SharingPolicyAction)0) { memberRights = PolicyAllowedMemberRights.GetAllowed(sharingPolicyAction, objectType); } if (memberRights == MemberRights.None) { list.Add(permission.Principal); } else { MemberRights memberRights2 = ~memberRights & permission.MemberRights; if (memberRights2 != MemberRights.None) { if (objectType == StoreObjectType.CalendarFolder) { if ((permission.MemberRights & MemberRights.ReadAny) != MemberRights.None) { permission.MemberRights |= MemberRights.FreeBusyDetailed; } if ((permission.MemberRights & MemberRights.FreeBusyDetailed) != MemberRights.None) { permission.MemberRights |= MemberRights.FreeBusySimple; } } permission.MemberRights = (memberRights & permission.MemberRights); folderData.IsChanged = true; } } } } if (list.Count > 0) { foreach (PermissionSecurityPrincipal securityPrincipal in list) { permissionSet.RemoveEntry(securityPrincipal); } folderData.IsChanged = true; } }
public virtual void TearDown() { resCalc = null; minAlloc = null; maxAlloc = null; totalCapacity = null; clock = null; queueMetrics = null; policy = null; replanner = null; }
protected override void InternalSave(ConfigurableObject instance) { if (instance == null) { throw new ArgumentNullException("instance"); } MailboxCalendarFolder mailboxCalendarFolder = instance as MailboxCalendarFolder; if (mailboxCalendarFolder == null) { throw new NotSupportedException("Save: " + instance.GetType().FullName); } if (mailboxCalendarFolder.PublishEnabled) { SharingPolicy sharingPolicy = DirectoryHelper.ReadSharingPolicy(base.MailboxSession.MailboxOwner.MailboxInfo.MailboxGuid, base.MailboxSession.MailboxOwner.MailboxInfo.IsArchive, base.MailboxSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid)); if (sharingPolicy == null || !sharingPolicy.Enabled || !sharingPolicy.IsAllowedForAnonymousCalendarSharing()) { throw new NotAllowedPublishingByPolicyException(); } SharingPolicyAction allowedForAnonymousCalendarSharing = sharingPolicy.GetAllowedForAnonymousCalendarSharing(); int maxAllowed = PolicyAllowedDetailLevel.GetMaxAllowed(allowedForAnonymousCalendarSharing); if (mailboxCalendarFolder.DetailLevel > (DetailLevelEnumType)maxAllowed) { throw new NotAllowedPublishingByPolicyException(mailboxCalendarFolder.DetailLevel, (DetailLevelEnumType)maxAllowed); } } MailboxFolderId mailboxFolderId = mailboxCalendarFolder.MailboxFolderId; StoreObjectId folderId = mailboxFolderId.StoreObjectIdValue ?? base.ResolveStoreObjectIdFromFolderPath(mailboxFolderId.MailboxFolderPath); if (folderId == null || folderId.ObjectType != StoreObjectType.CalendarFolder) { throw new CantFindCalendarFolderException(mailboxFolderId); } using (CalendarFolder calendarFolder = CalendarFolder.Bind(base.MailboxSession, folderId)) { ExtendedFolderFlags?valueAsNullable = calendarFolder.GetValueAsNullable <ExtendedFolderFlags>(FolderSchema.ExtendedFolderFlags); if (valueAsNullable != null && (valueAsNullable.Value & ExtendedFolderFlags.PersonalShare) != (ExtendedFolderFlags)0) { throw new CannotShareFolderException(ServerStrings.CannotShareOtherPersonalFolder); } this.SaveSharingAnonymous(mailboxCalendarFolder, folderId); if (!mailboxCalendarFolder.PublishEnabled) { mailboxCalendarFolder.PublishedCalendarUrl = null; mailboxCalendarFolder.PublishedICalUrl = null; } UserConfigurationDictionaryHelper.Save(mailboxCalendarFolder, MailboxCalendarFolder.CalendarFolderConfigurationProperties, (bool createIfNonexisting) => UserConfigurationHelper.GetPublishingConfiguration(this.MailboxSession, folderId, createIfNonexisting)); if (MailboxCalendarFolderDataProvider.UpdateExtendedFolderFlags(mailboxCalendarFolder, calendarFolder)) { calendarFolder.Save(); } } }
private void EnforceSharingPolicy(MailboxSession mailboxSession, ICollection <MapiAclTableRestriction.ExternalUserPermission> externalUserPermissions) { Util.ThrowOnNullArgument(mailboxSession, "mailboxSession"); if (externalUserPermissions == null || externalUserPermissions.Count == 0) { return; } List <RightsNotAllowedRecipient> list = new List <RightsNotAllowedRecipient>(externalUserPermissions.Count); SharingPolicy sharingPolicy = null; foreach (MapiAclTableRestriction.ExternalUserPermission externalUserPermission in externalUserPermissions) { if (sharingPolicy == null) { IMailboxInfo mailboxInfo = mailboxSession.MailboxOwner.MailboxInfo; sharingPolicy = DirectoryHelper.ReadSharingPolicy(mailboxInfo.MailboxGuid, mailboxInfo.IsArchive, mailboxSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid)); if (sharingPolicy == null) { ExTraceGlobals.StorageTracer.TraceDebug <IExchangePrincipal>((long)this.GetHashCode(), "{0}: No policy assigned means no external sharing is allowed for this user.", mailboxSession.MailboxOwner); throw new NotAllowedExternalSharingByPolicyException(); } } if (!sharingPolicy.Enabled) { ExTraceGlobals.StorageTracer.TraceDebug <IExchangePrincipal>((long)this.GetHashCode(), "{0}: A disabled policy means no external sharing is allowed for this user.", mailboxSession.MailboxOwner); throw new NotAllowedExternalSharingByPolicyException(); } SharingPolicyAction sharingPolicyAction = externalUserPermission.Principal.ExternalUser.IsReachUser ? sharingPolicy.GetAllowedForAnonymousCalendarSharing() : sharingPolicy.GetAllowed(externalUserPermission.Principal.ExternalUser.SmtpAddress.Domain); if (sharingPolicyAction == (SharingPolicyAction)0) { ExTraceGlobals.StorageTracer.TraceDebug <IExchangePrincipal, PermissionSecurityPrincipal>((long)this.GetHashCode(), "{0}: Policy does not allow granting permissions to {1}.", mailboxSession.MailboxOwner, externalUserPermission.Principal); throw new PrincipalNotAllowedByPolicyException(externalUserPermission.Principal); } MemberRights allowed = PolicyAllowedMemberRights.GetAllowed(sharingPolicyAction, this.FolderInfo.StoreObjectType); MemberRights memberRights = ~allowed & externalUserPermission.MemberRights; if (memberRights != MemberRights.None) { ExTraceGlobals.StorageTracer.TraceDebug((long)this.GetHashCode(), "{0}: Policy does not allow granting permission {1} to {2} on {3} folder '{4}'.", new object[] { mailboxSession.MailboxOwner, memberRights, externalUserPermission.Principal, this.FolderInfo.StoreObjectType, this.FolderInfo.DisplayName }); list.Add(new RightsNotAllowedRecipient(externalUserPermission.Principal, memberRights)); } } if (list.Count > 0) { throw new RightsNotAllowedByPolicyException(list.ToArray(), this.FolderInfo.StoreObjectType, this.FolderInfo.DisplayName); } }
// Token: 0x06000E61 RID: 3681 RVA: 0x000568D8 File Offset: 0x00054AD8 private static SharingPolicyCache GetDehydratedPolicyFromCacheOrAD(OrganizationId orgId, ADObjectId policyId) { SharingPolicyCache sharingPolicyCache; if (policyId != SharingPolicyCache.DynamicDefaultPolicy) { lock (SharingPolicyCache.cacheSyncLock) { if (SharingPolicyCache.dehydratedDefaultCache.TryGetValue(policyId.ObjectGuid, out sharingPolicyCache)) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId>(0L, "Found Sharing Policy {0} in dehydrated cache.", policyId); return(sharingPolicyCache); } } } SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(orgId); IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, sharedConfiguration.GetSharedConfigurationSessionSettings(), 282, "GetDehydratedPolicyFromCacheOrAD", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\SharingPolicy\\SharingPolicyCache.cs"); tenantOrTopologyConfigurationSession.SessionSettings.IsSharedConfigChecked = true; bool flag2 = policyId == SharingPolicyCache.DynamicDefaultPolicy; if (flag2) { SharingPolicyCache.Tracer.TraceDebug <OrganizationId>(0L, "Find Default Policy Id for Org {0} ", orgId); policyId = SharingPolicyCache.GetDefaultSharingPolicyId(tenantOrTopologyConfigurationSession); if (policyId == null) { return(null); } lock (SharingPolicyCache.cacheSyncLock) { if (SharingPolicyCache.dehydratedDefaultCache.TryGetValue(policyId.ObjectGuid, out sharingPolicyCache)) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId>(0L, "Found Sharing Policy {0} in dehydrated cache.", policyId); return(sharingPolicyCache); } } } SharingPolicy sharingPolicy = tenantOrTopologyConfigurationSession.Read <SharingPolicy>(policyId); if (sharingPolicy == null) { SharingPolicyCache.Tracer.TraceError <ADObjectId, bool>(0L, "Unable to find SharingPolicy {0} in the AD. PolicyId is default:{1}", policyId, flag2); return(null); } sharingPolicyCache = new SharingPolicyCache(sharingPolicy, true); lock (SharingPolicyCache.cacheSyncLock) { SharingPolicyCache.dehydratedDefaultCache[policyId.ObjectGuid] = sharingPolicyCache; } return(sharingPolicyCache); }
public virtual void SetUp() { resCalc = new DefaultResourceCalculator(); minAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(1024, 1); maxAlloc = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(64 * 1024, 20); totalCapacity = Org.Apache.Hadoop.Yarn.Api.Records.Resource.NewInstance(100 * 1024 , 100); clock = Org.Mockito.Mockito.Mock <Clock>(); queueMetrics = Org.Mockito.Mockito.Mock <QueueMetrics>(); policy = Org.Mockito.Mockito.Mock <SharingPolicy>(); replanner = Org.Mockito.Mockito.Mock <Planner>(); Org.Mockito.Mockito.When(clock.GetTime()).ThenReturn(1L); }
public static SharingPolicy ReadSharingPolicy(Guid mailboxGuid, bool isArchive, IRecipientSession recipientSession) { ADRecipient adrecipient = DirectoryHelper.ReadADRecipient(mailboxGuid, isArchive, recipientSession); if (adrecipient == null) { throw new ObjectNotFoundException(ServerStrings.ADUserNotFound); } ADUser aduser = adrecipient as ADUser; if (aduser == null) { ExTraceGlobals.StorageTracer.TraceError <ADRecipient>((long)mailboxGuid.GetHashCode(), "ExchangePrincipal::ReadSharingPolicy. This is not an ADUser so policy doesn't apply. Recipient = {0}.", adrecipient); return(null); } ADObjectId adobjectId = aduser.SharingPolicy; ADSessionSettings adsessionSettings; if (SharedConfiguration.IsDehydratedConfiguration(aduser.OrganizationId)) { SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(aduser.OrganizationId); adsessionSettings = sharedConfiguration.GetSharedConfigurationSessionSettings(); } else { adsessionSettings = aduser.OrganizationId.ToADSessionSettings(); adsessionSettings.IsSharedConfigChecked = true; } IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, adsessionSettings, 248, "ReadSharingPolicy", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\DirectoryHelper.cs"); if (adobjectId == null) { FederatedOrganizationId federatedOrganizationId = tenantOrTopologyConfigurationSession.GetFederatedOrganizationId(tenantOrTopologyConfigurationSession.SessionSettings.CurrentOrganizationId); if (federatedOrganizationId != null) { adobjectId = federatedOrganizationId.DefaultSharingPolicyLink; } } SharingPolicy sharingPolicy = null; if (adobjectId != null) { sharingPolicy = tenantOrTopologyConfigurationSession.Read <SharingPolicy>(adobjectId); if (sharingPolicy == null) { throw new ObjectNotFoundException(ServerStrings.SharingPolicyNotFound(adobjectId.Name)); } } return(sharingPolicy); }
private EvaluationContext(SharingPolicy policy, IFileSystem fileSystem) { // Unsupported case: isolated context with non null file system. // Isolated means caches aren't reused, but the given file system might cache. ErrorUtilities.VerifyThrowArgument( policy == SharingPolicy.Shared || fileSystem == null, "IsolatedContextDoesNotSupportFileSystem"); Policy = policy; SdkResolverService = new CachingSdkResolverService(); FileEntryExpansionCache = new ConcurrentDictionary <string, IReadOnlyList <string> >(); FileSystem = fileSystem ?? new CachingFileSystemWrapper(FileSystems.Default); EngineFileUtilities = new EngineFileUtilities(new FileMatcher(FileSystem, FileEntryExpansionCache)); }
/// <summary> /// Factory for <see cref="EvaluationContext" /> /// </summary> /// <param name="policy"> The <see cref="SharingPolicy"/> to use.</param> /// <param name="fileSystem">The <see cref="IFileSystem"/> to use. /// This parameter is compatible only with <see cref="SharingPolicy.Shared"/>. /// The method throws if a file system is used with <see cref="SharingPolicy.Isolated"/>. /// The reasoning is that <see cref="SharingPolicy.Isolated"/> means not reusing any caches between evaluations, /// and the passed in <paramref name="fileSystem"/> might cache state. /// </param> public static EvaluationContext Create(SharingPolicy policy, MSBuildFileSystemBase fileSystem) { // Unsupported case: isolated context with non null file system. // Isolated means caches aren't reused, but the given file system might cache. ErrorUtilities.VerifyThrowArgument( policy == SharingPolicy.Shared || fileSystem == null, "IsolatedContextDoesNotSupportFileSystem"); var context = new EvaluationContext( policy, fileSystem); TestOnlyHookOnCreate?.Invoke(context); return(context); }
internal InMemoryPlan(QueueMetrics queueMetrics, SharingPolicy policy, ReservationAgent agent, Org.Apache.Hadoop.Yarn.Api.Records.Resource totalCapacity, long step, ResourceCalculator resCalc, Org.Apache.Hadoop.Yarn.Api.Records.Resource minAlloc, Org.Apache.Hadoop.Yarn.Api.Records.Resource maxAlloc, string queueName, Planner replanner, bool getMoveOnExpiry, Clock clock ) { this.queueMetrics = queueMetrics; this.policy = policy; this.agent = agent; this.step = step; this.totalCapacity = totalCapacity; this.resCalc = resCalc; this.minAlloc = minAlloc; this.maxAlloc = maxAlloc; this.rleSparseVector = new RLESparseResourceAllocation(resCalc, minAlloc); this.queueName = queueName; this.replanner = replanner; this.getMoveOnExpiry = getMoveOnExpiry; this.clock = clock; }
/// <exception cref="Org.Apache.Hadoop.Yarn.Exceptions.YarnException"/> protected internal virtual Plan InitializePlan(string planQueueName) { string planQueuePath = GetPlanQueuePath(planQueueName); SharingPolicy adPolicy = GetAdmissionPolicy(planQueuePath); adPolicy.Init(planQueuePath, GetReservationSchedulerConfiguration()); // Calculate the max plan capacity Resource minAllocation = GetMinAllocation(); Resource maxAllocation = GetMaxAllocation(); ResourceCalculator rescCalc = GetResourceCalculator(); Org.Apache.Hadoop.Yarn.Api.Records.Resource totCap = GetPlanQueueCapacity(planQueueName ); Plan plan = new InMemoryPlan(GetRootQueueMetrics(), adPolicy, GetAgent(planQueuePath ), totCap, planStepSize, rescCalc, minAllocation, maxAllocation, planQueueName, GetReplanner(planQueuePath), GetReservationSchedulerConfiguration().GetMoveOnExpiry (planQueuePath)); Log.Info("Intialized plan {0} based on reservable queue {1}", plan.ToString(), planQueueName ); return(plan); }
public EncryptionResults Encrypt(IExchangePrincipal mailboxOwner, IRecipientSession recipientSession, ExternalUserCollection externalUserCollection, ValidRecipient[] recipients, string sender, string containerClass, string folderId, IFrontEndLocator frontEndLocator) { SharingDataType sharingDataType = SharingDataType.FromContainerClass(containerClass); if (sharingDataType == null || !sharingDataType.IsExternallySharable) { throw new ArgumentOutOfRangeException("containerClass"); } ADUser aduser = DirectoryHelper.ReadADRecipient(mailboxOwner.MailboxInfo.MailboxGuid, mailboxOwner.MailboxInfo.IsArchive, recipientSession) as ADUser; if (aduser == null) { SharedFolderDataEncryption.Tracer.TraceError <SharedFolderDataEncryption, string>((long)this.GetHashCode(), "{0}: The Active Directory user was not found. Sender={1}.", this, sender); throw new ObjectNotFoundException(ServerStrings.ADUserNotFound); } ProxyAddress item = new SmtpProxyAddress(sender, false); if (!aduser.EmailAddresses.Contains(item)) { SharedFolderDataEncryption.Tracer.TraceError <SharedFolderDataEncryption, string>((long)this.GetHashCode(), "{0}: The SMTP address was not found in the user AD object for this mailbox. Sender={1}.", this, sender); throw new ObjectNotFoundException(ServerStrings.ADUserNotFound); } SharingPolicy sharingPolicy = DirectoryHelper.ReadSharingPolicy(mailboxOwner.MailboxInfo.MailboxGuid, mailboxOwner.MailboxInfo.IsArchive, recipientSession); SharedFolderDataEncryption.Tracer.TraceDebug <SharedFolderDataEncryption, object>((long)this.GetHashCode(), "{0}: Sharing policy to be applied to this user: {1}", this, (sharingPolicy == null) ? "<null>" : sharingPolicy.Id); SharingPolicyAction sharingPolicyActions = SharedFolderDataEncryption.GetSharingPolicyActions(sharingDataType.StoreObjectType); SharedFolderDataRecipient[] externalIdentities = SharedFolderDataEncryption.GetExternalIdentities(externalUserCollection, recipients); List <InvalidRecipient> list = new List <InvalidRecipient>(); Dictionary <TokenTarget, List <SharedFolderDataRecipient> > dictionary = new Dictionary <TokenTarget, List <SharedFolderDataRecipient> >(externalIdentities.Length, SharedFolderDataEncryption.TokenTargetComparer); for (int i = 0; i < recipients.Length; i++) { SharedFolderDataRecipient item2 = externalIdentities[i]; ValidRecipient validRecipient = recipients[i]; SmtpAddress smtpAddress = new SmtpAddress(validRecipient.SmtpAddress); string domain = smtpAddress.Domain; if (sharingPolicy == null || !sharingPolicy.IsAllowedForAnySharing(domain, sharingPolicyActions)) { SharedFolderDataEncryption.Tracer.TraceDebug <string>((long)this.GetHashCode(), "Sharing policy does not allow user to share with domain {0}", domain); list.Add(new InvalidRecipient(validRecipient.SmtpAddress, InvalidRecipientResponseCodeType.SystemPolicyBlocksSharingWithThisRecipient)); } else { SmtpAddress smtpAddress2 = new SmtpAddress(validRecipient.SmtpAddressForEncryption); TokenTarget tokenTarget = TargetUriResolver.Resolve(smtpAddress2.Domain, aduser.OrganizationId); if (tokenTarget == null) { list.Add(new InvalidRecipient(validRecipient.SmtpAddress, InvalidRecipientResponseCodeType.RecipientOrganizationNotFederated)); } else { List <SharedFolderDataRecipient> list2; if (!dictionary.TryGetValue(tokenTarget, out list2)) { list2 = new List <SharedFolderDataRecipient>(1); dictionary.Add(tokenTarget, list2); } list2.Add(item2); } } } List <EncryptedSharedFolderData> list3 = new List <EncryptedSharedFolderData>(dictionary.Count); SharedFolderData sharedFolderData = new SharedFolderData(); sharedFolderData.DataType = sharingDataType.ExternalName; sharedFolderData.FolderId = folderId; sharedFolderData.SharingUrl = this.GetSharingUrl(aduser, frontEndLocator); sharedFolderData.FederationUri = this.externalAuthentication.TokenValidator.TargetUri.ToString(); sharedFolderData.SenderSmtpAddress = sender; DelegationTokenRequest delegationTokenRequest = new DelegationTokenRequest { FederatedIdentity = aduser.GetFederatedIdentity(), EmailAddress = aduser.GetFederatedSmtpAddress(new SmtpAddress(sender)).ToString(), Offer = Offer.SharingInviteMessage }; SecurityTokenService securityTokenService = this.externalAuthentication.GetSecurityTokenService(aduser.OrganizationId); foreach (KeyValuePair <TokenTarget, List <SharedFolderDataRecipient> > keyValuePair in dictionary) { delegationTokenRequest.Target = keyValuePair.Key; sharedFolderData.Recipients = keyValuePair.Value.ToArray(); try { RequestedToken requestedToken = securityTokenService.IssueToken(delegationTokenRequest); list3.Add(this.Encrypt(requestedToken, sharedFolderData)); } catch (WSTrustException ex) { foreach (SharedFolderDataRecipient sharedFolderDataRecipient in sharedFolderData.Recipients) { list.Add(new InvalidRecipient(sharedFolderDataRecipient.SmtpAddress, SharedFolderDataEncryption.GetResponseCodeFromException(ex), ex.ToString())); } } } return(new EncryptionResults(list3.ToArray(), list.ToArray())); }
protected override void ResolveLocalSecondaryIdentities() { base.ResolveLocalSecondaryIdentities(); Mailbox mailbox = (Mailbox)this.GetDynamicParameters(); if (this.RemoveManagedFolderAndPolicy) { mailbox.ManagedFolderMailboxPolicy = null; } if (base.Fields.IsModified(MailboxSchema.RetentionPolicy)) { if (this.RetentionPolicy != null) { RetentionPolicy retentionPolicy = (RetentionPolicy)base.GetDataObject<RetentionPolicy>(this.RetentionPolicy, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorRetentionPolicyNotFound(this.RetentionPolicy.ToString())), new LocalizedString?(Strings.ErrorRetentionPolicyNotUnique(this.RetentionPolicy.ToString())), ExchangeErrorCategory.Client); mailbox.RetentionPolicy = (ADObjectId)retentionPolicy.Identity; mailbox.ManagedFolderMailboxPolicy = null; } else { mailbox.RetentionPolicy = null; } } base.SetReferenceParameter<RecipientIdParameter>(MailboxSchema.ForwardingAddress, this.ForwardingAddress, mailbox, new GetRecipientDelegate<RecipientIdParameter>(this.GetRecipient)); if (base.Fields.IsModified(MailboxSchema.OfflineAddressBook)) { if (this.OfflineAddressBook != null) { OfflineAddressBook offlineAddressBook = (OfflineAddressBook)base.GetDataObject<OfflineAddressBook>(this.OfflineAddressBook, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorOfflineAddressBookNotFound(this.OfflineAddressBook.ToString())), new LocalizedString?(Strings.ErrorOfflineAddressBookNotUnique(this.OfflineAddressBook.ToString())), ExchangeErrorCategory.Client); mailbox.OfflineAddressBook = (ADObjectId)offlineAddressBook.Identity; } else { mailbox.OfflineAddressBook = null; } } if (base.Fields.IsModified(ADRecipientSchema.AddressBookPolicy)) { AddressBookMailboxPolicyIdParameter addressBookMailboxPolicyIdParameter = (AddressBookMailboxPolicyIdParameter)base.Fields[ADRecipientSchema.AddressBookPolicy]; if (addressBookMailboxPolicyIdParameter != null) { AddressBookMailboxPolicy addressBookMailboxPolicy = (AddressBookMailboxPolicy)base.GetDataObject<AddressBookMailboxPolicy>(addressBookMailboxPolicyIdParameter, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorAddressBookMailboxPolicyNotFound(addressBookMailboxPolicyIdParameter.ToString())), new LocalizedString?(Strings.ErrorAddressBookMailboxPolicyNotUnique(addressBookMailboxPolicyIdParameter.ToString())), ExchangeErrorCategory.Client); mailbox[ADRecipientSchema.AddressBookPolicy] = (ADObjectId)addressBookMailboxPolicy.Identity; } else { mailbox[ADRecipientSchema.AddressBookPolicy] = null; } } if (base.Fields.IsModified(ADRecipientSchema.ThrottlingPolicy)) { if (SharedConfiguration.IsDehydratedConfiguration(base.CurrentOrganizationId)) { base.WriteError(new TaskInvalidOperationException(Strings.ErrorLinkOpOnDehydratedTenant("ThrottlingPolicy")), ExchangeErrorCategory.Context, this.DataObject.Identity); } ThrottlingPolicyIdParameter throttlingPolicyIdParameter = (ThrottlingPolicyIdParameter)base.Fields[ADRecipientSchema.ThrottlingPolicy]; if (throttlingPolicyIdParameter != null) { ThrottlingPolicy throttlingPolicy = (ThrottlingPolicy)base.GetDataObject<ThrottlingPolicy>(throttlingPolicyIdParameter, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorThrottlingPolicyNotFound(throttlingPolicyIdParameter.ToString())), new LocalizedString?(Strings.ErrorThrottlingPolicyNotUnique(throttlingPolicyIdParameter.ToString())), ExchangeErrorCategory.Client); mailbox[ADRecipientSchema.ThrottlingPolicy] = (ADObjectId)throttlingPolicy.Identity; } else { mailbox[ADRecipientSchema.ThrottlingPolicy] = null; } } if (base.Fields.IsModified(ADUserSchema.SharingPolicy)) { if (SharedConfiguration.IsDehydratedConfiguration(base.CurrentOrganizationId)) { base.WriteError(new LocalizedException(Strings.ErrorLinkOpOnDehydratedTenant("SharingPolicy")), ExchangeErrorCategory.Client, this.DataObject); } SharingPolicyIdParameter sharingPolicyIdParameter = (SharingPolicyIdParameter)base.Fields[ADUserSchema.SharingPolicy]; if (sharingPolicyIdParameter != null) { SharingPolicy sharingPolicy = (SharingPolicy)base.GetDataObject<SharingPolicy>(sharingPolicyIdParameter, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorSharingPolicyNotFound(sharingPolicyIdParameter.ToString())), new LocalizedString?(Strings.ErrorSharingPolicyNotUnique(sharingPolicyIdParameter.ToString())), ExchangeErrorCategory.Client); mailbox[ADUserSchema.SharingPolicy] = (ADObjectId)sharingPolicy.Identity; } else { mailbox[ADUserSchema.SharingPolicy] = null; } } if (base.Fields.IsModified(ADUserSchema.RemoteAccountPolicy)) { RemoteAccountPolicyIdParameter remoteAccountPolicyIdParameter = (RemoteAccountPolicyIdParameter)base.Fields[ADUserSchema.RemoteAccountPolicy]; if (remoteAccountPolicyIdParameter != null) { RemoteAccountPolicy remoteAccountPolicy = (RemoteAccountPolicy)base.GetDataObject<RemoteAccountPolicy>(remoteAccountPolicyIdParameter, this.ConfigurationSession, null, new LocalizedString?(Strings.ErrorRemoteAccountPolicyNotFound(remoteAccountPolicyIdParameter.ToString())), new LocalizedString?(Strings.ErrorRemoteAccountPolicyNotUnique(remoteAccountPolicyIdParameter.ToString())), ExchangeErrorCategory.Client); mailbox[ADUserSchema.RemoteAccountPolicy] = (ADObjectId)remoteAccountPolicy.Identity; } else { mailbox[ADUserSchema.RemoteAccountPolicy] = null; } } if (base.Fields.IsModified(ADRecipientSchema.RoleAssignmentPolicy)) { MailboxPolicyIdParameter mailboxPolicyIdParameter = (MailboxPolicyIdParameter)base.Fields[ADRecipientSchema.RoleAssignmentPolicy]; if (mailboxPolicyIdParameter != null) { IConfigurationSession tenantLocalConfigSession = RecipientTaskHelper.GetTenantLocalConfigSession(base.CurrentOrganizationId, base.ExecutingUserOrganizationId, base.RootOrgContainerId); RoleAssignmentPolicy roleAssignmentPolicy = (RoleAssignmentPolicy)base.GetDataObject<RoleAssignmentPolicy>(mailboxPolicyIdParameter, tenantLocalConfigSession, null, new LocalizedString?(Strings.ErrorRoleAssignmentPolicyNotFound(mailboxPolicyIdParameter.ToString())), new LocalizedString?(Strings.ErrorRoleAssignmentPolicyNotUnique(mailboxPolicyIdParameter.ToString())), ExchangeErrorCategory.Client); mailbox[ADRecipientSchema.RoleAssignmentPolicy] = (ADObjectId)roleAssignmentPolicy.Identity; } else { mailbox[ADRecipientSchema.RoleAssignmentPolicy] = null; } } if (base.Fields.IsModified(ADRecipientSchema.MailboxPlan)) { if (this.MailboxPlan != null) { ADUser aduser = base.ProvisioningCache.TryAddAndGetOrganizationDictionaryValue<ADUser, string>(CannedProvisioningCacheKeys.CacheKeyMailboxPlanIdParameterId, base.CurrentOrganizationId, this.MailboxPlan.RawIdentity, () => (ADUser)base.GetDataObject<ADUser>(this.MailboxPlan, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorMailboxPlanNotFound(this.MailboxPlan.ToString())), new LocalizedString?(Strings.ErrorMailboxPlanNotUnique(this.MailboxPlan.ToString())), ExchangeErrorCategory.Client)); MailboxTaskHelper.ValidateMailboxPlanRelease(aduser, new Task.ErrorLoggerDelegate(base.WriteError)); mailbox[ADRecipientSchema.MailboxPlan] = (ADObjectId)aduser.Identity; return; } mailbox[ADRecipientSchema.MailboxPlan] = null; } }
private void ProcessMessageRequest(MessageAction action) { SharingMessageItem sharingMessageItem = null; bool flag = false; RecipientInfoAC[] array = (RecipientInfoAC[])base.GetParameter("Recips"); if (array != null && array.Length != 0) { AutoCompleteCache.UpdateAutoCompleteCacheFromRecipientInfoList(array, base.OwaContext.UserContext); } SharingMessageItem requestItem; sharingMessageItem = (requestItem = base.GetRequestItem <SharingMessageItem>(new PropertyDefinition[0])); try { if (!sharingMessageItem.IsPublishing && (sharingMessageItem.SharingMessageType.IsInvitationOrAcceptOfRequest || sharingMessageItem.SharingMessageType.IsRequest)) { SharingLevel level = this.UpdateInviteOrRequestProperties(sharingMessageItem); this.SetSharingLevel(sharingMessageItem, level); } bool flag2 = base.UpdateMessage(sharingMessageItem, StoreObjectType.Message); if (action == MessageAction.Save) { ExTraceGlobals.MailTracer.TraceDebug((long)this.GetHashCode(), "Saving Sharing message"); Utilities.SaveItem(sharingMessageItem, true); this.RenderChangeKey(sharingMessageItem); } else if (action == MessageAction.Send) { if (flag2) { throw new OwaEventHandlerException("Unresolved recipients", LocalizedStrings.GetNonEncoded(2063734279)); } if (sharingMessageItem.Recipients.Count == 0 && action == MessageAction.Send) { throw new OwaEventHandlerException("No recipients", LocalizedStrings.GetNonEncoded(1878192149)); } if (Utilities.RecipientsOnlyHaveEmptyPDL <Recipient>(base.UserContext, sharingMessageItem.Recipients)) { base.RenderPartialFailure(1389137820); return; } ExTraceGlobals.MailTracer.TraceDebug((long)this.GetHashCode(), "Sending sharing message"); bool flag3 = false; if (base.IsParameterSet("ForceSend")) { flag3 = (bool)base.GetParameter("ForceSend"); } sharingMessageItem.SetSubmitFlags(flag3 ? SharingSubmitFlags.Auto : SharingSubmitFlags.None); try { if (flag) { sharingMessageItem.SendWithoutSavingMessage(); } else { sharingMessageItem.Send(); } } catch (ObjectNotFoundException e) { this.SendIdAndChangeKeyToClientOnError(sharingMessageItem, e); this.SanitizingWriter.Write("<p id=\"err\" _msg=\""); this.SanitizingWriter.Write(LocalizedStrings.GetNonEncoded(-1608187286), sharingMessageItem.SharedFolderName); this.SanitizingWriter.Write("\""); this.SanitizingWriter.Write(" _shareErr=\""); this.SanitizingWriter.Write(1); this.SanitizingWriter.Write("\"></p>"); } catch (InvalidSharingRecipientsException ex) { this.SendIdAndChangeKeyToClientOnError(sharingMessageItem, ex); this.SanitizingWriter.Write("<div id=\"err\" _msg=\"\" _shareErr=\""); SharingPolicy sharingPolicy = DirectoryHelper.ReadSharingPolicy(base.UserContext.MailboxSession.MailboxOwner.MailboxInfo.MailboxGuid, base.UserContext.MailboxSession.MailboxOwner.MailboxInfo.IsArchive, base.UserContext.MailboxSession.GetADRecipientSession(true, ConsistencyMode.IgnoreInvalid)); if (sharingPolicy != null && sharingPolicy.IsAllowedForAnonymousCalendarSharing() && ex.InvalidRecipientsResolution != null) { switch (ex.InvalidRecipientsResolution.Resolution) { case InvalidSharingRecipientsResolutionType.PublishAndTryAgain: this.SanitizingWriter.Write(3); this.SanitizingWriter.Write("\" _folderId=\""); this.SanitizingWriter.Write(ex.InvalidRecipientsResolution.FolderId); this.SanitizingWriter.Write("\">"); this.RenderPublishAndTryAgainDialog(ex); break; case InvalidSharingRecipientsResolutionType.SendPublishLinks: this.SanitizingWriter.Write(4); this.SanitizingWriter.Write("\">"); this.RenderSendPublishLinksDialog(ex); break; default: throw; } } else { this.SanitizingWriter.Write(2); this.SanitizingWriter.Write("\">"); this.RenderInvalidRecipientsDialog(ex); } this.SanitizingWriter.Write("</div>"); } catch (Exception e2) { this.SendIdAndChangeKeyToClientOnError(sharingMessageItem, e2); throw; } if (Globals.ArePerfCountersEnabled) { OwaSingleCounters.MessagesSent.Increment(); } } RenderingUtilities.RenderNavigationTreeDirtyFlag(this.Writer, base.UserContext, NavigationTreeDirtyFlag.Calendar, new NavigationModule[] { NavigationModule.Calendar }); } finally { if (requestItem != null) { ((IDisposable)requestItem).Dispose(); } } }
/// <summary> /// Factory for <see cref="EvaluationContext" /> /// </summary> public static EvaluationContext Create(SharingPolicy policy) { // ReSharper disable once IntroduceOptionalParameters.Global // do not remove this method to avoid breaking binary compatibility return(Create(policy, fileSystem: null)); }
internal EvaluationContext(SharingPolicy policy) { Policy = policy; }