public Uid ResolveUsername(ObjectClass objectClass, string username, OperationOptions options)
{
Trace.TraceInformation("Invoke ResolveUsername ObjectClass:{0}=>{1}", objectClass.GetObjectClassValue(), username);
try
{
Object uidAfter = ExecuteResolveUsername(_configuration.ResolveUsernameScriptFileName, objectClass,
username, options);
if (uidAfter is String)
{
Trace.TraceInformation("{0}:{1} resolved", objectClass.GetObjectClassValue(), uidAfter);
return(new Uid((String)uidAfter));
}
if (uidAfter is Uid)
{
Trace.TraceInformation("{0}:{1} resolved", objectClass.GetObjectClassValue(), uidAfter);
return((Uid)uidAfter);
}
throw new ConnectorException("ResolveUsername script didn't return with the uid (__UID__) string value");
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
public Uid Authenticate(ObjectClass objectClass, string username, GuardedString password, OperationOptions options)
{
Trace.TraceInformation("Invoke Authenticate ObjectClass:{0}=>{1}", objectClass.GetObjectClassValue(), username);
try
{
Object uidAfter = ExecuteAuthenticate(_configuration.AuthenticateScriptFileName, objectClass, username,
password, options);
if (uidAfter is String)
{
Trace.TraceInformation("{0}:{1} authenticated", objectClass.GetObjectClassValue(), uidAfter);
return(new Uid((String)uidAfter));
}
if (uidAfter is Uid)
{
var u = uidAfter as Uid;
Trace.TraceInformation("{0}:{1} authenticated", objectClass.GetObjectClassValue(), u.GetUidValue());
return(u);
}
throw new ConnectorException("Authenticate script didn't return with the uid (__UID__) string value");
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
public virtual Uid Update(ObjectClass objectClass, Uid uid, ICollection <ConnectorAttribute> replaceAttributes,
OperationOptions options)
{
var attributesAccessor = new ConnectorAttributesAccessor(replaceAttributes);
Name newName = attributesAccessor.GetName();
Uid uidAfterUpdate = uid;
if (newName != null)
{
Trace.TraceInformation("Rename the object {0}:{1} to {2}", objectClass.GetObjectClassValue(),
uid.GetUidValue(), newName.GetNameValue());
uidAfterUpdate = new Uid(newName.GetNameValue().ToLower());
}
if (ObjectClass.ACCOUNT.Equals(objectClass))
{
}
else if (ObjectClass.GROUP.Is(objectClass.GetObjectClassValue()))
{
if (attributesAccessor.HasAttribute("members"))
{
throw new InvalidAttributeValueException("Requested to update a read only attribute");
}
}
else
{
Trace.TraceWarning("Update of type {0} is not supported",
_configuration.ConnectorMessages.Format(objectClass.GetDisplayNameKey(),
objectClass.GetObjectClassValue()));
throw new NotSupportedException("Update of type" + objectClass.GetObjectClassValue() +
" is not supported");
}
return(uidAfterUpdate);
}
public virtual SyncToken GetLatestSyncToken(ObjectClass objectClass)
{
if (ObjectClass.ACCOUNT.Equals(objectClass))
{
return(new SyncToken(10));
}
Trace.TraceWarning("Sync of type {0} is not supported",
_configuration.ConnectorMessages.Format(objectClass.GetDisplayNameKey(),
objectClass.GetObjectClassValue()));
throw new NotSupportedException("Sync of type" + objectClass.GetObjectClassValue() + " is not supported");
}
public virtual Uid ResolveUsername(ObjectClass objectClass, string userName, OperationOptions options)
{
if (ObjectClass.ACCOUNT.Equals(objectClass))
{
return(new Uid(userName));
}
Trace.TraceWarning("ResolveUsername of type {0} is not supported",
_configuration.ConnectorMessages.Format(objectClass.GetDisplayNameKey(),
objectClass.GetObjectClassValue()));
throw new NotSupportedException("ResolveUsername of type" + objectClass.GetObjectClassValue() +
" is not supported");
}
public virtual void Delete(ObjectClass objectClass, Uid uid, OperationOptions options)
{
if (ObjectClass.ACCOUNT.Equals(objectClass) || ObjectClass.GROUP.Equals(objectClass))
{
// do real delete here
}
else
{
Trace.TraceWarning("Delete of type {0} is not supported",
_configuration.ConnectorMessages.Format(objectClass.GetDisplayNameKey(),
objectClass.GetObjectClassValue()));
throw new NotSupportedException("Delete of type" + objectClass.GetObjectClassValue() +
" is not supported");
}
}
internal ConnectorObject CreateConnectorObject(ExchangeConnector connector, PSObject psobject, ObjectClass objectClass)
{
ConnectorObjectBuilder builder = new ConnectorObjectBuilder();
string guid = (string)psobject.Properties["guid"].Value.ToString();
string name = (string)psobject.Properties["name"].Value;
builder.SetUid(new Uid(guid));
builder.SetName(new Name(name));
ObjectClassInfo ocinfo = connector.GetSchema().FindObjectClassInfo(objectClass.GetObjectClassValue());
IDictionary <string, PSPropertyInfo> properties = psobject.Properties.ToDictionary(psinfo => psinfo.Name);
LOG.Trace("Building connector object with UID = {0} and Name = {1}", guid, name);
foreach (ConnectorAttributeInfo cai in ocinfo.ConnectorAttributeInfos)
{
if (cai.IsReadable && properties.ContainsKey(cai.Name))
{
object value = properties[cai.Name].Value;
LOG.Trace(" - attribute {0} = {1}", cai.Name, value);
if (value is PSObject)
{
var ps = value as PSObject;
value = ps.BaseObject;
LOG.Trace(" - attribute {0} UNWRAPPED = {1} ({2})", cai.Name, value, value.GetType());
}
builder.AddAttribute(cai.Name, CommonUtils.ConvertToSupportedForm(cai, value));
}
}
return(builder.Build());
}
public virtual SyncToken GetLatestSyncToken(ObjectClass objectClass)
{
Trace.TraceInformation("Invoke GetLatestSyncToken ObjectClass:{0}", objectClass.GetObjectClassValue());
SyncToken token = null;
try
{
Object result = ExecuteGetLatestSyncToken(_configuration.SyncScriptFileName, objectClass);
if (result is SyncToken)
{
token = result as SyncToken;
}
else if (null != result)
{
token = new SyncToken(result);
}
Trace.TraceInformation("GetLatestSyncToken ok");
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
return(token);
}
public virtual Uid Create(ObjectClass objectClass, ICollection <ConnectorAttribute> createAttributes,
OperationOptions options)
{
if (ObjectClass.ACCOUNT.Equals(objectClass) || ObjectClass.GROUP.Equals(objectClass))
{
Name name = ConnectorAttributeUtil.GetNameFromAttributes(createAttributes);
if (name != null)
{
// do real create here
return(new Uid(ConnectorAttributeUtil.GetStringValue(name).ToLower()));
}
throw new InvalidAttributeValueException("Name attribute is required");
}
Trace.TraceWarning("Delete of type {0} is not supported",
_configuration.ConnectorMessages.Format(objectClass.GetDisplayNameKey(),
objectClass.GetObjectClassValue()));
throw new NotSupportedException("Delete of type" + objectClass.GetObjectClassValue() + " is not supported");
}
public Uid Update(ObjectClass objectClass, Uid uid, ICollection <ConnectorAttribute> valuesToReplace, OperationOptions options)
{
Trace.TraceInformation("Invoke Update ObjectClass: {0}/{1}", objectClass.GetObjectClassValue(), uid.GetUidValue());
try
{
Uid uidAfter = ExecuteUpdate(_configuration.UpdateScriptFileName, objectClass, uid, valuesToReplace, options);
if (uidAfter == null)
{
throw new ConnectorException("Update script didn't return with a valid uid (__UID__) value");
}
Trace.TraceInformation("{0}:{1} updated", objectClass.GetObjectClassValue(), uidAfter.GetUidValue());
return(uidAfter);
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
// implementation of CreateSpiOp
public virtual Uid Create(ObjectClass objectClass, ICollection <ConnectorAttribute> createAttributes, OperationOptions options)
{
Trace.TraceInformation("Invoke Create ObjectClass:{0}", objectClass.GetObjectClassValue());
try
{
Uid uid = ExecuteCreate(_configuration.CreateScriptFileName, objectClass, createAttributes, options);
if (uid == null)
{
throw new ConnectorException("Create script didn't return with a valid uid (__UID__) string value");
}
Trace.TraceInformation("{0}:{1} created", objectClass.GetObjectClassValue(), uid.GetUidValue());
return(uid);
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
public virtual void Sync(ObjectClass objectClass, SyncToken token, SyncResultsHandler handler,
OperationOptions options)
{
if (ObjectClass.ALL.Equals(objectClass))
{
//
}
else if (ObjectClass.ACCOUNT.Equals(objectClass))
{
var builder = new ConnectorObjectBuilder();
builder.SetUid("3f50eca0-f5e9-11e3-a3ac-0800200c9a66");
builder.SetName("Foo");
builder.AddAttribute(ConnectorAttributeBuilder.BuildEnabled(true));
var deltaBuilder = new SyncDeltaBuilder
{
Object = builder.Build(),
DeltaType = SyncDeltaType.CREATE,
Token = new SyncToken(10)
};
foreach (SyncDelta connectorObject in CollectionUtil.NewSet(deltaBuilder.Build()))
{
if (!handler.Handle(connectorObject))
{
// Stop iterating because the handler stopped processing
break;
}
}
}
else
{
Trace.TraceWarning("Sync of type {0} is not supported",
_configuration.ConnectorMessages.Format(objectClass.GetDisplayNameKey(),
objectClass.GetObjectClassValue()));
throw new NotSupportedException("Sync of type" + objectClass.GetObjectClassValue() + " is not supported");
}
((SyncTokenResultsHandler)handler).HandleResult(new SyncToken(10));
}
/// <summary>
/// Returns the AD ObjectClass associated with a particular
/// Connector ObjectClass
/// </summary>
/// <param name="oclass"></param>
/// <returns></returns>
internal String GetADObjectClass(ObjectClass oclass)
{
if (oclass.Equals(ObjectClass.ACCOUNT))
{
return(_configuration.ObjectClass);
}
else if (ActiveDirectoryConnector.groupObjectClass.Equals(oclass))
{
return("Group");
}
else if (ActiveDirectoryConnector.ouObjectClass.Equals(oclass))
{
return("organizationalUnit");
}
else
{
// It's not something I know about, so I'll consult the AD schema.
// if it's there, fine, but if not throw an exception.
//first check to see if we have seen it before.
String objectClassName = oclass.GetObjectClassValue();
if (_knownObjectClasses.Contains(objectClassName))
{
return(objectClassName);
}
// if we havent seen it before, consult AD's schema
ActiveDirectorySchema ADSchema = GetADSchema();
ActiveDirectorySchemaClass ADSchemaClass = null;
try
{
ADSchemaClass = ADSchema.FindClass(objectClassName);
_knownObjectClasses.Add(objectClassName);
return(objectClassName);
}
catch (ActiveDirectoryObjectNotFoundException exception)
{
String msg = _configuration.ConnectorMessages.Format(
"ex_ObjectClassInvalidForConnector",
"ObjectClass \'{0}\' is not valid for this connector",
objectClassName);
throw new ConnectorException(msg);
}
}
}
// implementation of DeleteSpiOp
public virtual void Delete(ObjectClass objectClass, Uid uid, OperationOptions options)
{
Trace.TraceInformation("Invoke Delete ObjectClass:{0}/{1}", objectClass.GetObjectClassValue(), uid.GetUidValue());
try
{
ExecuteDelete(_configuration.DeleteScriptFileName, objectClass, uid, options);
Trace.TraceInformation("Delete ok");
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
// implementation of SearchSpiOp
public virtual void ExecuteQuery(ObjectClass objectClass, Filter query,
ResultsHandler handler, OperationOptions options)
{
Trace.TraceInformation("Invoke ExecuteQuery ObjectClass:{0}", objectClass.GetObjectClassValue());
try
{
ExecuteQuery(_configuration.SearchScriptFileName, objectClass, query, handler, options);
Trace.TraceInformation("Search ok");
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
/// <summary>
/// Implementation of CreateOp.Create
/// </summary>
/// <param name="oclass">Object class</param>
/// <param name="attributes">Object attributes</param>
/// <param name="options">Operation options</param>
/// <returns>Uid of the created object</returns>
public Uid Create(ObjectClass oclass, ICollection <ConnectorAttribute> attributes, OperationOptions options)
{
const string operation = "Create";
ExchangeUtility.NullCheck(oclass, "oclass", this._configuration);
ExchangeUtility.NullCheck(attributes, "attributes", this._configuration);
LOG.Info("Exchange.Create method for {0}; attributes:\n{1}", oclass.GetObjectClassValue(), CommonUtils.DumpConnectorAttributes(attributes));
String database = (String)ExchangeUtility.GetAttValue("Database", attributes);
LOG.Info("Database attribute before plugins call: " + database);
plugins.OnBeforeCreate(oclass, attributes, options, _configuration);
database = (String)ExchangeUtility.GetAttValue("Database", attributes);
LOG.Info("Database attribute after plugins call: " + database);
CreateOpContext context = new CreateOpContext()
{
Attributes = attributes,
Connector = this,
ConnectorConfiguration = this._configuration,
ObjectClass = oclass,
OperationName = operation,
Options = options
};
try {
_scripting.ExecutePowerShell(context, Scripting.Position.BeforeMain);
if (!_scripting.ExecutePowerShell(context, Scripting.Position.InsteadOfMain))
{
CreateMain(context);
}
_scripting.ExecutePowerShell(context, Scripting.Position.AfterMain);
return(context.Uid);
} catch (Exception e) {
LOG.Error(e, "Exception while executing Create operation: {0}");
throw;
}
}
public virtual void Sync(ObjectClass objectClass, SyncToken token,
SyncResultsHandler handler, OperationOptions options)
{
Trace.TraceInformation("Invoke Sync ObjectClass:{0}->{1}", objectClass.GetObjectClassValue(), token);
try
{
ExecuteSync(_configuration.SyncScriptFileName, objectClass, token, handler, options);
Trace.TraceInformation("Sync ok");
}
catch (ConnectorException)
{
throw;
}
catch (Exception e)
{
if (e.InnerException != null)
{
throw e.InnerException;
}
throw;
}
}
// TODO Exchange-specific attributes
/// <summary>
/// Implementation of SearchOp.CreateFilterTranslator
/// </summary>
/// <param name="oclass">Object class</param>
/// <param name="options">Operation options</param>
/// <returns>Filter translator</returns>
public FilterTranslator <string> CreateFilterTranslator(ObjectClass oclass, OperationOptions options)
{
return(_handlers[oclass.GetObjectClassValue()].CreateFilterTranslator(this, oclass, options));
}
/// <summary>
/// Implementation of CreateOp.Create
/// </summary>
/// <param name="oclass">Object class</param>
/// <param name="attributes">Object attributes</param>
/// <param name="options">Operation options</param>
/// <returns>Uid of the created object</returns>
public Uid Create(ObjectClass oclass, ICollection <ConnectorAttribute> attributes, OperationOptions options)
{
const string operation = "Create";
ExchangeUtility.NullCheck(oclass, "oclass", this._configuration);
ExchangeUtility.NullCheck(attributes, "attributes", this._configuration);
LOGGER_API.TraceEvent(TraceEventType.Information, CAT_DEFAULT,
"Exchange.Create method for {0}; attributes:\n{1}", oclass.GetObjectClassValue(), CommonUtils.DumpConnectorAttributes(attributes));
CreateOpContext context = new CreateOpContext()
{
Attributes = attributes,
Connector = this,
ConnectorConfiguration = this._configuration,
ObjectClass = oclass,
OperationName = operation,
Options = options
};
try {
_scripting.ExecutePowerShell(context, Scripting.Position.BeforeMain);
if (!_scripting.ExecutePowerShell(context, Scripting.Position.InsteadOfMain))
{
CreateMain(context);
}
_scripting.ExecutePowerShell(context, Scripting.Position.AfterMain);
return(context.Uid);
} catch (Exception e) {
LOGGER.TraceEvent(TraceEventType.Error, CAT_DEFAULT, "Exception while executing Create operation: {0}", e);
throw;
}
}
