/// <summary> /// Given an poBox object , it will return the rule for a PolicyID /// only one rule is returned /// </summary> public void GetRuleForPolicyID(POBox.POBox poBox, string PolicyID, ref Member member) { string RuleList = "RuleList"; Simias.Policy.Rule rule = null; ICSList list = poBox.Search(PropertyTags.PolicyID, PolicyID, SearchOp.Equal); foreach (ShallowNode sn in list) { Simias.Policy.Policy tempPolicy = new Simias.Policy.Policy(poBox, sn); if (tempPolicy.IsSystemPolicy) { MultiValuedList mvl = tempPolicy.Properties.GetProperties(RuleList); if (mvl.Count > 0) { foreach (Property p in mvl) { if (p != null) { rule = new Simias.Policy.Rule(p.Value); Property prop = new Property(PolicyID, rule.ToString()); prop.ServerOnlyProperty = true; member.Properties.ModifyProperty(prop); break; } } } } } return; }
/// <summary> /// Start the PO Box manager. /// </summary> public void Start() { try { lock (this) { log.Debug("Starting PO Service: {0}", ServiceUrl); // Get a list of all POBoxes. ICSList poBoxList = store.GetCollectionsByType(NodeTypes.POBoxType); foreach (ShallowNode sn in poBoxList) { // Get the domain for this POBox. POBox poBox = new POBox(store, sn); Simias.Storage.Domain domain = store.GetDomain(poBox.Domain); //if (domain.Role == SyncRoles.Slave) //{ // start collection managers AddPOBoxManager(poBox.ID); //} } } } catch (Exception e) { log.Error(e, "Unable to start PO manager."); throw e; } }
/// <summary> /// Removes all subscriptions for the collection that is contained in the event. /// </summary> /// <param name="args">Node event arguments.</param> private void OnCollectionNoAccess(NodeEventArgs args) { // Make sure that this is an event for a collection. if (args.Collection == args.ID) { // Search the POBox collections for a subscription for this collection. Property p = new Property(Subscription.SubscriptionCollectionIDProperty, args.ID); // Find all of the subscriptions for this POBox. ICSList list = store.GetNodesByProperty(p, SearchOp.Equal); foreach (ShallowNode sn in list) { // Make sure that this node is a subscription. if (sn.Type == NodeTypes.SubscriptionType) { // Get the collection (POBox) for this subscription. POBox poBox = POBox.GetPOBoxByID(store, sn.CollectionID); if (poBox != null) { // Delete this subscription from the POBox. poBox.Commit(poBox.Delete(new Subscription(poBox, sn))); } } } } }
/// <summary> /// This API will clean all certificate (.?er files) /// before Server, store existing and new certificate and load them in Hash table. /// </summary> public static void CleanCertsFromStore() { Store store = Store.GetStore(); ICSList domainList = store.GetDomainList(); Boolean isLocalDomain = false; foreach (ShallowNode snd in domainList) { Domain domain = store.GetDomain(snd.ID); ICSList certs = domain.GetNodesByType(CertType); isLocalDomain = domain.Name.Equals(Store.LocalDomainName); foreach (ShallowNode sn in certs) { Node node = new Node(domain, sn); try { string nodeProperty = node.Properties.GetSingleProperty(isLocalDomain?hostProperty:raProperty).Value.ToString(); if (nodeProperty != null) { log.Debug("Node deleted is:{0}", node.Name); domain.Commit(domain.Delete(node)); } } catch { log.Error("Exception while clearing existing Certificates from Domain"); } } //End of Inner foreach loop } // End of Outer foreach loop } //End of Function
/// <summary> /// Start the PO service. /// </summary> public void Start() { #if (!REMOVE_OLD_INVITATION) lock (typeof(POService)) { if (subscriptionService == null) { // Start the subscription thread. subscriptionService = new SubscriptionService(); } } #endif // Get a list of all POBoxes. ICSList poBoxList = store.GetCollectionsByType(NodeTypes.POBoxType); foreach (ShallowNode sn in poBoxList) { // Add the existing POBoxes to the mapping table. POBox poBox = new POBox(store, sn); poBoxTable[poBox.ID] = poBox.Domain; #if (!REMOVE_OLD_INVITATION) // Process any active subscriptions. ProcessWaitingSubscriptions(poBox); #endif } poBoxSubscriber.Enabled = true; invitationSubscriber.Enabled = true; #if (!REMOVE_OLD_INVITATION) noAccessSubscriber.Enabled = true; #endif }
/// <summary> /// Remove the certificate for the specified host. /// </summary> /// <param name="host">The host the certificate belongs to.</param> public static void RemoveCertificate(string host) { string uriHost = GetHostFromUri(host); log.Debug("removing for host : {0}", uriHost); CertPolicy.RemoveCertificate(uriHost); log.Debug("removed for host : {0}", uriHost); // also remove it from store , if any Store store = Store.GetStore(); Domain domain = store.GetDomain(store.LocalDomain); // Check for an existing cert in the store. Node cn = null; ICSList nodeList = domain.Search(hostProperty, uriHost, SearchOp.Equal); foreach (ShallowNode sn in nodeList) { cn = new Node(domain, sn); if (cn.IsType(CertType)) { Property myprop = cn.Properties.GetSingleProperty(certificateProperty); if (myprop != null) { domain.Commit(domain.Delete(cn)); log.Debug("committed the deletion of certtype node for :{0} ", uriHost); } } } }
// We call catalog services to read the entries.. Not using discovery because no need...Only read operation is performed /// <summary> /// Collective space used by group member. /// </summary> /// <param name="groupID">Group id whose members space need to be calculated.</param> /// <returns></returns> static public long GetSpaceUsedByAllGroupMembers(string groupID) { long SpaceUsed = 0; string catalogID = "a93266fd-55de-4590-b1c7-428f2fed815d"; string OwnerProperty = "oid"; string SizeProperty = "size"; Collection catalog; //ArrayList entries = new ArrayList(); Store store = Store.GetStore(); Domain domain = store.GetDomain(store.DefaultDomain); string [] GroupMembers = domain.GetGroupsMemberList(groupID); catalog = store.GetCollectionByID(catalogID); foreach (string memberID in GroupMembers) { Property midsProp = new Property(OwnerProperty, memberID); ICSList nodes = catalog.Search(midsProp, SearchOp.Equal); foreach (ShallowNode sn in nodes) { Node node = new Node(catalog, sn); Property p = node.Properties.GetSingleProperty(SizeProperty); SpaceUsed += (p != null) ? ( long )p.Value : 0;; } } return(SpaceUsed); }
/// <summary> /// constructor /// </summary> /// <param name="hNode">HostNode object</param> internal HostEntry(HostNode hNode) { host = hNode; ICSList members = hNode.GetHostedMembers(); userCount = members.Count; }
/// <summary> /// Given an poBox object , it will return the value for a PolicyID , and PolicyTag . /// Only one value is returned /// </summary> public int GetValueForPolicyID(POBox.POBox poBox, string PolicyID, string PolicyTag) { int PolicyValue = -1; ICSList list = poBox.Search(PropertyTags.PolicyID, PolicyID, SearchOp.Equal); foreach (ShallowNode sn in list) { Simias.Policy.Policy tempPolicy = new Simias.Policy.Policy(poBox, sn); if (tempPolicy.IsSystemPolicy) { MultiValuedList mvl = tempPolicy.Properties.GetProperties(PolicyTag); if (mvl.Count > 0) { foreach (Property p in mvl) { if (p != null) { PolicyValue = (int)p.Value; break; } } } } } return(PolicyValue); }
/// <summary> /// Utility method to delete a member's POBox from the system /// </summary> public static bool DeletePOBox(string DomainID, string UserID) { bool deleted = false; try { Store store = Store.GetStore(); ICSList cList = store.GetCollectionsByOwner(UserID); foreach (ShallowNode sn in cList) { Collection c = new Collection(store, sn); if ((c.Domain == DomainID) && ((Node)c).IsBaseType(NodeTypes.POBoxType)) { c.Commit(c.Delete()); deleted = true; break; } } } catch (Exception e2) { log.Error(e2.Message); log.Error(e2.StackTrace); } return(deleted); }
public BrowserShallowNode[] SearchForShallowNodes(string collectionID, string propertyName, string propertyType, string propertyValue, string operation) { ArrayList list = new ArrayList(); Store store = Store.GetStore(); // Build the property to search for. Property p = new Property(propertyName, ( Syntax )Enum.Parse(typeof(Syntax), propertyType), propertyValue); if (collectionID == null || collectionID.Equals(string.Empty)) { // The collection ID was not specified ... perform a store-wide search. ICSList nodeList = store.GetNodesByProperty(p, ( SearchOp )Enum.Parse(typeof(SearchOp), operation)); foreach (ShallowNode sn in nodeList) { list.Add(new BrowserShallowNode(sn)); } } else { // Get the collection. Collection c = store.GetCollectionByID(collectionID); if (c != null) { // Search the collection. ICSList nodeList = c.Search(p, ( SearchOp )Enum.Parse(typeof(SearchOp), operation)); foreach (ShallowNode sn in nodeList) { list.Add(new BrowserShallowNode(sn)); } } } return(list.ToArray(typeof(BrowserShallowNode)) as BrowserShallowNode[]); }
/// <summary> /// Gets the distinguished name from the member name. /// </summary> /// <param name="user">The user name.</param> /// <param name="distinguishedName">Receives the ldap distinguished name.</param> /// <param name="id">Receives the member's user ID.</param> /// <returns>True if the distinguished name was found.</returns> private bool GetUserDN(string user, out string distinguishedName, out string id) { bool status = false; Member member = null; // Initialize the outputs. distinguishedName = String.Empty; id = String.Empty; if (domain != null) { member = domain.GetMemberByName(user); if (member != null) { Property dn = member.Properties.GetSingleProperty("DN"); if (dn != null) { distinguishedName = dn.ToString(); id = member.UserID; status = true; } } else { // The specified user did not exist in the roster under // the short or common name. // Let's see if the user came in fully distinguished. // ex. cn=user.o=context string dn = user.ToLower(); if (dn.StartsWith("cn=") == true) { // NDAP name to LDAP name dn = dn.Replace('.', ','); ICSList dnList = domain.Search("DN", dn, SearchOp.Equal); if (dnList != null && dnList.Count == 1) { IEnumerator dnEnum = dnList.GetEnumerator(); if (dnEnum.MoveNext() == true) { member = new Member(domain, dnEnum.Current as ShallowNode); if (member != null) { distinguishedName = dn; id = member.UserID; status = true; } } } } } } return(status); }
/// <summary> /// Locates a Subscription in the POBox by CollectionID /// </summary> /// <param name="collectionID">The ID of the collection.</param> /// <returns>A Subscription object.</returns> public Subscription GetSubscriptionByCollectionID(string collectionID) { ICSList subList = this.Search( Subscription.SubscriptionCollectionIDProperty, collectionID, SearchOp.Equal); foreach (ShallowNode sNode in subList) { return(new Subscription(this, sNode)); } return(null); }
public static void GetCollisionNodes( ) { Store.Initialize(SimiasDataPath, true, -1); Store store = Store.GetStore(); if (store == null) { Console.WriteLine("store could not be initialized....."); } Domain domain = store.GetDomain(store.DefaultDomain); SearchOp searchOperation = SearchOp.Begins; string pattern = "*"; int max = 0; int index = 0; Console.WriteLine(); Console.WriteLine("**************************Collision Nodes Report********************* "); Console.WriteLine(); Simias.Storage.SearchPropertyList SearchPrpList = new Simias.Storage.SearchPropertyList(); int i = 0; SearchPrpList.Add(CollisionProperty, "*", SearchOp.Exists); SearchPrpList.Add(BaseSchema.ObjectName, pattern, searchOperation); try{ ICSList searchList = Catalog.Search(SearchPrpList); SearchState searchState = new SearchState(domain.ID, searchList.GetEnumerator() as ICSEnumerator, searchList.Count); if (index != 0) { searchState.Enumerator.SetCursor(Simias.Storage.Provider.IndexOrigin.SET, index); } foreach (ShallowNode sn in searchList) { if (max != 0 && i++ >= max) { break; } CatalogEntry catEntry = Catalog.ConvertToCataloEntry(sn); Console.WriteLine("iFolder Name :{0}, iFolder ID:{1}", catEntry.Name, catEntry.CollectionID); } } catch (Exception ee) { Console.WriteLine("Got exception: " + ee.Message); } finally{ Store.DeleteInstance(); } }
/// <summary> /// Returns the total amount of disk space used by this member. /// </summary> /// <param name="member">Member to find used disk space for.</param> /// <returns>Amount of used disk space in bytes.</returns> private long GetUsedDiskSpace(Member member) { long collectionSpace = 0; // Get all of the collections that are owned by the member. Store store = Store.GetStore(); ICSList collectionList = store.GetCollectionsByOwner(member.UserID, member.GetDomainID(store)); foreach (ShallowNode sn in collectionList) { Collection c = new Collection(store, sn); collectionSpace += c.StorageSize; } return(collectionSpace); }
/// <summary> /// Store the certificate for the specified host. /// </summary> /// <param name="certificate">The certificate to store.</param> /// <param name="host">The host the certificate belongs to.</param> /// <param name="domainID">the domainID to which host belongs</param> /// <param name="persist">If true save in store.</param> public static void StoreDomainCertificate(byte[] certificate, string host, string domainID, bool persist) { // this function is neither tested nor used string uriHost = GetHostFromUri(host); log.Debug("storing certificate for host : {0}", uriHost); CertPolicy.StoreCertificate(certificate, uriHost); //try //{ if (persist) { // Save the cert in the store. Store store = Store.GetStore(); Domain domain = store.GetDomain(domainID); // Check for an existing cert in the store. Node cn = null; ICSList nodeList = domain.Search(hostProperty, uriHost, SearchOp.Equal); foreach (ShallowNode sn in nodeList) { cn = new Node(domain, sn); if (!cn.IsType(CertType)) { cn = null; continue; } break; } if (cn == null) { // The cert doesn't exist ... create it. //cn=new Node(" cn = new Node("Certificate for " + uriHost); domain.SetType(cn, CertType); cn.Properties.ModifyNodeProperty(new Property(hostProperty, uriHost)); } Property myprop = new Property(certificateProperty, Convert.ToBase64String(certificate)); myprop.LocalProperty = true; cn.Properties.ModifyNodeProperty(myprop); //cn.Properties.ModifyNodeProperty(new Property(certificateProperty, Convert.ToBase64String(certificate))); log.Debug("committed the storage of certificate"); domain.Commit(cn); } //}catch(Exception ex){} }
/// <summary> /// Locates a Subscription in the POBox by CollectionID and UserID. /// </summary> /// <param name="collectionID">The ID of the collection.</param> /// <param name="userID">The ID of the user to whom the subscription is addressed.</param> /// <returns>A Subscription object.</returns> public Subscription GetSubscriptionByCollectionID(string collectionID, string userID) { ICSList subList = this.Search( Subscription.SubscriptionCollectionIDProperty, collectionID, SearchOp.Equal); foreach (ShallowNode sn in subList) { Subscription sub = new Subscription(this, sn); if (sub.ToIdentity.Equals(userID)) { return(sub); } } return(null); }
/// <summary> /// Creates a file size filter policy for the specified member. /// </summary> /// <param name="member">Member that the filter will be associated with.</param> /// <param name="limit">Size of file in bytes that all users in the domain will be limited to.</param> static public void Create(Member member, long limit) { ICSList ftList = new ICSList(); // Need a policy manager. PolicyManager pm = new PolicyManager(); if (limit > 0) { ftList.Add(new Rule(limit, Rule.Operation.Greater, Rule.Result.Deny)); pm.CommitPolicy(FileSizeFilterPolicyID, ftList, member); } else { pm.DeletePolicy(FileSizeFilterPolicyID, member); } }
public static void GetReports( ) { //if( replace == false ) Console.WriteLine("You have opted to view and not delete..Use enable to modify also "); else Console.WriteLine("It will modify the members"); Store.Initialize(SimiasDataPath, true, -1); Store store = Store.GetStore(); if (store == null) { Console.WriteLine("store could not be initialized....."); } Domain domain = store.GetDomain(store.DefaultDomain); Console.WriteLine("**************************IFOLDER REPORT********************* "); Console.WriteLine(); Console.WriteLine(); try { ICSList ifolders = store.GetCollectionsByType("iFolder"); foreach (ShallowNode sn in ifolders) { object[] cells = new object[count]; Collection ifolder = store.GetCollectionByID(sn.ID); Member owner = domain.GetMemberByID(ifolder.Owner.UserID); Console.WriteLine(" *************"); Console.WriteLine("user name is :{0} and iFolder name is :{1}", owner.FN, ifolder.Name); Console.WriteLine("iFolder quota is :{0}", DiskSpaceQuota.GetLimit(ifolder)); Console.WriteLine("Users quota is :{0}", DiskSpaceQuota.Get(owner).Limit); Console.WriteLine(" "); } } catch (Exception ex) { Console.WriteLine(); Console.WriteLine(); Console.WriteLine(ex); Console.WriteLine(ex.StackTrace); } finally { Store.DeleteInstance(); } }
/// <summary> /// /// </summary> /// <param name="rsa"></param> /// <param name="recoveryAgnt"></param> /// <param name="persist"></param> public static void CheckAndStoreRSA(string rsa, string recoveryAgnt, bool persist) { bool toStore = true; int count = 0; Store store = Store.GetStore(); string domainID = store.DefaultDomain; if (domainID != null) { Domain domain = store.GetDomain(store.DefaultDomain); ICSList rsas = domain.GetNodesByType(RSAType); foreach (ShallowNode sn in rsas) { Node node = new Node(domain, sn); try { if (count++ > 0) { throw new Exception("Too many Default RSA"); } string nodeProperty = node.Properties.GetSingleProperty(raProperty).Value.ToString(); if (nodeProperty != null) { toStore = false; } else { toStore = true; } } catch (Exception e) { log.Fatal("RSA Check Error: {0}", e.Message); return; } } if (toStore) { StoreRARSA(rsa, recoveryAgnt, persist); } } }
public static ArrayList getAllDomainUsers(Domain domain, string username) { SearchProperty searchProperty = SearchProperty.UserName; SearchOperation searchOperation = SearchOperation.BeginsWith; string pattern = "*"; Simias.Storage.SearchPropertyList SearchPrpList = new Simias.Storage.SearchPropertyList(); //SearchPrpList.Add(searchProperty, pattern, searchOperation); SearchPrpList.Add("DN", "*", SearchOp.Exists); ICSList searchList = domain.Search(SearchPrpList); ArrayList list = new ArrayList(); Member member = null; Console.WriteLine("Total No Of Users in Domain: " + searchList.Count); foreach (ShallowNode sn in searchList) { try { if (sn.IsBaseType(NodeTypes.MemberType)) { member = new Member(domain, sn); Member mem = domain.GetMemberByID(member.UserID); //add only those members to list whose home server is current server if (mem.HomeServer != null) { if (String.Equals(mem.Name, username) && mem.HomeServer.UserID == HostNode.GetLocalHost().UserID) { list.Add(mem); break; } } } } catch (Exception ex) { Console.WriteLine("Error: " + ex.Message); Console.WriteLine("Error Trace: " + ex.StackTrace); } } Console.WriteLine("Total No Of Users for whom Home Server is current server: " + list.Count); return(list); }
/// <summary> /// Get an iFolder Entry By Relative Path /// </summary> /// <param name="c"></param> /// <param name="entryPath"></param> /// <returns></returns> internal static Node GetEntryByPath(Collection c, string entryPath) { Node n = null; entryPath = entryPath.Trim(new char[] { '/' }); ICSList children = c.Search(PropertyTags.FileSystemPath, entryPath, SearchOp.Equal); foreach (ShallowNode sn in children) { Node child = c.GetNodeByID(sn.ID); if (child.IsBaseType(NodeTypes.FileNodeType) || child.IsBaseType(NodeTypes.DirNodeType)) { n = child; break; } } return(n); }
/// <summary> /// Removes the subscription for this collection from the specified member. /// </summary> /// <param name="member">Member to remove subscription from.</param> public static void RemoveSubscriptionByMember(string domainID, string collectionID, string userID) { Store store = Store.GetStore(); #if (!REMOVE_OLD_INVITATION) Domain domain = store.GetDomain(domainID); if ((domain != null) && (domain.SupportsNewInvitation == true)) { #endif // Get the member's POBox. POBox poBox = POBox.FindPOBox(store, domainID, userID); if (poBox != null) { ICSList subList = poBox.Search(Subscription.SubscriptionCollectionIDProperty, collectionID, SearchOp.Equal); if (subList.Count > 0) { foreach (ShallowNode sn in subList) { // No need to process further invitation events. The collection cannot be deleted // by removing its members, because the owner of the collection can never be deleted. Subscription subscription = new Subscription(poBox, sn); subscription.CascadeEvents = false; poBox.Commit(poBox.Delete(subscription)); log.Debug("RemoveSubscriptionByMember - Removed subscription {0} from member {1}.", sn.ID, userID); } } else { log.Debug("RemoveSubscriptionByMember - No subscriptions found for member {0}.", userID); } } else { log.Debug("RemoveSubscriptionByMember - Cannot find POBox for member {0}.", userID); } #if (!REMOVE_OLD_INVITATION) } #endif }
/// <summary> /// Removes all subscriptions associated with this collection. /// </summary> /// <param name="domainID"></param> /// <param name="collectionID"></param> /// <param name="userID"></param> public static void RemoveSubscriptionsForCollection(string domainID, string collectionID) { Store store = Store.GetStore(); #if (!REMOVE_OLD_INVITATION) Domain domain = store.GetDomain(domainID); if ((domain != null) && (domain.SupportsNewInvitation == true)) { #endif ICSList subList = store.GetNodesByProperty(new Property(Subscription.SubscriptionCollectionIDProperty, collectionID), SearchOp.Equal); if (subList.Count > 0) { foreach (ShallowNode sn in subList) { // The collection for the subscription nodes will be the POBox. Collection collection = store.GetCollectionByID(sn.CollectionID); if (collection != null) { // No need to process further invitation events. The collection associated with // this subscription has already been removed. Subscription subscription = new Subscription(collection, sn); subscription.CascadeEvents = false; collection.Commit(collection.Delete(subscription)); log.Debug("RemoveSubscriptionsForCollection - Removed subscription {0} for collection {1}.", sn.ID, sn.CollectionID); } else { log.Debug("RemoveSubscriptionsForCollection - Cannot find POBox {0}.", sn.CollectionID); } } } else { log.Debug("RemoveSubscriptionsForCollection - No subscriptions found for collection {0}.", collectionID); } #if (!REMOVE_OLD_INVITATION) } #endif }
/// <summary> /// Creates a file type filter policy for the specified member. /// </summary> /// <param name="member">Member that the filter will be associated with.</param> /// <param name="patterns">File type patterns that will be used to filter files.</param> static public void Create(Member member, FileTypeEntry[] patterns) { ICSList ftList = new ICSList(); // Need a policy manager. PolicyManager pm = new PolicyManager(); if (patterns.Length > 0) { // Add the new rules and save the policy. foreach (FileTypeEntry fte in patterns) { ftList.Add(new Rule(fte.Name, fte.IgnoreCase ? Rule.Operation.RegExp_IgnoreCase : Rule.Operation.RegExp, fte.Allowed ? Rule.Result.Allow : Rule.Result.Deny)); } pm.CommitPolicy(FileTypeFilterPolicyID, ftList, member); } else { pm.DeletePolicy(FileTypeFilterPolicyID, member); } }
/// <summary> /// Remove the certificate for the specified host. /// </summary> /// /// <param name="domainID">the domainid for this host</param> /// <param name="host">The host the certificate belongs to.</param> public static void RemoveDomainCertificate(string domainID, string host) { // this API is yet to be tested , and has not been used. string uriHost = GetHostFromUri(host); log.Debug("removing for host : {0}", uriHost); CertPolicy.RemoveCertificate(uriHost); log.Debug("removed for host : {0}", uriHost); // also remove it from store , if any Store store = Store.GetStore(); Domain domain = store.GetDomain(domainID); // check for the cert Node cn = null; ICSList nodelist = domain.Search(hostProperty, "*", SearchOp.Equal); //domain.GetNodesByType(CertType); if (nodelist == null) { log.Debug("returned null for hostproperty * "); } foreach (ShallowNode sn in nodelist) { cn = new Node(domain, sn); if (!cn.IsType(CertType)) { log.Debug("returned non null but this node is not of type CertType"); continue; } if (cn != null) { // cert type is found domain.Commit(domain.Delete(cn)); log.Debug("committed the deletion of certtype node for :{0} ", uriHost); } } }
/// <summary> /// Change the default disk quota for the managed groups (falling under secondary admin) based on sync control method /// It will only change the default disk quota set on each group, If quota was changed by admin, thent his method will not change that. /// </summary> /// <param name="GroupQuotaRestrictionMethod">the enum which will decide what will be the default disk quota for each group</param> public static void ChangeDefaultGroupQuota(int GroupQuotaRestrictionMethod) { Store store = Store.GetStore(); Domain domain = store.GetDomain(store.DefaultDomain); ICSList SecAdmins = domain.GetMembersByRights(Access.Rights.Secondary); try { foreach (ShallowNode sn in SecAdmins) { Member AdminAsMember = new Member(domain, sn); if (!AdminAsMember.IsType("Host")) { string [] ManagedGroups = AdminAsMember.GetMonitoredGroups(); foreach (string GroupID in ManagedGroups) { Member GroupAsMember = domain.GetMemberByID(GroupID); long GroupDiskQuota = Simias.Policy.DiskSpaceQuota.Get(GroupAsMember).Limit; if (GroupQuotaRestrictionMethod == (int)QuotaRestriction.UI_Based && GroupDiskQuota == -1) { // change the default disk quota for groups, (from Unlimited to 0MB) Simias.Policy.DiskSpaceQuota.Set(GroupAsMember, 0); } else if (GroupQuotaRestrictionMethod == (int)QuotaRestriction.Sync_Based && GroupDiskQuota == 0) { // change the default disk quota for groups, (from 0MB to Unlimited) Simias.Policy.DiskSpaceQuota.Delete(GroupAsMember); } } } } domain.Commit(); } catch (Exception ex) { log.Debug("Exception during changing the default disk quota. " + ex.ToString()); } }
/// <summary> /// Starts a search for a specific set of domain members. /// </summary> /// <param name="domainID">The identifier of the domain to search for members in.</param> /// <param name="attributeName">Name of attribute to search.</param> /// <param name="searchString">String that contains a pattern to search for.</param> /// <param name="operation">Type of search operation to perform.</param> /// <param name="count">Maximum number of member objects to return.</param> /// <param name="searchContext">Receives a provider specific search context object. This object must be serializable.</param> /// <param name="memberList">Receives an array object that contains the domain Member objects.</param> /// <param name="total">Receives the total number of objects found in the search.</param> /// <returns>True if there are more domain members. Otherwise false is returned.</returns> public bool FindFirstDomainMembers(string domainID, string attributeName, string searchString, SearchOp operation, int count, out string searchContext, out Member[] memberList, out int total) { bool moreEntries = false; // Initialize the outputs. searchContext = null; memberList = null; total = 0; // Start the search for the specific members of the domain. Domain domain = store.GetDomain(domainID); if (domain != null) { ICSList list = domain.Search(attributeName, searchString, operation); SearchState searchState = new SearchState(domainID, list.GetEnumerator() as ICSEnumerator, list.Count); searchContext = searchState.ContextHandle; total = list.Count; moreEntries = FindNextDomainMembers(ref searchContext, count, out memberList); } return(moreEntries); }
// open store and enable the login for all users. It will also delete 'DisabledAt' property for all users, if it was set earlier. //DisabledAt property means during e-dir sync, somehow server interpreted that user was deleted in e-dir, so disabled in iFolder and currently // it is under grace itnerval period. After grace interval, server will completely delete that user and orphan his iFolders. public static void EnableUserLogins(bool replace) { if (replace == false) { Console.WriteLine("You have opted to view and not delete..Use enable to modify also "); } else { Console.WriteLine("It will modify the members"); } Store.Initialize(SimiasDataPath, true, -1); Store store = Store.GetStore(); if (store == null) { Console.WriteLine("store could not be initialized....."); } Domain domain = store.GetDomain(store.DefaultDomain); try{ ICSList FullMemList = domain.GetMemberList(); foreach (ShallowNode sn in FullMemList) { Member memObject = new Member(domain, sn); Simias.Storage.Property disabledAt = memObject.Properties.GetSingleProperty(disabledAtProperty); if (disabledAt != null) { if (replace) { memObject.DeleteProperty = disabledAtProperty; } if (domain.GetLoginpolicy(memObject.UserID) == true) //it returns true if user is disabled { // if login was disabled, then enable login if (replace == true) { domain.SetLoginDisabled(memObject.UserID, false); //false means it will delete the logindisabled property } Console.WriteLine("Enabled the login for user :"******"Login already enabled for user :"******"Removed the disabledAt property for user :"******"Got exception: " + ee.Message); } finally{ Store.DeleteInstance(); } }
/// <summary> /// write the response back /// </summary> public void Send() { ctx.Response.Write("<channel>"); ctx.Response.Write("<title>"); ctx.Response.Write(collection.Name); ctx.Response.Write("</title>"); /* * if (slog.Link != "") * { * ctx.Response.Write("<link>"); * ctx.Response.Write( slog.Link ); * ctx.Response.Write("</link>"); * } */ ctx.Response.Write("<language>"); ctx.Response.Write("en-us"); ctx.Response.Write("</language>"); ctx.Response.Write("<copyright>"); ctx.Response.Write("(c) Novell, Inc."); ctx.Response.Write("</copyright>"); ctx.Response.Write("<managingEditor>"); Domain domain = store.GetDomain(store.DefaultDomain); if (collection.Owner.FN != null && collection.Owner.FN != "") { ctx.Response.Write(collection.Owner.FN); } else { ctx.Response.Write(collection.Owner.Name); } ctx.Response.Write("</managingEditor>"); ctx.Response.Write("<webmaster>"); //member = domain.GetMemberByID( domain.Owner ); if (domain.Owner.FN != null && domain.Owner.FN != "") { ctx.Response.Write(domain.Owner.FN); } else { ctx.Response.Write(domain.Owner.Name); } ctx.Response.Write("</webmaster>"); try { Simias.Storage.Property descProp = collection.Properties.GetSingleProperty("Description"); if (descProp != null) { ctx.Response.Write("<description>" + descProp.Value.ToString() + "</description>"); } else { ctx.Response.Write("<description>" + collection.Type.ToString() + "</description>"); } } catch {} ctx.Response.Write( String.Format( "<link>{0}{1}:{2}{3}{4}?feed={5}</link>", ctx.Request.IsSecureConnection ? "https://" : "http://", ctx.Request.Url.Host, ctx.Request.Url.Port.ToString(), ctx.Request.ApplicationPath, (publicAccess == true) ? "/pubrss.ashx" : "/rss.ashx", HttpUtility.UrlEncode(collection.Name))); Simias.Storage.Property colProp = collection.Properties.GetSingleProperty(Simias.RssFeed.Util.LastModified); DateTime latest = (colProp != null) ? (DateTime)colProp.Value : collection.CreationTime; /* * ICSList nodes = collection.Search( Simias.RssFeed.Util.LastModified, dt, SearchOp.Greater ); * ICSEnumerator nodesEnum = null; * if ( nodes.Count > 0 ) * { * nodesEnum = nodes.GetEnumerator() as ICSEnumerator; * if ( nodesEnum != null && * nodesEnum.SetCursor( IndexOrigin.SET, nodesEnum.Count - 1 ) == true ) * { * nodesEnum.MoveNext(); * * try * { * ShallowNode sn = nodesEnum.Current as ShallowNode; * log.Debug( "sn: " + sn.Name ); * * Item item = new Item( collection, sn ); * if ( item.Published > latest ) * { * latest = item.Published; * } * } * catch( Exception e ) * { * log.Debug( e.Message ); * } * } * } */ Simias.RssFeed.Util.SendPublishDate(ctx, latest); ctx.Response.Write("<lastBuildDate>"); ctx.Response.Write(Util.GetRfc822Date(latest)); ctx.Response.Write("</lastBuildDate>"); ctx.Response.Write("<generator>"); ctx.Response.Write("Simias"); ctx.Response.Write("</generator>"); /* * ctx.Response.Write("<cloud>"); * ctx.Response.Write( node.Cloud ); * ctx.Response.Write("</cloud>"); */ ctx.Response.Write("<ttl>"); ctx.Response.Write(Simias.RssFeed.Util.DefaultTtl.ToString()); ctx.Response.Write("</ttl>"); ctx.Response.Write("<rating>"); ctx.Response.Write(Simias.RssFeed.Util.DefaultRating); ctx.Response.Write("</rating>"); if (strict == false) { ctx.Response.Write("<authorID>" + collection.Owner.UserID + "</authorID>"); ctx.Response.Write("<type>" + collection.Type.ToString() + "</type>"); ctx.Response.Write("<id>" + collection.ID + "</id>"); } if (items == true) { ICSList nodes = collection.Search( Simias.RssFeed.Util.LastModified, new DateTime(1992, 1, 1, 0, 0, 0), SearchOp.Greater); if (nodes != null && nodes.Count > 0) { ICSEnumerator nodesEnum = nodes.GetEnumerator() as ICSEnumerator; int count = nodesEnum.Count; while (count-- > 0) { if (nodesEnum.SetCursor(IndexOrigin.SET, count) == true) { nodesEnum.MoveNext(); ShallowNode sn = nodesEnum.Current as ShallowNode; Item item = null; if (this.types.Count == 0) { if (sn.Type == "FileNode") { item = new Item(collection, sn, publicAccess); } } else { foreach (string ctype in this.types) { if (ctype == sn.Type) { item = new Item(collection, sn, publicAccess); break; } } } if (item != null) { item.Strict = this.strict; item.Enclosures = this.enclosures; item.Send(ctx); } } } } } ctx.Response.Write("</channel>"); }