public void HostAdapter_Ctor()
{
var window = new TestWindow();
var actual = new HostAdapter(window);
Assert.NotNull(actual);
}
private static T AdaptToHost <T>(AddInToken pipeline, IContract addInContract)
{
if (addInContract == null)
{
throw new ArgumentNullException("addInContract");
}
System.Diagnostics.Contracts.Contract.EndContractBlock();
ContractComponent contract = pipeline._contract;
HostAdapter hostAdapter = pipeline._hostAdapter;
Type hostAdapterType;
Type contractType;
LoadContractAndHostAdapter(contract, hostAdapter, out contractType, out hostAdapterType);
int?temporaryToken = null;
try
{
temporaryToken = addInContract.AcquireLifetimeToken();
// This assembly resolve event exists to:
// 1) To upgrade the contract assembly from the LoadFrom context to
// the default loader context
ResolverHelper resolver = new ResolverHelper(pipeline);
ResolveEventHandler assemblyResolver = new ResolveEventHandler(resolver.ResolveAssemblyForHostAdapter);
AppDomain.CurrentDomain.AssemblyResolve += assemblyResolver;
// Create the Host Adapter, which is a subclass of the Host Add-In View.
// Pass the contract implementation to this constructor, using a
// transparent proxy to the real type. Detect common errors here.
InvokerDelegate myInvokerDelegate = CreateConsInvoker(hostAdapterType, contractType);
T hav;
try
{
hav = (T)myInvokerDelegate(addInContract);
}
catch (ArgumentException e)
{
CheckForLoaderContextProblems(contract, pipeline._addinAdapter, e);
throw;
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= assemblyResolver;
}
return(hav);
}
finally
{
if (temporaryToken != null && addInContract != null)
{
addInContract.RevokeLifetimeToken((int)temporaryToken);
}
}
}
public void Route_TwoSegmentsProxied_ClaimedMethodsExecuted()
{
var configuration = ExtensibilityConfigurationProvider.LoadConfiguration();
var context = new PluginContext(_strategy);
var hostAdapter = new HostAdapter <ISegmentedContract>(context, configuration);
var proxy = RoutableProxy.Create <ISegmentedContract>(hostAdapter);
Assert.Equal(ISegmentedContract.FirstSomeMethod, proxy.SomeMethod());
Assert.Equal(ISegmentedContract.SecondSomeOtherMethod, proxy.SomeOtherMethod());
}
public void Route_XmlConfig_ClaimedMethodsExecuted()
{
var configuration = CreateAlphaPrimaryConfiguration();
var context = new PluginContext(_strategy);
var hostAdapter = new HostAdapter <ISegmentedContract>(context, configuration);
var proxy = RoutableProxy.Create <ISegmentedContract>(hostAdapter);
Assert.Equal(ISegmentedContract.FirstSomeMethod, proxy.SomeMethod());
Assert.Equal(ISegmentedContract.SecondSomeOtherMethod, proxy.SomeOtherMethod());
}
internal PartialToken(HostAdapter hostAdapter, ContractComponent contract,
AddInAdapter addinAdapter, AddInBase addinBase)
{
System.Diagnostics.Contracts.Contract.Requires(hostAdapter != null);
System.Diagnostics.Contracts.Contract.Requires(contract != null);
System.Diagnostics.Contracts.Contract.Requires(addinAdapter != null);
System.Diagnostics.Contracts.Contract.Requires(addinBase != null);
_hostAdapter = hostAdapter;
_contract = contract;
_addinAdapter = addinAdapter;
_addinBase = addinBase;
}
internal PartialToken(HostAdapter hostAdapter, ContractComponent contract,
AddInAdapter addinAdapter, AddInBase addinBase)
{
System.Diagnostics.Contracts.Contract.Requires(hostAdapter != null);
System.Diagnostics.Contracts.Contract.Requires(contract != null);
System.Diagnostics.Contracts.Contract.Requires(addinAdapter != null);
System.Diagnostics.Contracts.Contract.Requires(addinBase != null);
_hostAdapter = hostAdapter;
_contract = contract;
_addinAdapter = addinAdapter;
_addinBase = addinBase;
}
public void Route_TwoSegments_ClaimedMethodsExecuted()
{
var configuration = CreateAlphaPrimaryConfiguration();
var context = new PluginContext(_strategy);
var hostAdapter = new HostAdapter <ISegmentedContract>(context, configuration);
var firstPart = hostAdapter.Route(nameof(ISegmentedContract.SomeMethod));
Assert.Equal(ISegmentedContract.FirstSomeMethod, firstPart.SomeMethod());
var secondPart = hostAdapter.Route(nameof(ISegmentedContract.SomeOtherMethod));
Assert.Equal(ISegmentedContract.SecondSomeOtherMethod, secondPart.SomeOtherMethod());
}
internal static T ActivateHostAdapter <T>(PartialToken pipeline, IContract addIn)
{
if (pipeline == null)
{
throw new ArgumentNullException("pipeline");
}
if (addIn == null)
{
throw new ArgumentNullException("addIn");
}
System.Diagnostics.Contracts.Contract.EndContractBlock();
ContractComponent contract = pipeline._contract;
HostAdapter hostAdapter = pipeline._hostAdapter;
Type hostAdapterType;
Type contractType;
LoadContractAndHostAdapter(contract, hostAdapter, out contractType, out hostAdapterType);
// This assembly resolve event exists to:
// 1) To upgrade the contract assembly from the LoadFrom context to
// the default loader context
ResolverHelper resolver = new ResolverHelper(contract);
ResolveEventHandler assemblyResolver = new ResolveEventHandler(resolver.ResolveAssemblyForHostAdapter);
AppDomain.CurrentDomain.AssemblyResolve += assemblyResolver;
T hav;
InvokerDelegate myInvokerDelegate = CreateConsInvoker(hostAdapterType, contractType);
try
{
hav = (T)myInvokerDelegate(addIn);
}
catch (ArgumentException e)
{
CheckForLoaderContextProblems(contract, pipeline._addinAdapter, e);
throw;
}
finally
{
AppDomain.CurrentDomain.AssemblyResolve -= assemblyResolver;
}
return(hav);
}
internal static void LoadContractAndHostAdapter(ContractComponent contract, HostAdapter hostAdapter,
out Type contractType, out Type hostAdapterType)
{
PermissionSet assertSet = new PermissionSet(PermissionState.None);
assertSet.AddPermission(new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.PathDiscovery, hostAdapter.Location));
assertSet.AddPermission(new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.PathDiscovery, contract.Location));
assertSet.Assert();
// Explicitly load the host adapter & contract first, using LoadFrom
// to ensure they are loaded in the same loader context.
Assembly hostAdapterAssembly = Assembly.LoadFrom(hostAdapter.Location);
Assembly contractAssembly = Assembly.LoadFrom(contract.Location);
hostAdapterType = hostAdapterAssembly.GetType(hostAdapter.TypeInfo.FullName, true);
contractType = contractAssembly.GetType(contract.TypeInfo.FullName, true);
}
public void Route_JsonConfig_ClaimedMethodsExecuted()
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("test.json");
var configurationRoot = builder.Build();
var configuration = configurationRoot.Get <ExtensibilityConfiguration>();
var context = new PluginContext(_strategy);
var hostAdapter = new HostAdapter <ISegmentedContract>(context, configuration);
var proxy = RoutableProxy.Create <ISegmentedContract>(hostAdapter);
Assert.Equal(ISegmentedContract.FirstSomeMethod, proxy.SomeMethod());
Assert.Equal(ISegmentedContract.SecondSomeOtherMethod, proxy.SomeOtherMethod());
}
internal AddInToken(HostAdapter hostAdapter, ContractComponent contract,
AddInAdapter addinAdapter, AddInBase addinBase, AddIn addin)
{
System.Diagnostics.Contracts.Contract.Requires(hostAdapter != null);
System.Diagnostics.Contracts.Contract.Requires(contract != null);
System.Diagnostics.Contracts.Contract.Requires(addinAdapter != null);
System.Diagnostics.Contracts.Contract.Requires(addinBase != null);
System.Diagnostics.Contracts.Contract.Requires(addin != null);
_hostAddinViews = hostAdapter.HostAddinViews;
_hostAdapter = hostAdapter;
_contract = contract;
_addinAdapter = addinAdapter;
_addinBase = addinBase;
_addin = addin;
// _pipelineRootDir must be filled in after deserialization.
}
protected override void Act()
{
HostAdapter.NavigateTask(validationError);
}
private static T ActivateInAppDomain <T>(AddInToken pipeline, AppDomain domain, AddInControllerImpl controller, bool weOwn)
{
ContractComponent contract = pipeline._contract;
HostAdapter hostAdapter = pipeline._hostAdapter;
bool usingHostAppDomain = domain == AppDomain.CurrentDomain;
//begin direct connect code
if (AddInToken.EnableDirectConnect && !weOwn && usingHostAppDomain)
{
Type havType = typeof(T);
TypeInfo havTypeInfo = new TypeInfo(havType);
if (pipeline._addinBase.CanDirectConnectTo(havTypeInfo))
{
// Connect directly for best performance.
// Assert permission to the specific Addin directory only.
PermissionSet permissionSet = new PermissionSet(PermissionState.None);
permissionSet.AddPermission(new FileIOPermission(FileIOPermissionAccess.Read | FileIOPermissionAccess.PathDiscovery,
Path.GetDirectoryName(pipeline._addin.Location)));
permissionSet.Assert();
Assembly addInAssembly = Assembly.LoadFrom(pipeline._addin.Location);
//
Type addinType = addInAssembly.GetType(pipeline._addin.TypeInfo.FullName, true);
Object addIn = addinType.GetConstructor(new Type[0]).Invoke(new Object[0]);
System.Diagnostics.Contracts.Contract.Assert(addIn != null, "Bypass couldn't create the add-in");
// remember the addin directly as the HAV. Set the contract to null.
controller.AssociateWithHostAddinView(addIn, null);
return((T)addIn);
}
}
//end direct connect code
// Use Activator.CreateInstance instead of AppDomain.CreateInstanceAndUnwrap
// because Activator will do the appropriate security asserts in the
// remote appdomain.
Type t = typeof(ActivationWorker);
Object[] args = new Object[] { pipeline };
ObjectHandle objHandle = Activator.CreateInstance(domain, t.Assembly.FullName, t.FullName,
false, BindingFlags.Instance | BindingFlags.NonPublic, null,
args, null, null);
ActivationWorker activationWorker = (ActivationWorker)objHandle.Unwrap();
activationWorker.UsingHostAppDomain = usingHostAppDomain;
System.AddIn.Contract.IContract addInContract = null;
try
{
addInContract = activationWorker.Activate();
}
catch (Exception ex)
{
CheckForDuplicateAssemblyProblems(pipeline, ex);
throw;
}
if (weOwn)
{
domain.SetData(ContractHandle.s_appDomainOwner, addInContract);
}
controller.ActivationWorker = activationWorker;
T hav = AdaptToHost <T>(pipeline, addInContract);
controller.AssociateWithHostAddinView(hav, addInContract);
return(hav);
}
