/// <summary>
/// Gets the first plugin satisfying the required operation claims for the current package source.
/// </summary>
/// <param name="requiredClaim">The required operation claim.</param>
/// <param name="cancellationToken">A cancellation token.</param>
/// <returns>A task that represents the asynchronous operation.
/// The task result (<see cref="Task{TResult}.Result" />) returns a <see cref="GetPluginResult" />.</returns>
/// <exception cref="OperationCanceledException">Thrown if <paramref name="cancellationToken" />
/// is cancelled.</exception>
public async Task <GetPluginResult> GetPluginAsync(
OperationClaim requiredClaim,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var messages = new List <string>();
foreach (var result in _pluginCreationResults)
{
if (!string.IsNullOrEmpty(result.Message))
{
throw new PluginException(result.Message);
}
if (result.Claims.Contains(requiredClaim))
{
var key = $"{MessageMethod.SetCredentials}.{_packageSource.SourceUri}";
await result.PluginMulticlientUtilities.DoOncePerPluginLifetimeAsync(
key,
() => SetPackageSourceCredentialsAsync(result.Plugin, cancellationToken),
cancellationToken);
return(new GetPluginResult(result.Plugin, result.PluginMulticlientUtilities));
}
}
return(null);
}
public IResult AddUserOperationClaim(AppUser userResult, OperationClaim operationClaim)
{
_userOperationClaimDal.Add(new UserOperationClaim {
User = userResult, OperationClaim = operationClaim
});
return(new SuccessResult());
}
/// <summary>
/// Creates a plugin from the discovered plugin.
/// We firstly check the cache for the operation claims for the given request key.
/// If there is a valid cache entry, and it does contain the requested operation claim, then we start the plugin, and if need be update the cache value itself.
/// If there is a valid cache entry, and it does NOT contain the requested operation claim, then we return a null.
/// If there is no valid cache entry or an invalid one, we start the plugin as normally, return an active plugin even if the requested claim is not available, and write a cache entry.
/// </summary>
/// <param name="result">plugin discovery result</param>
/// <param name="requestedOperationClaim">The requested operation claim</param>
/// <param name="requestKey">plugin request key</param>
/// <param name="packageSourceRepository">package source repository</param>
/// <param name="serviceIndex">service index</param>
/// <param name="cancellationToken">cancellation token</param>
/// <returns>A plugin creation result, null if the requested plugin cannot handle the given operation claim</returns>
private async Task <Tuple <bool, PluginCreationResult> > TryCreatePluginAsync(
PluginDiscoveryResult result,
OperationClaim requestedOperationClaim,
PluginRequestKey requestKey,
string packageSourceRepository,
JObject serviceIndex,
CancellationToken cancellationToken)
{
PluginCreationResult pluginCreationResult = null;
var cacheEntry = new PluginCacheEntry(_pluginsCacheDirectory.Value, result.PluginFile.Path, requestKey.PackageSourceRepository);
return(await ConcurrencyUtilities.ExecuteWithFileLockedAsync(
cacheEntry.CacheFileName,
action : async lockedToken =>
{
if (cacheEntry.OperationClaims == null || cacheEntry.OperationClaims.Contains(requestedOperationClaim))
{
if (result.PluginFile.State.Value == PluginFileState.Valid)
{
var plugin = await _pluginFactory.GetOrCreateAsync(
result.PluginFile.Path,
PluginConstants.PluginArguments,
new RequestHandlers(),
_connectionOptions,
cancellationToken);
var utilities = await PerformOneTimePluginInitializationAsync(plugin, cancellationToken);
// We still make the GetOperationClaims call even if we have the operation claims cached. This is a way to self-update the cache.
var operationClaims = await _pluginOperationClaims.GetOrAdd(
requestKey,
key => new Lazy <Task <IReadOnlyList <OperationClaim> > >(() =>
GetPluginOperationClaimsAsync(
plugin,
packageSourceRepository,
serviceIndex,
cancellationToken))).Value;
if (!EqualityUtility.SequenceEqualWithNullCheck(operationClaims, cacheEntry.OperationClaims))
{
cacheEntry.OperationClaims = operationClaims;
await cacheEntry.UpdateCacheFileAsync();
}
pluginCreationResult = new PluginCreationResult(
plugin,
utilities.Value,
operationClaims);
}
else
{
pluginCreationResult = new PluginCreationResult(result.Message);
}
}
return new Tuple <bool, PluginCreationResult>(pluginCreationResult != null, pluginCreationResult);
},
token : cancellationToken
));
}
public IActionResult Update(OperationClaim operation)
{
var result = _operationService.Update(operation);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult Delete(OperationClaim operationClaim)
{
var result = _operationClaimService.Delete(operationClaim);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Add(OperationClaim operationClaim)
{
var result = _operationClaimService.Add(operationClaim);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IResult Add(OperationClaim operationClaim)
{
var result = _operationClaimDal.GetAll(o => o.Name == operationClaim.Name);
if (result.Count != 0)
{
return(new ErrorResult(Messages.OperationClaimAlreadyExist));
}
_operationClaimDal.Add(operationClaim);
return(new SuccessResult(Messages.AddedOperationClaim));
}
public async Task <IResult> Handle(UpdateOperationClaimCommand request, CancellationToken cancellationToken)
{
var claimToUpdate = new OperationClaim
{
Id = request.Id,
Name = request.ClaimName
};
await _operationClaimDal.UpdateAsync(claimToUpdate);
return(new SuccessResult(Messages.OperationClaimUpdated));
}
//[ValidationAspect(typeof(OperationClaimValidator))]
public IResult Add(OperationClaim entity)
{
var result = BusinessRules.Run(CheckOperationClaimCount());
if (result != null)
{
return(result);
}
_userDal.Add(entity);
return(new SuccessResult(Messages.Added));
}
public IActionResult GetAll(OperationClaim operationClaim)
{
var result = _operationClaimService.GetAll();
if (result.Success == true)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IResult Update(OperationClaim operationClaim)
{
IResult result = BusinessRules.Run(CheckIfOperationClaimAlreadyExist(operationClaim));
if (result != null)
{
return(result);
}
_operationClaimDal.Update(operationClaim);
return(new SuccessResult(Messages.OperationClaimUpdated));
}
public IResult Delete(OperationClaim operationClaim)
{
IResult result = BusinessRules.Run();
if (result != null)
{
return(result);
}
_operationClaimDal.Delete(operationClaim);
return(new SuccessResult());
}
public void InvalidParameters_ThrowValidationException()
{
OperationClaim operationClaim = new OperationClaim
{
Id = 1,
Name = "O"
};
var result = _validator.TestValidate(operationClaim);
result.ShouldHaveValidationErrorFor("Name");
}
public void Update_UpdateOperationClaim_ReturnTrueResult()
{
IOperationClaimService service = new OperationClaimManager(_mockOperationClaimDal.Object);
OperationClaim operationClaim = new OperationClaim
{
Id = 1,
Name = It.IsAny <string>()
};
var result = service.Update(operationClaim);
Assert.IsTrue(result.Success);
}
private IResult CheckIfOperationClaimAlreadyExist(OperationClaim operationClaim)
{
var result = _operationClaimDal.Get(o => o.OperationClaimName == operationClaim.OperationClaimName);
if (result != null)
{
if (result.OperationClaimID != operationClaim.OperationClaimID)
{
return(new ErrorResult(Messages.OperationClaimAlreadyExist));
}
}
return(new SuccessResult());
}
public IResult Update(OperationClaim operationClaim)
{
IResult result = BusinessRule.Run
(
CheckIfClaimExist(operationClaim.Id)
);
if (result != null)
{
return(result);
}
_operationClaimDal.Update(operationClaim);
return(new SuccessResult(OperationClaimMessages.Updated));
}
public IResult Update(OperationClaim operationClaim)
{
IResult result = BusinessRules.Run(
CheckIfOperationClaimNameIsExists(operationClaim.Name)
);
if (result != null)
{
return(result);
}
_operationClaimDal.Update(operationClaim);
return(new SuccessResult());
}
public IResult Add(OperationClaim operationClaim)
{
IResult result = BusinessRule.Run
(
CheckIfClaimAlreadyExist(operationClaim.Name)
);
if (result != null)
{
return(result);
}
_operationClaimDal.Add(operationClaim);
return(new SuccessResult());
}
public async Task <IResult> Handle(CreateGroupClaimCommand request, CancellationToken cancellationToken)
{
if (IsClaimExists(request.ClaimName))
{
return(new ErrorResult(Messages.OperationClaimExists));
}
var operationClaim = new OperationClaim
{
Name = request.ClaimName
};
await _operationClaimDal.AddAsync(operationClaim);
return(new SuccessResult(Messages.OperationClaimAdded));
}
public async Task <IResult> Handle(CreateOperationClaimCommand request, CancellationToken cancellationToken)
{
if (IsClaimExists(request.ClaimName))
{
return(new ErrorResult(Messages.OperationClaimExists));
}
var operationClaim = new OperationClaim
{
Name = request.ClaimName
};
_operationClaimRepository.Add(operationClaim);
await _operationClaimRepository.SaveChangesAsync();
return(new SuccessResult(Messages.Added));
}
public async Task <IResult> Register(User user)
{
await _userDal.AddAsync(user);
var defaultOperationClaim = await _operationClaimDal.GetAsync(o => o.Name == "user");
if (defaultOperationClaim is null)
{
defaultOperationClaim = new OperationClaim
{
Name = "user"
};
await _operationClaimDal.AddAsync(defaultOperationClaim);
}
await _userOperationClaimDal.AddAsync(new UserOperationClaim
{
UserId = user.Id,
OperationClaimId = defaultOperationClaim.Id
});
return(new SuccessResult(Messages.UserCreated));
}
public IResult Update(OperationClaim operationClaim)
{
_operationClaimDal.Update(operationClaim);
return(new SuccessResult(Messages.Successful));
}
//[ValidationAspect(typeof(OperationClaimValidator))]
public IResult Update(OperationClaim entity)
{
_userDal.Update(entity);
return(new SuccessResult(Messages.ItemUpdated));
}
/// <summary>
/// Creates a plugin from the given pluginDiscoveryResult.
/// This plugin's operations will be source agnostic ones (Authentication)
/// </summary>
/// <param name="pluginDiscoveryResult">plugin discovery result</param>
/// <param name="requestedOperationClaim">The requested operation claim</param>
/// <param name="cancellationToken">cancellation token</param>
/// <returns>A plugin creation result, null if the requested plugin cannot handle the given operation claim</returns>
public Task <Tuple <bool, PluginCreationResult> > TryGetSourceAgnosticPluginAsync(PluginDiscoveryResult pluginDiscoveryResult, OperationClaim requestedOperationClaim, CancellationToken cancellationToken)
{
if (pluginDiscoveryResult == null)
{
throw new ArgumentNullException(nameof(pluginDiscoveryResult));
}
return(TryCreatePluginAsync(
pluginDiscoveryResult,
requestedOperationClaim,
new PluginRequestKey(pluginDiscoveryResult.PluginFile.Path, "Source-Agnostic"),
packageSourceRepository: null,
serviceIndex: null,
cancellationToken: cancellationToken));
}
public IResult Delete(OperationClaim operationClaim)
{
_operationClaimDal.Delete(operationClaim);
return(new SuccessResult(Messages.OperationClaimDeleted));
}
public IResult Add(OperationClaim operationClaim)
{
_operationClaimDal.Add(operationClaim);
return(new SuccessResult(Messages.OperationClaimAdded));
}
/// <summary>
/// Creates a plugin from the discovered plugin.
/// We firstly check the cache for the operation claims for the given request key.
/// If there is a valid cache entry, and it does contain the requested operation claim, then we start the plugin, and if need be update the cache value itself.
/// If there is a valid cache entry, and it does NOT contain the requested operation claim, then we return a null.
/// If there is no valid cache entry or an invalid one, we start the plugin as normally, return an active plugin even if the requested claim is not available, and write a cache entry.
/// </summary>
/// <param name="result">plugin discovery result</param>
/// <param name="requestedOperationClaim">The requested operation claim</param>
/// <param name="requestKey">plugin request key</param>
/// <param name="packageSourceRepository">package source repository</param>
/// <param name="serviceIndex">service index</param>
/// <param name="cancellationToken">cancellation token</param>
/// <returns>A plugin creation result, null if the requested plugin cannot handle the given operation claim</returns>
private async Task <Tuple <bool, PluginCreationResult> > TryCreatePluginAsync(
PluginDiscoveryResult result,
OperationClaim requestedOperationClaim,
PluginRequestKey requestKey,
string packageSourceRepository,
JObject serviceIndex,
CancellationToken cancellationToken)
{
// This is a non cancellable task.
// We should only honor cancellation requests we can recover from.
// Once we have reached this part of the code, we do the plugin initialization
// handshake, operation claims, and shut down set up.
// If either one of these tasks fails then the plugin itself is not usable for the rest of the process.
// We could consider handling each of this operations more cleverly,
// but simplicity and readability is prioritized
cancellationToken = CancellationToken.None;
PluginCreationResult pluginCreationResult = null;
var cacheEntry = new PluginCacheEntry(_pluginsCacheDirectoryPath.Value, result.PluginFile.Path, requestKey.PackageSourceRepository);
ConcurrencyUtilities.ExecuteWithFileLocked(cacheEntry.CacheFileName, cacheEntry.LoadFromFile);
if (cacheEntry.OperationClaims == null || cacheEntry.OperationClaims.Contains(requestedOperationClaim))
{
try
{
if (result.PluginFile.State.Value == PluginFileState.Valid)
{
var plugin = await _pluginFactory.GetOrCreateAsync(
result.PluginFile.Path,
PluginConstants.PluginArguments,
new RequestHandlers(),
_connectionOptions,
cancellationToken);
var utilities = await PerformOneTimePluginInitializationAsync(plugin, cancellationToken);
// We still make the GetOperationClaims call even if we have the operation claims cached. This is a way to self-update the cache.
var operationClaims = await _pluginOperationClaims.GetOrAdd(
requestKey,
key => new Lazy <Task <IReadOnlyList <OperationClaim> > >(() =>
GetPluginOperationClaimsAsync(
plugin,
packageSourceRepository,
serviceIndex,
cancellationToken))).Value;
if (!EqualityUtility.SequenceEqualWithNullCheck(operationClaims, cacheEntry.OperationClaims))
{
cacheEntry.OperationClaims = operationClaims;
await utilities.Value.DoOncePerPluginLifetimeAsync(
nameof(PluginCacheEntry),
() => ConcurrencyUtilities.ExecuteWithFileLockedAsync(
cacheEntry.CacheFileName,
action: async lockedToken =>
{
await cacheEntry.UpdateCacheFileAsync();
return(Task.FromResult <object>(null));
},
token: cancellationToken),
cancellationToken);
}
pluginCreationResult = new PluginCreationResult(
plugin,
utilities.Value,
operationClaims);
}
else
{
pluginCreationResult = new PluginCreationResult(result.Message);
}
}
catch (Exception e)
{
pluginCreationResult = new PluginCreationResult(
string.Format(CultureInfo.CurrentCulture,
Strings.Plugin_ProblemStartingPlugin,
result.PluginFile.Path,
e.Message),
e);
}
}
return(new Tuple <bool, PluginCreationResult>(pluginCreationResult != null, pluginCreationResult));
}
public IResult Add(OperationClaim operationClaim)
{
_operationClaimDal.Add(operationClaim);
return(new SuccessResult());
}
public IResult Update(OperationClaim entity)
{
_operationClaimDal.Update(entity);
return(new SuccessResult(Messages.UpdateSuccess));
}
public IResult Add(OperationClaim entity)
{
_operationClaimDal.Add(entity);
return(new SuccessResult(Messages.AddedSuccess));
}
