/// <summary>
/// Modify data store for an iFolder Server.
/// </summary>
/// <param name="name">The name of the data store.</param>
/// <returns>Bool true on success.</returns>
public bool ModifyStore(string datapath, bool enabled)
{
log.Debug(" Modify store called - : {0}", datapath);
HostNode host = HostNode.GetLocalHost();
MultiValuedList mv = host.Properties.GetProperties(PropertyTags.DataPath);
foreach (Property prop in mv)
{
string[] comps = ((string)prop.Value).Split('|');
if ((datapath.Equals(comps[0])))
{
Store store = Store.GetStore();
Domain domain = store.GetDomain(store.DefaultDomain);
prop.Delete();
domain.Commit(host);
string storageFormat = String.Format("{0}|{1}", comps[0], comps[1]);
storageFormat = String.Format("{0}|{1}", storageFormat, enabled.ToString());
Property p = new Property(PropertyTags.DataPath, storageFormat);
p.LocalProperty = true;
host.Properties.AddProperty(p);
domain.Commit(host);
}
}
return(true);
}
/// <summary>
/// Delete data store for an iFolder Server.
/// </summary>
/// <param name="name">The name of the data store.</param>
/// <returns>Bool true on success.</returns>
public bool DeleteStore(string datapathname)
{
log.Debug(" Delete Store called with : {0}", datapathname);
HostNode host = HostNode.GetLocalHost();
MultiValuedList mv = host.Properties.GetProperties(PropertyTags.DataPath);
foreach (Property prop in mv)
{
string[] comps = ((string)prop.Value).Split('|');
if ((datapathname.Equals(comps[0])))
{
Store store = Store.GetStore();
Domain domain = store.GetDomain(store.DefaultDomain);
if (!Directory.Exists(Path.Combine(comps[1], "SimiasFiles")))
{
prop.Delete();
domain.Commit(host);
//delete the source link of the symbolic link created
string storepath = Store.StorePath;
string tmppath = Path.Combine(storepath, "SimiasFiles");
tmppath = Path.Combine(tmppath, datapathname);
Mono.Unix.Native.Syscall.unlink(tmppath);
}
}
}
return(true);
}
/// <summary>
/// Add a data store for an iFolder Server.
/// </summary>
/// <returns>Bool true on success.</returns>
public int AddStore(string ServerID)
{
Store store = Store.GetStore();
Domain domain = store.GetDomain(store.DefaultDomain);
string storepath = Store.StorePath;
string tmppath = Path.Combine(storepath, "SimiasFiles");
tmppath = Path.Combine(tmppath, this.DataPath);
int result = 0;
if (Directory.Exists(tmppath) == true)
{
return(1);
}
else if (Directory.Exists(this.FullPath) != true)
{
return(2);
}
Mono.Unix.Native.Syscall.symlink(this.FullPath, tmppath);
string storageFormat = String.Format("{0}|{1}", this.DataPath, this.FullPath);
storageFormat = String.Format("{0}|{1}", storageFormat, this.Enabled.ToString());
HostNode host = HostNode.GetLocalHost();
Property p = new Property(PropertyTags.DataPath, storageFormat);
p.LocalProperty = true;
host.Properties.AddProperty(p);
domain.Commit(host);
return(result);
}
/// <summary>
/// commit the encrypted password as part of member object
/// </summary>
/// <returns>true if setting is successful</returns>
private bool SetAdminPassword()
{
bool status = false;
// Bootstrap the domain from the Simias.config file
Simias.Configuration config = Store.Config;
string adminName = config.Get("EnterpriseDomain", "AdminName");
string adminPassword = config.Get("EnterpriseDomain", "AdminPassword");
if (adminName != null && adminName != "" && adminPassword != null)
{
try
{
Member member = domain.GetMemberByName(adminName);
if (member != null)
{
Property pwd =
member.Properties.GetSingleProperty(InternalUser.pwdProperty);
if (pwd == null || pwd.Value == null)
{
pwd = new Property(InternalUser.pwdProperty, HashPassword(adminPassword));
member.Properties.ModifyProperty(pwd);
// Marker so we know this member was created internally
// and not through an external identity sync.
domain.SetType(member as Node, InternalUser.memberMarker);
domain.Commit(member);
status = true;
}
}
}
catch (Exception ap)
{
log.Error(ap.Message);
log.Error(ap.StackTrace);
}
}
return(status);
}
/// <summary>
/// Method to get the Simias Enterprise server domain
/// If the the domain does not exist and the create flag is true
/// the domain will be created. If create == false, ownerName is ignored
/// </summary>
internal Simias.Storage.Domain GetServerDomain(bool Create)
{
// Check if the Server domain exists in the store
Simias.Storage.Domain enterpriseDomain = null;
bool master = true;
try
{
Collection collection = store.GetSingleCollectionByType("Enterprise");
if (collection != null)
{
enterpriseDomain = store.GetDomain(collection.ID);
if (enterpriseDomain != null)
{
this.domainName = enterpriseDomain.Name;
this.id = enterpriseDomain.ID;
// For backwards compatibility, if the report collection does not
// exist because the store was created with a previous version of
// simias, check and create it here.
// Don't create this directory on a slave server.
//TODO : Check with migration !!
Report.CreateReportCollection(store, enterpriseDomain);
}
}
if (enterpriseDomain == null && Create == true)
{
// Bootstrap the domain from the Simias.config file
Simias.Configuration config = Store.Config;
string cfgValue = config.Get("EnterpriseDomain", "SystemName");
if (cfgValue != null && cfgValue != String.Empty)
{
this.domainName = cfgValue;
}
cfgValue = config.Get("EnterpriseDomain", "Description");
if (cfgValue != null && cfgValue != String.Empty)
{
this.description = cfgValue;
}
cfgValue = config.Get("EnterpriseDomain", "AdminName");
if (cfgValue != null && cfgValue != String.Empty)
{
this.admin = cfgValue;
}
cfgValue = config.Get("Server", "MasterAddress");
if (cfgValue != null && cfgValue != String.Empty)
{
master = false;
}
/*
* cfgValue = config.Get( "EnterpriseDomain", "AdminPassword" );
* if ( cfgValue != null && cfgValue != "" )
* {
* this.adminPassword = cfgValue;
* }
*/
if (master == true)
{
cfgValue = config.Get("EnterpriseDomain", "DomainID");
if (cfgValue != null && cfgValue != String.Empty)
{
this.id = cfgValue;
}
else
{
this.id = Guid.NewGuid().ToString();
}
// Create the enterprise server domain.
enterpriseDomain =
new Simias.Storage.Domain(
store,
this.domainName,
this.id,
this.description,
Simias.Sync.SyncRoles.Master,
Simias.Storage.Domain.ConfigurationType.ClientServer);
// This needs to be added to allow the enterprise location provider
// to be able to resolve this domain.
enterpriseDomain.SetType(enterpriseDomain, "Enterprise");
// Create the owner member for the domain.
string provider = null;
cfgValue = config.Get("Identity", "Assembly");
if (cfgValue != null && cfgValue != String.Empty)
{
provider = cfgValue;
}
this.admin = ParseUserName(this.admin, provider);
Member member =
new Member(this.admin, Guid.NewGuid().ToString(), Access.Rights.Admin);
member.IsOwner = true;
enterpriseDomain.SetType(member as Node, "User");
// Marker so we know this member was created internally
// and not through an external identity sync.
enterpriseDomain.SetType(member as Node, "Internal");
enterpriseDomain.Commit(new Node[] { enterpriseDomain, member });
// Set the domain default
store.DefaultDomain = enterpriseDomain.ID;
// Create the name mapping.
store.AddDomainIdentity(enterpriseDomain.ID, member.UserID);
}
else
{
// Slave host so create the proxy domain and owner.
enterpriseDomain = Simias.Host.SlaveSetup.GetDomain(Store.StorePath);
store.DefaultDomain = enterpriseDomain.ID;
enterpriseDomain.Role = Simias.Sync.SyncRoles.Slave;
Member owner = Simias.Host.SlaveSetup.GetOwner(Store.StorePath);
enterpriseDomain.SetType(enterpriseDomain, "Enterprise");
enterpriseDomain.Proxy = true;
owner.Proxy = true;
enterpriseDomain.Commit(new Node[] { enterpriseDomain, owner });
}
Report.CreateReportCollection(store, enterpriseDomain);
}
}
catch (Exception gssd)
{
log.Error(gssd.Message);
log.Error(gssd.StackTrace);
}
return(enterpriseDomain);
}
private void Init()
{
hostAddress = MyDns.GetHostName();
Store store = Store.GetStore();
try
{
Uri localUri = Manager.LocalServiceUrl;
Simias.Storage.Domain rDomain = store.GetDomain( ID );
if (rDomain == null)
{
rDomain =
new Simias.Storage.Domain(
store,
this.domainName,
Simias.Gaim.GaimDomain.ID,
this.description,
Simias.Sync.SyncRoles.Master,
Simias.Storage.Domain.ConfigurationType.Workgroup );
rDomain.SetType( rDomain, "Workgroup" );
string storedUserID = GetGaimUserID();
if (storedUserID != null)
{
log.Debug("Creating the Gaim Domain with a saved UserID");
userID = storedUserID;
}
else
{
log.Debug("Creating the Gaim Domain with a NEW UserID");
userID = Guid.NewGuid().ToString();
}
Member member =
new Member(
userName,
userID,
Access.Rights.Admin );
member.IsOwner = true;
if (localUri == null)
{
localUri = Manager.LocalServiceUrl;
if (localUri != null)
{
Simias.Storage.Property p = new Property("Gaim:SimiasURL", localUri.ToString());
p.LocalProperty = true;
member.Properties.AddProperty(p);
}
else
{
log.Debug("Manager.LocalServiceUrl returned NULL!");
}
}
if (aliasName != null && aliasName.Length > 0)
{
Simias.Storage.Property p = new Property("Gaim:Alias", aliasName);
p.LocalProperty = true;
member.FN = string.Format("{0} ({1})", aliasName, hostName);
}
rDomain.Commit( new Node[] { rDomain, member } );
store.AddDomainIdentity( rDomain.ID, member.UserID );
GaimService.RegisterDomainProvider();
}
Member pMember;
Simias.POBox.POBox poBox = null;
string poBoxName = "POBox:" + Simias.Gaim.GaimDomain.ID + ":" + userID;
try
{
poBox = Simias.POBox.POBox.FindPOBox( store, Simias.Gaim.GaimDomain.ID, userID );
}
catch{}
if (poBox == null)
{
poBox = new Simias.POBox.POBox( store, poBoxName, ID );
pMember =
new Member( userName, userID, Access.Rights.ReadWrite );
pMember.IsOwner = true;
poBox.Commit(new Node[] { poBox, pMember });
}
else
{
pMember = poBox.GetMemberByID( userID );
if (pMember == null)
{
pMember =
new Member( userName, userID, Access.Rights.ReadWrite );
pMember.IsOwner = true;
poBox.Commit(new Node[] { pMember });
}
}
poBoxID = poBox.ID;
}
catch( Exception e1 )
{
log.Error(e1.Message);
log.Error(e1.StackTrace);
throw e1;
}
}
