public IOwned <RpcObjectRef <TService> > PublishInstance <TService>(IOwned <TService> serviceInstance)
where TService : class
{
if (serviceInstance is null)
{
throw new ArgumentNullException(nameof(serviceInstance));
}
var allServices = RpcBuilderUtil.GetAllServices(serviceInstance.Value.GetType(), true);
this.TryRegisterServiceDefinitions(allServices, null);
var connectionInfo = this.RetrieveConnectionInfo();
lock (this.syncRoot)
{
var serviceInstanceId = RpcObjectId.NewId();
var publishedServices = this.PublishInstanceCore_Locked(allServices, serviceInstance, serviceInstanceId, false);
Func <ValueTask> disposeAction = () => this.UnpublishInstanceAsync(serviceInstanceId);
return(OwnedObject.Create(new RpcObjectRef <TService>(
connectionInfo, serviceInstanceId, publishedServices.ToArray()), disposeAction));
}
}
private void SetLastUser(IOwned <TOwner> result)
{
if (result is IOverriden <TOwner> previous)
{
previous.SetLastUser(owner);
}
}
public void LifetimeScope_Resolves_IOwned()
{
IOwned <IInterface> ownedInstance = LifetimeScope.ResolveRequiredService <IOwned <IInterface> >();
Assert.NotNull(ownedInstance);
Assert.NotNull(ownedInstance.Value);
}
public bool CurrentPlayerOwns(IOwned owned)
{
Assert.IsTrue(IsValid);
Assert.IsNotNull(owned);
Assert.IsNotNull(owned.Owner);
return(Agent.CurrentPlayerAgent.Value.Model == owned.Owner.Value);
}
public static void SetNewOwner <TOwner> (this IOwned <TOwner> @this, TOwner owner)
{
if (!Equals(@this.Owner, default(TOwner)))
{
throw new InvalidOperationException("Cannot set owner. Item is already owned.");
}
@this.Owner = owner;
}
public bool SameOwner(IOwned other)
{
if (other == null)
{
return(Owner.Value == null);
}
return(other.Owner.Value == Owner.Value);
}
public static void ResetOwner <TOwner> (this IOwned <TOwner> @this)
{
if (Equals(@this.Owner, default(TOwner)))
{
throw new InvalidOperationException("Cannot reset owner. Item is not yet owned.");
}
@this.Owner = default(TOwner);
}
public bool SameOwner(IOwned other)
{
if (other == null)
{
return(Owner.Value == null);
}
return(ReferenceEquals(other.Owner.Value, Owner.Value));
}
public void LifetimeScope_DoesNotDisposed_OwnedComponent()
{
IOwned <IDisposableInterface> disposable = LifetimeScope.ResolveRequiredService <IOwned <IDisposableInterface> >();
Assert.False(disposable.Value.IsDisposed);
LifetimeScope.Dispose();
Assert.False(disposable.Value.IsDisposed);
}
public bool Authorize(IOwned entity, UUID id)
{
if (id.Equals(_ownerID))
{
//Reset the timeout every time the user makes a change
_updated = true;
JM726.Lib.Static.Util.Wake(this);
return(true);
}
return(false);
}
public void Owned_Downcasts()
{
var builder = new ContainerBuilder();
builder.RegisterTransient <Implementation>().As <IInterface>();
var container = builder.Build();
var instance = container.ResolveRequiredService <IOwned <IInterface> >();
var e = Record.Exception(() =>
{
IOwned <object> downcastOwned = instance;
});
Assert.Null(e);
}
public IOwned <RpcSingletonRef <TService> > PublishSingleton <TService>(IOwned <TService> singletonService) where TService : class
{
if (singletonService == null)
{
throw new ArgumentNullException(nameof(singletonService));
}
var allServices = RpcBuilderUtil.GetAllServices(typeof(TService), false);
this.TryRegisterServiceDefinitions(allServices, null);
var publishedServices = this.VerifyPublishedServices(allServices);
var connectionInfo = this.RetrieveConnectionInfo();
lock (this.syncRoot)
{
var instanceKey = new InstanceKey(singletonService.Value);
foreach (var serviceType in publishedServices.ServiceTypes)
{
if (this.singletonServiceTypeToServiceImpl.ContainsKey(serviceType) || this.singletonServiceTypeToFactory.ContainsKey(serviceType))
{
throw new RpcDefinitionException($"A singleton for the type '{serviceType}' has already been published.");
}
}
this.singletonTypeToPublishedServices.Add(typeof(TService), publishedServices);
var publishedInstance = new PublishedInstance(singletonService);
foreach (var serviceType in publishedServices.ServiceTypes)
{
this.singletonServiceTypeToServiceImpl.Add(serviceType, publishedInstance);
}
}
return(OwnedObject.Create(new RpcSingletonRef <TService>(
connectionInfo),
() => this.UnpublishSingletonAsync <TService>()));
}
private void FailOwnership(IOwned obj)
{
throw new ArgumentException(obj + " is not owned by this Emit, and thus cannot be used");
}
public bool Authorize(IOwned entity, UUID id)
{
if (id.Equals(_ownerID)) {
//Reset the timeout every time the user makes a change
_updated = true;
JM726.Lib.Static.Util.Wake(this);
return true;
}
return false;
}
public bool Authorize(IOwned entity, OpenMetaverse.UUID id)
{
return _parent._ownerID.Equals(UUID.Zero) || id.Equals(_parent._ownerID);
}
public bool Authorize(IOwned entity, UUID id)
{
return true;
}
public bool Authorize(IOwned entity, OpenMetaverse.UUID id)
{
return(_parent._ownerID.Equals(UUID.Zero) || id.Equals(_parent._ownerID));
}
public bool Authorize(IOwned entity, UUID id)
{
return _god.Equals(id);
}
public bool Authorize(IOwned entity, UUID id)
{
return(entity.Owner == id);
}
public bool Authorize(IOwned entity, UUID id)
{
return(true);
}
public ServiceProviderServiceImpl(IRpcServicePublisher publisher)
{
this.simpleServiceScope = publisher.PublishInstance <ISimpleService>(new TestSimpleServiceImpl());
}
public bool Authorize(IOwned entity, UUID id)
{
return entity.Owner == id;
}
public static IOwned <RpcObjectRef <TService> > PublishInstance <TService>(this IRpcServer server, IOwned <TService> serviceInstance) where TService : class
{
if (server is null)
{
throw new ArgumentNullException(nameof(server));
}
return(server.ServicePublisher.PublishInstance(serviceInstance));
}
public bool SameOwner(IOwned other)
{
return(ReferenceEquals(Owner.Value, other));
}
public bool SameOwner(IOwned other) => ReferenceEquals(Owner.Value, other.Owner.Value);
public static bool Owns(this ClaimsPrincipal user, IOwned obj)
{
return(user.Identity.Name == obj.OwnerLogin);
}
internal static T Resolve <T>(ref IOwned <T> factory) => (factory = factory ?? container.Resolve <Func <IOwned <T> > >()()).Value;
public bool Authorize(IOwned entity, UUID id)
{
return(_god.Equals(id));
}
