/// <summary>
/// Prepare the given OperationContext for use with this CMIS profile.
/// </summary>
/// <param name="operationContext"></param>
public void ConfigureOperationContext(IOperationContext operationContext)
{
/*
Disabled because repository may generate error if the type is not Orderable for cmis:contentStreamFileName
Documentum generates such an error: https://github.com/aegif/CmisSync/issues/724
Alfresco also is not Orderable even though it does not generate an error:
http://stackoverflow.com/questions/39290294/check-whether-cmiscontentstreamfilename-is-orderable
if (IgnoreIfSameLowercaseNames)
{
// Depending on the CMIS profile, order by stream name or document name.
if (UseCmisStreamName && contentStreamFileNameOrderable)
{
operationContext.OrderBy = "cmis:contentStreamFileName";
}
else
{
operationContext.OrderBy = "cmis:name";
}
}
else
{
// Do not specify an order criteria, as we don't need it,
// and it might have a performance impact on the CMIS server.
}
*/
}
async Task<OperationResult> Process(TestStatelessUnreliable msg, IOperationContext arg2)
{
if (msg.SleepDurationMs > 0)
await Task.Delay(msg.SleepDurationMs);
return OperationResult.Success;
}
public void Process(SayS2S msg, IOperationContext context)
{
foreach (var roomMember in _roomMembers)
{
roomMember.CallbackChannel.Send(new RoomEvent() { Text = msg.Text, UserName = msg.UserName });
}
}
public Task<Message> Process(Func<IOperationContext, Task<Message>> next, IOperationContext operation)
{
var lockType = LockType.Write;
if (_lockConfig != null)
lockType = _lockConfig.GetLockType(operation.Message.GetType());
return _fiber.Call(() => next(operation), lockType);
}
void OnSay(Say msg, IOperationContext context)
{
if (_room != null)
{
_room.SendOneWay(new SayS2S(){UserName = _userName, Text = msg.Text}, context);
}
else throw new ProcessingException(SayErrors.NotConnectedToRoom);
}
public OperationContextOrgUnitContextStorage(IOperationContext operationContext)
{
_operationContext = operationContext;
// WCF operation context is null during app initialization.
// We don't need to store OU context during that stage anyway.
operationContextAvailable = _operationContext != null;
}
async Task<OperationResult> Process(PingGateway msg, IOperationContext context)
{
using (BackendCallsTimer.NewContext())
{
await Task.Delay(msg.SleepDurationMs);
return OperationResult.Success;
}
}
async Task OnSay(Say msg, IOperationContext context)
{
if (_room != null)
{
await _room.Say(new SayS2S() { UserName = _userName, Text = msg.Text });
}
else throw new ProcessingException(SayErrors.NotConnectedToRoom);
}
private void UpdateClientIp(LocationContext location, IOperationContext operation)
{
if ( operation.HasIncomingMessageProperty(RemoteEndpointMessageProperty.Name) )
{
var property = (RemoteEndpointMessageProperty)
operation.GetIncomingMessageProperty(RemoteEndpointMessageProperty.Name);
location.Ip = property.Address;
WcfEventSource.Log.LocationIdSet(location.Ip);
}
}
public static IEnumerable<int> FindAssociatedOrgUnitIds(int? organizationalUnitId, DescendantOption descentantOption, LinkedOption linkedOption, IOperationContext operationContext, ObjectContext objectContext)
{
return
AssociatedOrgUnitFinder.FindAssociatedOrgUnits(objectContext, new AssociatedOrgUnitsDto
{
OrganizationalUnitId = organizationalUnitId,
DescendantOption = descentantOption,
LinkedOption = linkedOption
});
}
static void OnSay(Say msg, IOperationContext context)
{
RoomMember member;
if (RoomMembers.TryGetValue(context.ReplyChannel, out member))
{
List<RoomMember> members;
if (Rooms.TryGetValue(member.RoomName, out members))
{
members.ForEach((m) => m.UserChannel.Send(new RoomEvent() { UserName = member.UserName, Text = msg.Text }));
}
}
}
/// <summary>
/// Initialize the telemetry event with the client IP if available
/// </summary>
/// <param name="telemetry">The telemetry event</param>
/// <param name="operation">The WCF operation context</param>
protected override void OnInitialize(ITelemetry telemetry, IOperationContext operation)
{
if ( String.IsNullOrEmpty(telemetry.Context.Location.Ip) )
{
var location = operation.Request.Context.Location;
if ( String.IsNullOrEmpty(location.Ip) )
{
UpdateClientIp(location, operation);
}
telemetry.Context.Location.Ip = location.Ip;
}
}
/// <summary>
/// Called when a telemetry item is available
/// </summary>
/// <param name="telemetry">The telemetry item to augment</param>
/// <param name="operation">The operation context</param>
protected override void OnInitialize(ITelemetry telemetry, IOperationContext operation)
{
var httpHeaders = operation.GetHttpRequestHeaders();
if ( httpHeaders != null )
{
var userAgent = httpHeaders.Headers["User-Agent"];
if ( !String.IsNullOrEmpty(userAgent) )
{
telemetry.Context.User.UserAgent = userAgent;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RemoteObjectFetcher"/> class.
/// Fetches remote CMIS Objects and adds them to the handled events.
/// </summary>
/// <param name="session">Session to be used.</param>
/// <param name="storage">Storage to look for mapped objects.</param>
public RemoteObjectFetcher(ISession session, IMetaDataStorage storage) {
if (session == null) {
throw new ArgumentNullException("session");
}
if (storage == null) {
throw new ArgumentNullException("storage");
}
this.session = session;
this.storage = storage;
this.operationContext = OperationContextFactory.CreateNonCachingPathIncludingContext(this.session);
}
public static IEnumerable<int> FindAssociatedOrgUnitIds(int? organizationalUnitId, DescendantOption descentantOption, LinkedOption linkedOption, IOperationContext operationContext, ObjectContext objectContext)
{
var key = string.Concat("AssociatedOrgUnitIds_", organizationalUnitId, "_", descentantOption, "_", linkedOption);
//return operationContext.FindOrCreate<IEnumerable<int>>(key, () =>
//{
return
AssociatedOrgUnitFinder.FindAssociatedOrgUnits(objectContext, new AssociatedOrgUnitsDto
{
OrganizationalUnitId = organizationalUnitId,
DescendantOption = descentantOption,
LinkedOption = linkedOption
});
//});
}
async public Task<JoinRoomResponse> Process(JoinRoomS2S request, IOperationContext context)
{
if (_roomMembers.Count >= MaxRoomSize)
return new JoinRoomResponse { RetCode = JoinRoomRetCode.RoomIsFull };
else
{
if (_roomMembers.Any(x => x.UserName == request.UserName))
return new JoinRoomResponse { RetCode = JoinRoomRetCode.NameIsTaken };
_state = await _stateManager.GetOrAddAsync<IReliableDictionary<string, DateTime>>(ActorRef.Key.Id);
try
{
var callbackChannel = await _node.ConnectToCallbackChannel(request.CallbackChannelRef);
callbackChannel.DisconnectedEvent
.Subscribe(_ =>
Fiber.Process(() =>
{
_roomMembers.RemoveAll(x => x.UserName == request.UserName);
var leaveNotification = new RoomEvent { Text = "User left", UserName = request.UserName };
foreach (var roomMember in _roomMembers)
{
roomMember.CallbackChannel.Send(leaveNotification);
}
if (_roomMembers.Count == 0)
Dispose();
}));
var joinNotification = new RoomEvent { Text = "User joined", UserName = request.UserName };
foreach (var roomMember in _roomMembers)
{
roomMember.CallbackChannel.Send(joinNotification);
}
_roomMembers.Add(new RoomMember { UserName = request.UserName, CallbackChannel = callbackChannel });
return new JoinRoomResponse { RetCode = JoinRoomRetCode.Ok };
}
catch (Exception)
{
return new JoinRoomResponse() { RetCode = JoinRoomRetCode.Retry };
}
}
}
private Mock <ISession> CreateSessionMock(IOperationContext result)
{
Mock <ISession> sessionMock = new Mock <ISession>();
sessionMock.Setup(s => s.CreateOperationContext(
It.IsAny <HashSet <string> >(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IncludeRelationshipsFlag>(),
It.IsAny <HashSet <string> >(),
It.IsAny <bool>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <int>())).Returns(result);
return(sessionMock);
}
public ResolverTaskDefinition(
IOperationContext operationContext,
IPreparedSelection selection,
int responseIndex,
ResultMap resultMap,
object?parent,
Path path,
IImmutableDictionary <string, object?> scopedContextData)
{
OperationContext = operationContext;
Selection = selection;
ResponseIndex = responseIndex;
ResultMap = resultMap;
Parent = parent;
Path = path;
ScopedContextData = scopedContextData;
}
/// <summary>
/// Executes the operation's logic.
/// </summary>
/// <param name="context">A reference to the operation context.</param>
protected override void Execute(IOperationContext context)
{
const byte FallbackIndex = 0xFF;
var inThingContainer = this.FromLocation.DecodeContainer(context.Map, context.ContainerManager, out byte index, this.FromCreature);
// Adjust index if this a map location.
var existingThing = (this.FromLocation.Type == LocationType.Map && (inThingContainer is ITile fromTile)) ? fromTile.FindItemWithTypeId(this.FromTypeId) : inThingContainer?.FindThingAtIndex(index);
if (existingThing == null || !(existingThing is IItem existingItem))
{
// Silent fail.
return;
}
IThing thingCreated = context.ItemFactory.Create(ItemCreationArguments.WithTypeId(this.ToTypeId));
if (thingCreated == null)
{
return;
}
// At this point, we have an item to change, and we were able to generate the new one, let's proceed.
(bool replaceSuccessful, IThing replaceRemainder) = inThingContainer.ReplaceContent(context.ItemFactory, existingThing, thingCreated, index, existingItem.Amount);
if (!replaceSuccessful || replaceRemainder != null)
{
context.GameApi.AddContentToContainerOrFallback(inThingContainer, ref replaceRemainder, FallbackIndex, includeTileAsFallback: true, this.GetRequestor(context.CreatureFinder));
}
if (replaceSuccessful)
{
if (inThingContainer is ITile atTile)
{
this.SendNotification(
context,
new TileUpdatedNotification(
() => context.Map.FindPlayersThatCanSee(atTile.Location),
atTile.Location,
context.MapDescriptor.DescribeTile));
// Evaluate if the new item triggers a collision.
// context.EventRulesApi.EvaluateRules(this, EventRuleType.Collision, new CollisionEventRuleArguments(fromCylinder.Location, existingThing, this.GetRequestor(context.CreatureFinder)));
}
}
}
/// <summary>
/// Crawl remote content, syncing down if needed.
/// Meanwhile, cache remoteFiles and remoteFolders, they are output parameters that are used in CrawlLocalFiles/CrawlLocalFolders
/// </summary>
private bool CrawlRemote(IFolder remoteFolder, string localFolder, IList <string> remoteFiles, IList <string> remoteFolders)
{
bool success = true;
SleepWhileSuspended();
// Get all remote children.
// TODO: use paging
IOperationContext operationContext = session.CreateOperationContext();
operationContext.MaxItemsPerPage = Int32.MaxValue;
foreach (ICmisObject cmisObject in remoteFolder.GetChildren(operationContext))
{
try
{
if (cmisObject is DotCMIS.Client.Impl.Folder)
{
// It is a CMIS folder.
IFolder remoteSubFolder = (IFolder)cmisObject;
CrawlRemoteFolder(remoteSubFolder, localFolder, remoteFolders);
}
else if (cmisObject is DotCMIS.Client.Impl.Document)
{
// It is a CMIS document.
IDocument remoteDocument = (IDocument)cmisObject;
CrawlRemoteDocument(remoteDocument, localFolder, remoteFiles);
}
else if (isLink(cmisObject))
{
Logger.Debug("Ignoring file '" + remoteFolder + "/" + cmisObject.Name + "' of type '" +
cmisObject.ObjectType.Description + "'. Links are not currently handled.");
}
else
{
Logger.Warn("Unknown object type: '" + cmisObject.ObjectType.Description + "' (" + cmisObject.ObjectType.DisplayName
+ ") for object " + remoteFolder + "/" + cmisObject.Name);
}
}
catch (CmisBaseException e)
{
ProcessRecoverableException("Could not access remote object: " + cmisObject.Name, e);
success = false;
}
}
return(success);
}
public override async Task DeleteAsync(IOperationDescription description, IOperationContext context)
{
Trace.WriteInfo(TraceType, "DeleteAsync called");
description.ThrowIfNull(nameof(description));
context.ThrowIfNull(nameof(context));
string errorMessage;
if (!this.ValidObjectType <ApplicationTypeVersionOperationDescription>(description, out errorMessage))
{
throw new InvalidCastException(errorMessage);
}
var appTypeDescription = (ApplicationTypeVersionOperationDescription)description;
try
{
Trace.WriteInfo(
TraceType,
"DeleteAsync: Unprovisioning application type. Name: {0}. Version: {1}. Timeout: {2}",
appTypeDescription.TypeName,
appTypeDescription.TypeVersion,
context.OperationTimeout);
await this.fabricClient.ApplicationManager.UnprovisionApplicationAsync(
appTypeDescription.TypeName,
appTypeDescription.TypeVersion,
context.OperationTimeout,
context.CancellationToken);
Trace.WriteInfo(TraceType, "DeleteAsync: Unprovisioning call accepted");
}
catch (FabricElementNotFoundException nfe)
{
if (nfe.ErrorCode == FabricErrorCode.ApplicationTypeNotFound)
{
Trace.WriteInfo(
TraceType,
"DeleteAsync: Application type not found. Name: {0}. Version: {1}",
appTypeDescription.TypeName,
appTypeDescription.TypeVersion);
return;
}
throw;
}
}
/// <summary>
/// Called when a telemetry item is available
/// </summary>
/// <param name="telemetry">The telemetry item to augment</param>
/// <param name="operation">The operation context</param>
protected override void OnInitialize(ITelemetry telemetry, IOperationContext operation)
{
var ctxt = telemetry.Context.Operation;
if (String.IsNullOrEmpty(ctxt.Name))
{
// TODO: consider including the HTTP verb
// if service is using WebHttpBinding.
ctxt.Name = operation.ContractName + '.' + operation.OperationName;
}
RequestTelemetry request = telemetry as RequestTelemetry;
if (request != null)
{
request.Name = ctxt.Name;
}
}
/*--------------------------------------------------------------------------------------------*/
public static void ClearOldTokens(IOperationContext pOpCtx, long pMemberId)
{
pOpCtx.Cache.Memory.RemoveOauthMembers(pMemberId);
//OPTIMIZE: delete old OauthAccess vertices, or filter the Member->OauthAccess edges?
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, pMemberId)
.AuthenticatedByOauthAccesses.ToOauthAccess
.SideEffect(
new WeaverStatementRemoveProperty <OauthAccess>(x => x.Token),
new WeaverStatementRemoveProperty <OauthAccess>(x => x.Refresh)
)
.ToQuery();
pOpCtx.Data.Execute(q, "OauthAccess-ClearOldTokens");
}
public static async Task ExecuteTasksAsync(
IOperationContext operationContext)
{
if (operationContext.Execution.TaskBacklog.IsEmpty)
{
return;
}
var proposedTaskCount = operationContext.Operation.ProposedTaskCount;
if (proposedTaskCount == 1)
{
await ExecuteResolversAsync(
operationContext.Execution,
HandleError,
operationContext.RequestAborted);
}
else
{
var tasks = new Task[proposedTaskCount];
for (var i = 0; i < proposedTaskCount; i++)
{
tasks[i] = ExecuteResolversAsync(
operationContext.Execution,
HandleError,
operationContext.RequestAborted);
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
void HandleError(Exception exception)
{
IError error =
operationContext.ErrorHandler
.CreateUnexpectedError(exception)
.SetCode(ErrorCodes.Execution.TaskProcessingError)
.Build();
error = operationContext.ErrorHandler.Handle(error);
// TODO : this error needs to be reported!
operationContext.Result.AddError(error);
}
}
private static bool TryCompleteListValue(
IOperationContext operationContext,
MiddlewareContext resolverContext,
ISelection selection,
Path path,
IType fieldType,
string responseName,
int responseIndex,
object?result,
List <ResolverTask> bufferedTasks,
out object?completedValue)
{
IType elementType = fieldType.InnerType();
if (elementType.Kind is TypeKind.NonNull)
{
elementType = elementType.InnerType();
}
if (elementType.Kind is TypeKind.Object or TypeKind.Interface or TypeKind.Union)
{
return(TryCompleteCompositeListValue(
operationContext,
resolverContext,
selection,
path,
fieldType,
responseName,
responseIndex,
result,
bufferedTasks,
out completedValue));
}
return(TryCompleteOtherListValue(
operationContext,
resolverContext,
selection,
path,
fieldType,
responseName,
responseIndex,
result,
bufferedTasks,
out completedValue));
}
public AdvancedViewModel(ILumiaSettingsService lumiaSettingsService, IFileSystemOperations fileSystemOperations,
UIServices uiServices, IDeploymentContext context, IOperationContext operationContext,
IList <Meta <IDiskLayoutPreparer> > diskPreparers,
IWindowsDeployer deployer,
ILogCollector logCollector,
IOperationProgress progress)
{
this.lumiaSettingsService = lumiaSettingsService;
this.uiServices = uiServices;
this.context = context;
this.deployer = deployer;
this.logCollector = logCollector;
this.progress = progress;
DiskPreparers = diskPreparers;
DeleteDownloadedWrapper = new CommandWrapper <Unit, Unit>(this,
ReactiveCommand.CreateFromTask(() => DeleteDownloaded(fileSystemOperations)), uiServices.ContextDialog, operationContext);
ForceDualBootWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(ForceDualBoot),
uiServices.ContextDialog, operationContext);
ForceSingleBootWrapper = new CommandWrapper <Unit, Unit>(this,
ReactiveCommand.CreateFromTask(ForceDisableDualBoot), uiServices.ContextDialog, operationContext);
BackupCommandWrapper =
new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(Backup), uiServices.ContextDialog, operationContext);
RestoreCommandWrapper =
new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(Restore), uiServices.ContextDialog, operationContext);
CollectLogsCommmandWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(CollectLogs), uiServices.ContextDialog, operationContext);
IsBusyObservable = Observable.Merge(DeleteDownloadedWrapper.Command.IsExecuting,
BackupCommandWrapper.Command.IsExecuting, RestoreCommandWrapper.Command.IsExecuting,
ForceDualBootWrapper.Command.IsExecuting, ForceSingleBootWrapper.Command.IsExecuting,
CollectLogsCommmandWrapper.Command.IsExecuting);
preparerUpdater = this.WhenAnyValue(x => x.SelectedPreparer)
.Where(x => x != null)
.Subscribe(x =>
{
context.DiskLayoutPreparer = x.Value;
lumiaSettingsService.DiskPreparer = (string)x.Metadata["Name"];
});
SelectedPreparer = GetInitialDiskPreparer();
}
/// <inheritdoc/>
public async Task CloseAsync(IOperationContext operationContext, IResultContext context)
{
// Here, if the file in the user file system is modified (not in-sync), you will send the file content,
// creation time, modification time and attributes to the remote storage.
// We also send ETag, to make sure the changes on the server, if any, are not overwritten.
Logger.LogMessage("IFile.CloseAsync()", UserFileSystemPath);
string userFileSystemFilePath = UserFileSystemPath;
// In case the file is moved it does not exist in user file system when CloseAsync() is called.
if (Engine.ChangesProcessingEnabled &&
FsPath.Exists(userFileSystemFilePath) &&
!FsPath.AvoidSync(userFileSystemFilePath))
{
// In case the file is overwritten it is converted to a regular file prior to CloseAsync().
// we need to convert it back into file/folder placeholder.
if (!PlaceholderItem.IsPlaceholder(userFileSystemFilePath))
{
PlaceholderItem.ConvertToPlaceholder(userFileSystemFilePath, false);
Logger.LogMessage("Converted to placeholder", userFileSystemFilePath);
}
try
{
if (PlaceholderItem.GetItem(userFileSystemFilePath).IsNew(VirtualDrive))
{
// Create new file in the remote storage.
await new RemoteStorageRawItem <IVirtualFile>(userFileSystemFilePath, VirtualDrive, Logger).CreateAsync();
}
else if (!PlaceholderItem.GetItem(userFileSystemFilePath).IsMoved())
{
// Send content to remote storage. Unlock if auto-locked.
await new RemoteStorageRawItem <IVirtualFile>(userFileSystemFilePath, VirtualDrive, Logger).UpdateAsync();
}
}
catch (IOException ex)
{
// Either the file is already being synced in another thread or client or server file is blocked by concurrent process.
// This is a normal behaviour.
// The file must be synched by your synchronyzation service at a later time, when the file becomes available.
Logger.LogMessage("Failed to upload file. Possibly in use by an application or blocked for synchronization in another thread:", ex.Message);
}
}
}
public void TestUpdateProperties()
{
string name1 = "port-test-folder1";
string name2 = "port-test-folder2";
string name3 = "port-test-folder3";
IOperationContext oc = Session.CreateOperationContext();
oc.CacheEnabled = false;
IFolder newFolder = null;
try
{
// create folder
IFolder root = Session.GetRootFolder();
newFolder = CreateFolder(root, name1);
Assert.IsNotNull(newFolder);
IFolder newFolder2 = (IFolder)Session.GetObject(newFolder, oc);
Assert.IsNotNull(newFolder2);
Assert.IsNotNull(name1, newFolder2.Name);
IDictionary<string, object> updateProps = new Dictionary<string, object>();
updateProps[PropertyIds.Name] = name2;
newFolder2.UpdateProperties(updateProps);
IFolder newFolder3 = (IFolder)Session.GetObject(newFolder, oc);
Assert.IsNotNull(newFolder3);
Assert.IsNotNull(name2, newFolder3.Name);
newFolder3.Rename(name3);
IFolder newFolder4 = (IFolder)Session.GetObject(newFolder, oc);
Assert.IsNotNull(newFolder4);
Assert.IsNotNull(name3, newFolder4.Name);
}
finally
{
if (newFolder != null)
{
newFolder.DeleteTree(true, UnfileObject.Delete, true);
Assert.IsFalse(Session.Exists(newFolder));
}
}
}
public AlfrescoService()
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters[DotCMIS.SessionParameter.BindingType] = BindingType.AtomPub;
parameters[DotCMIS.SessionParameter.AtomPubUrl] = "http://*****:*****@sw0rd12";
SessionFactory factory = SessionFactory.NewInstance();
IList <IRepository> repos = factory.GetRepositories(parameters);
session = repos.ElementAt(0).CreateSession();
operationContext = session.CreateOperationContext();
operationContext.IncludeAcls = false;
}
/// <summary cref="NodeSource.ReadAttribute" />
protected override ServiceResult ReadAttribute(IOperationContext context, uint attributeId, DataValue value)
{
switch (attributeId)
{
case Attributes.EventNotifier:
{
value.Value = EventNotifier;
break;
}
default:
{
return(base.ReadAttribute(context, attributeId, value));
}
}
return(ServiceResult.Good);
}
private string GetHeader(IOperationContext context, string httpHeader, string soapHeader)
{
if (this.RequestAlreadyChecked(context))
{
return(null);
}
var httpHeaders = context.GetHttpRequestHeaders();
if (httpHeaders != null)
{
return(httpHeaders.Headers[httpHeader]);
}
else
{
return(context.GetIncomingMessageHeader <string>(soapHeader, this.SoapHeaderNamespace));
}
}
void ProcessCallbackMessage(IOperationContext operation)
{
var callbackHeader = operation.Message.GetHeader <CallbackHeader>();
if (callbackHeader != null)
{
INetChannel callbackChannel;
if (_callbackChannels.TryGetValue(callbackHeader.CallbackChannelId, out callbackChannel))
{
operation.Message.RemoveHeader <CallbackHeader>();
callbackChannel.Send(operation.Message);
}
else
{
operation.ReplyChannel.Send(new CallbackChannelDisconnected(callbackHeader.CallbackChannelId));
}
}
}
/// <summary>
/// Delete the container with the specified name if it exists.
/// </summary>
/// <param name="containerName">Name of container to delete.</param>
public async Task DeleteContainerAsync(string containerName)
{
using (IOperationContext azOp = L.Begin("Delete Azure Storage container"))
{
try
{
CloudBlobClient client = GetCloudBlobClient();
CloudBlobContainer container = client.GetContainerReference(containerName);
await container.DeleteIfExistsAsync();
azOp.Complete();
}
catch (Exception e)
{
L.Error(e, "Exception throw deleting Azure Storage container {c}.", containerName);
}
}
}
/// <summary>
/// Executes the operation's logic.
/// </summary>
/// <param name="context">A reference to the operation context.</param>
protected override void Execute(IOperationContext context)
{
// Perform the actual, internal turn.
this.Creature.Direction = this.Direction;
// Send the notification if applicable.
if (context.Map.GetTileAt(this.Creature.Location, out ITile playerTile))
{
var playerStackPos = playerTile.GetStackOrderOfThing(this.Creature);
this.SendNotification(
context,
new CreatureTurnedNotification(
() => context.Map.PlayersThatCanSee(this.Creature.Location),
this.Creature,
playerStackPos));
}
}
public static bool TryComplete(
IOperationContext operationContext,
IMiddlewareContext middlewareContext,
Path path,
IType fieldType,
object?result,
out object?completedResult)
{
if (fieldType.IsNonNullType())
{
if (TryComplete(
operationContext,
middlewareContext,
path,
fieldType.InnerType(),
result,
out completedResult) &&
completedResult is { })
/// <inheritdoc />
public void Run(IOperationContext operationContext)
{
if (operationContext.CurrentSubpath == null)
{
return;
}
var controlPoint2 = operationContext.CurrentTransformationMatrix.Transform(new PdfPoint(X2, Y2));
var end = operationContext.CurrentTransformationMatrix.Transform(new PdfPoint(X3, Y3));
operationContext.CurrentSubpath.BezierCurveTo(operationContext.CurrentPosition.X,
operationContext.CurrentPosition.Y,
controlPoint2.X,
controlPoint2.Y,
end.X,
end.Y);
operationContext.CurrentPosition = end;
}
/// <summary>
/// Called when a telemetry item is available
/// </summary>
/// <param name="telemetry">The telemetry item to augment</param>
/// <param name="operation">The operation context</param>
protected override void OnInitialize(ITelemetry telemetry, IOperationContext operation)
{
if (String.IsNullOrEmpty(telemetry.Context.Operation.Name))
{
var opContext = operation.Request.Context.Operation;
if (String.IsNullOrEmpty(opContext.Name))
{
UpdateOperationContext(operation, opContext);
}
telemetry.Context.Operation.Name = opContext.Name;
RequestTelemetry request = telemetry as RequestTelemetry;
if (request != null)
{
request.Name = opContext.Name;
}
}
}
/// <inheritdoc/>
public async Task GetChildrenAsync(string pattern, IOperationContext operationContext, IFolderListingResultContext resultContext)
{
Logger.LogMessage($"{nameof(IFolder)}.{nameof(GetChildrenAsync)}({pattern})", UserFileSystemPath);
IEnumerable <FileSystemInfo> remoteStorageChildren = new DirectoryInfo(RemoteStoragePath).EnumerateFileSystemInfos(pattern);
List <IFileSystemItemMetadata> userFileSystemChildren = new List <IFileSystemItemMetadata>();
foreach (FileSystemInfo remoteStorageItem in remoteStorageChildren)
{
IFileSystemItemMetadata itemInfo = Mapping.GetUserFileSysteItemMetadata(remoteStorageItem);
userFileSystemChildren.Add(itemInfo);
}
// To signal that the children enumeration is completed
// always call ReturnChildren(), even if the folder is empty.
resultContext.ReturnChildren(userFileSystemChildren.ToArray(), userFileSystemChildren.Count);
}
///<inheritdoc>
public async Task MoveToAsync(string userFileSystemNewPath, IOperationContext operationContext, IConfirmationResultContext resultContext)
{
string userFileSystemOldPath = this.UserFileSystemPath;
Logger.LogMessage($"{nameof(IFileSystemItem)}.{nameof(MoveToAsync)}()", UserFileSystemPath, userFileSystemNewPath);
string remoteStorageNewPath = Mapping.MapPath(userFileSystemNewPath);
string remoteStorageOldPath = RemoteStoragePath;
if (File.Exists(RemoteStoragePath))
{
new FileInfo(RemoteStoragePath).MoveTo(remoteStorageNewPath);
}
else if (Directory.Exists(RemoteStoragePath))
{
new DirectoryInfo(RemoteStoragePath).MoveTo(remoteStorageNewPath);
}
Logger.LogMessage("Moved item in remote storage succesefully", userFileSystemOldPath, userFileSystemNewPath);
}
/// <summary>
/// Executes the operation's logic.
/// </summary>
/// <param name="context">A reference to the operation context.</param>
protected override void Execute(IOperationContext context)
{
var targetLoginLocation = this.playerMetadata.LastLocation;
if (context.Map[targetLoginLocation] == null)
{
targetLoginLocation = this.playerMetadata.StartingLocation;
}
var creationArguments = new PlayerCreationArguments()
{
Type = CreatureType.Player,
Metadata = this.playerMetadata,
PreselectedId = this.preselectedPlayerId,
};
if (!(context.CreatureFactory.CreateCreature(creationArguments) is IPlayer player))
{
context.Logger.LogWarning($"Unable to create player instance for {this.playerMetadata.Name}, aborting log in.");
return;
}
if (!context.GameApi.AddCreatureToGame(targetLoginLocation, player))
{
// Unable to place the player in the map.
var disconnectNotification = new DisconnectNotification(
player.YieldSingleItem(),
"Your character could not be placed on the map.\nPlease try again, or contact an administrator if the issue persists.");
context.GameApi.SendNotification(disconnectNotification);
return;
}
var descriptionTiles = context.Map.DescribeAt(player, player.Location);
// TODO: In addition, we need to send the player's inventory, the first time login message + outfit window here if applicable.
// And any VIP records here.
this.SendNotification(context, new PlayerLoginNotification(player, player.Location, descriptionTiles, AnimatedEffect.BubbleBlue));
this.SendNotification(context, new WorldLightChangedNotification(player.YieldSingleItem(), this.currentWorldLightLevel, this.currentWorldLightColor));
this.SendNotification(context, new CreatureLightUpdateNotification(player.YieldSingleItem(), player));
this.SendNotification(context, new TextMessageNotification(player.YieldSingleItem(), MessageType.Status, "This is a test message"));
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
IOperationContext context = WcfOperationContext.Current;
if (context != null)
{
WcfOperationContext.StoreThreadContext(context);
if (!this.LogTelemetryFor(context))
{
WcfEventSource.Log.OperationIgnored(context.ContractName, context.ContractNamespace, context.OperationName);
return(null);
}
foreach (var mod in this.GetModules())
{
Executor.ExceptionSafe(
mod.GetType().Name,
"OnBeginRequest",
mod.OnBeginRequest,
context);
}
foreach (var mod in this.GetModules())
{
var tracer = mod as IWcfMessageTrace;
if (tracer != null)
{
Executor.ExceptionSafe(
mod.GetType().Name,
"OnTraceRequest",
tracer.OnTraceRequest,
context,
ref request);
}
}
}
else
{
WcfEventSource.Log.NoOperationContextFound();
}
return(null);
}
/// <inheritdoc/>
public async Task CloseAsync(IOperationContext operationContext, IResultContext context)
{
// Here, if the file in user file system is modified (not in-sync), we send file content,
// creation time, modification time and attributes to remote storage.
// We also create new ETag, associate it with a file in user file system and send it to the server.
LogMessage("IFile.CloseAsync()", this.FullPath);
string userFileSystemFilePath = this.FullPath;
// In case the file is moved it does not exist in user file system when Close() is called.
if (!FsPath.Exists(userFileSystemFilePath) || FsPath.AvoidSync(userFileSystemFilePath))
{
return;
}
// In case the file is overwritten it is converted to a regular file prior to Close().
// we need to convert it back into file/folder placeholder.
if (!PlaceholderItem.IsPlaceholder(userFileSystemFilePath))
{
PlaceholderItem.ConvertToPlaceholder(userFileSystemFilePath, false);
LogMessage("Converted to placeholder:", userFileSystemFilePath);
}
if (!PlaceholderItem.GetItem(userFileSystemFilePath).GetInSync())
{
LogMessage("Changed:", userFileSystemFilePath);
string remoteStorageFilePath = Mapping.MapPath(userFileSystemFilePath);
try
{
await new RemoteStorageItem(remoteStorageFilePath).UpdateAsync(userFileSystemFilePath);
LogMessage("Updated succesefully:", remoteStorageFilePath);
}
catch (IOException ex)
{
// Either the file is already being synced in another thread or client or server file is blocked by concurrent process.
// This is a normal behaviour.
// The file must be synched by your synchronyzation service at a later time, when the file becomes available.
LogMessage("Failed to upload file. Possibly in use by an application or blocked for synchronization in another thread:", ex.Message);
}
}
}
void IWcfTelemetryModule.OnEndRequest(IOperationContext operation, Message reply)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (telemetryClient == null)
{
return;
}
RequestTelemetry telemetry = operation.Request;
telemetry.Stop();
// make some assumptions
bool isFault = false;
HttpStatusCode responseCode = HttpStatusCode.OK;
if (reply != null)
{
isFault = reply.IsFault;
}
HttpResponseMessageProperty httpHeaders = operation.GetHttpResponseHeaders();
if (httpHeaders != null)
{
responseCode = httpHeaders.StatusCode;
if ((int)responseCode >= 400)
{
isFault = true;
}
}
else if (isFault)
{
responseCode = HttpStatusCode.InternalServerError;
}
telemetry.Success = !isFault;
telemetry.ResponseCode = responseCode.ToString("d");
telemetry.Properties.Add("Protocol", telemetry.Url.Scheme);
telemetryClient.TrackRequest(telemetry);
}
/// <inheritdoc/>
public async Task GetChildrenAsync(string pattern, IOperationContext operationContext, IFolderListingResultContext resultContext)
{
// This method has a 60 sec timeout.
// To process longer requests and reset the timout timer call one of the following:
// - resultContext.ReturnChildren() method.
// - resultContext.ReportProgress() method.
Logger.LogMessage($"IFolder.GetChildrenAsync({pattern})", UserFileSystemPath);
IEnumerable <FileSystemItemBasicInfo> children = await new UserFolder(UserFileSystemPath).EnumerateChildrenAsync(pattern);
// Filtering existing files/folders. This is only required to avoid extra errors in the log.
List <IFileSystemItemBasicInfo> newChildren = new List <IFileSystemItemBasicInfo>();
foreach (IFileSystemItemBasicInfo child in children)
{
string userFileSystemItemPath = Path.Combine(UserFileSystemPath, child.Name);
if (!FsPath.Exists(userFileSystemItemPath))
{
Logger.LogMessage("Creating", child.Name);
newChildren.Add(child);
}
}
// To signal that the children enumeration is completed
// always call ReturnChildren(), even if the folder is empty.
resultContext.ReturnChildren(newChildren.ToArray(), newChildren.Count());
// Save ETags and set "locked by another user" icon.
foreach (FileSystemItemBasicInfo child in children)
{
string userFileSystemItemPath = Path.Combine(UserFileSystemPath, child.Name);
// Create ETags.
// ETags must correspond with a server file/folder, NOT with a client placeholder.
// It should NOT be moved/deleted/updated when a placeholder in the user file system is moved/deleted/updated.
// It should be moved/deleted when a file/folder in the remote storage is moved/deleted.
ETag.SetETagAsync(userFileSystemItemPath, child.ETag);
// Set the lock icon and read-only attribute, to indicate that the item is locked by another user.
new UserFileSystemRawItem(userFileSystemItemPath).SetLockedByAnotherUserAsync(child.LockedByAnotherUser);
}
}
public void TestQuery()
{
if (Session.RepositoryInfo.Capabilities.QueryCapability == CapabilityQuery.None)
{
return;
}
foreach (IQueryResult qr in Session.Query("SELECT * FROM cmis:document", false))
{
Assert.IsNotNull(qr);
Assert.IsNotNull(qr.GetPropertyValueByQueryName(PropertyIds.ObjectId));
Assert.IsNotNull(qr.GetPropertyValueByQueryName(PropertyIds.Name));
}
int count = 0;
foreach (IQueryResult qr in Session.Query("SELECT * FROM cmis:folder", false))
{
Assert.IsNotNull(qr);
Assert.IsNotNull(qr.GetPropertyValueByQueryName(PropertyIds.ObjectId));
Assert.IsNotNull(qr.GetPropertyValueByQueryName(PropertyIds.Name));
count++;
}
Assert.IsTrue(count > 0);
IOperationContext oc = OperationContextUtils.CreateMinimumOperationContext(PropertyIds.ObjectTypeId, PropertyIds.Name);
IFolder rootFolder = Session.GetRootFolder(oc);
bool found = false;
foreach (ICmisObject obj in Session.QueryObjects("cmis:folder", null, false, oc))
{
Assert.IsNotNull(obj.Id);
Assert.IsNotNull(obj.Name);
if (obj.Id == rootFolder.Id)
{
found = true;
}
}
Assert.IsTrue(found);
}
/// <summary>
/// Executes the operation's logic.
/// </summary>
/// <param name="context">A reference to the operation context.</param>
protected override void Execute(IOperationContext context)
{
context.Scheduler.CancelAllFor(this.Creature.Id, this.TypeToCancel);
if (this.Creature is IPlayer player)
{
if (this.TypeToCancel == typeof(IOperation) && player is ICombatant playerAsCombatant)
{
playerAsCombatant.SetAttackTarget(null);
}
this.SendNotification(
context,
new GenericNotification(
() => player.YieldSingleItem(),
new PlayerCancelAttackPacket(),
new PlayerCancelWalkPacket(this.Creature.Direction.GetClientSafeDirection())));
}
}
async Task<JoinRoomResponse> OnRoomJoin(JoinRoom msg, IOperationContext context)
{
var room = await _rooms.GetActor(new ActorKey(msg.RoomName));
var callbackRef = _callbacksNode.ExposeAsCallbackChannel(this);
var joinRoomOnServer = new JoinRoomS2S()
{
CallbackChannelRef = callbackRef,
RoomName = msg.RoomName,
UserName = msg.UserName
};
var reply = await room.SendAsync<JoinRoomResponse>(joinRoomOnServer, context);
if (reply.RetCode == JoinRoomRetCode.Ok)
{
_room = room;
_userName = msg.UserName;
}
return reply;
}
public Task<Message> Process(Func<IOperationContext, Task<Message>> next, IOperationContext context)
{
Func<IOperationContext, Task<Message>> handler;
if (_messageHandlingConfig.TryGetHandlerFor(context.Message.GetType(), out handler))
{
return handler(context);
}
else if (next != null)
{
return next(context);
}
else if (_throwIfUnhandled)
{
throw new ProcessingException(BasicErrorCode.DispatcherFuncNotFound);
}
else
{
return Task.FromResult<Message>(null);
}
}
async Task<JoinRoomResponse> OnRoomJoin(JoinRoom msg, IOperationContext context)
{
var room = ActorProxy.Create<ISFRoomActor>(new ActorId(msg.RoomName));
await room.SubscribeAsync(this);
var joinRoomOnServer = new JoinRoomS2S()
{
RoomName = msg.RoomName,
UserName = msg.UserName
};
var reply = await room.JoinRoom(joinRoomOnServer);
if (reply.RetCode == JoinRoomRetCode.Ok)
{
_room = room;
_userName = msg.UserName;
}
return reply;
}
void IWcfTelemetryModule.OnError(IOperationContext operation, Exception error)
{
if ( operation == null )
throw new ArgumentNullException("operation");
if ( error == null )
throw new ArgumentNullException("error");
if ( telemetryClient == null )
return;
ExceptionTelemetry telemetry = new ExceptionTelemetry(error);
if ( error is FaultException )
{
telemetry.SeverityLevel = SeverityLevel.Error;
telemetry.HandledAt = ExceptionHandledAt.UserCode;
} else
{
telemetry.SeverityLevel = SeverityLevel.Critical;
telemetry.HandledAt = ExceptionHandledAt.Platform;
}
telemetryClient.TrackException(error);
}
public IDocument GetObjectOfLatestVersion(bool major, IOperationContext context)
{
string objectId;
string versionSeriesId;
Lock();
try
{
objectId = ObjectId;
versionSeriesId = VersionSeriesId;
}
finally
{
Unlock();
}
if (versionSeriesId == null)
{
throw new CmisRuntimeException("Version series id is unknown!");
}
IObjectData objectData = Binding.GetVersioningService().GetObjectOfLatestVersion(RepositoryId, objectId, versionSeriesId, major,
context.FilterString, context.IncludeAllowableActions, context.IncludeRelationships, context.RenditionFilterString,
context.IncludePolicies, context.IncludeAcls, null);
IDocument result = Session.ObjectFactory.ConvertObject(objectData, context) as IDocument;
if (result == null)
{
throw new CmisRuntimeException("Latest version is not a document!");
}
return result;
}
public IList<IDocument> GetAllVersions(IOperationContext context)
{
string objectId;
string versionSeriesId;
Lock();
try
{
objectId = ObjectId;
versionSeriesId = VersionSeriesId;
}
finally
{
Unlock();
}
IList<IObjectData> versions = Binding.GetVersioningService().GetAllVersions(RepositoryId, objectId, versionSeriesId,
context.FilterString, context.IncludeAllowableActions, null);
IObjectFactory of = Session.ObjectFactory;
IList<IDocument> result = new List<IDocument>();
if (versions != null)
{
foreach (IObjectData objectData in versions)
{
IDocument doc = of.ConvertObject(objectData, context) as IDocument;
if (doc == null)
{
// should not happen...
continue;
}
result.Add(doc);
}
}
return result;
}
protected void Initialize(ISession session, IObjectType objectType, IObjectData objectData, IOperationContext context)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
if (objectType == null)
{
throw new ArgumentNullException("objectType");
}
if (objectType.PropertyDefinitions == null || objectType.PropertyDefinitions.Count < 9)
{
// there must be at least the 9 standard properties that all objects have
throw new ArgumentException("Object type must have property defintions!");
}
this.Session = session;
this.objectType = objectType;
this.extensions = new Dictionary<ExtensionLevel, IList<ICmisExtensionElement>>();
this.CreationContext = new OperationContext(context);
this.RefreshTimestamp = DateTime.UtcNow;
IObjectFactory of = Session.ObjectFactory;
if (objectData != null)
{
// handle properties
if (objectData.Properties != null)
{
properties = of.ConvertProperties(objectType, objectData.Properties);
extensions[ExtensionLevel.Properties] = objectData.Properties.Extensions;
}
// handle allowable actions
if (objectData.AllowableActions != null)
{
allowableActions = objectData.AllowableActions;
extensions[ExtensionLevel.AllowableActions] = objectData.AllowableActions.Extensions;
}
// handle renditions
if (objectData.Renditions != null)
{
renditions = new List<IRendition>();
foreach (IRenditionData rd in objectData.Renditions)
{
renditions.Add(of.ConvertRendition(Id, rd));
}
}
// handle ACL
if (objectData.Acl != null)
{
acl = objectData.Acl;
extensions[ExtensionLevel.Acl] = objectData.Acl.Extensions;
}
// handle policies
if (objectData.PolicyIds != null && objectData.PolicyIds.PolicyIds != null)
{
policies = new List<IPolicy>();
foreach (string pid in objectData.PolicyIds.PolicyIds)
{
IPolicy policy = Session.GetObject(Session.CreateObjectId(pid)) as IPolicy;
if (policy != null)
{
policies.Add(policy);
}
}
extensions[ExtensionLevel.Policies] = objectData.PolicyIds.Extensions;
}
// handle relationships
if (objectData.Relationships != null)
{
relationships = new List<IRelationship>();
foreach (IObjectData rod in objectData.Relationships)
{
IRelationship relationship = of.ConvertObject(rod, CreationContext) as IRelationship;
if (relationship != null)
{
relationships.Add(relationship);
}
}
}
extensions[ExtensionLevel.Object] = objectData.Extensions;
}
}
// operations
public IDocument Copy(IObjectId targetFolderId, IDictionary<string, object> properties, VersioningState? versioningState,
IList<IPolicy> policies, IList<IAce> addAces, IList<IAce> removeAces, IOperationContext context)
{
IObjectId newId = Session.CreateDocumentFromSource(this, properties, targetFolderId, versioningState, policies, addAces, removeAces);
// if no context is provided the object will not be fetched
if (context == null || newId == null)
{
return null;
}
// get the new object
IDocument newDoc = Session.GetObject(newId, context) as IDocument;
if (newDoc == null)
{
throw new CmisRuntimeException("Newly created object is not a document! New id: " + newId);
}
return newDoc;
}
public Document(ISession session, IObjectType objectType, IObjectData objectData, IOperationContext context)
{
Initialize(session, objectType, objectData, context);
}
public IDocument GetRenditionDocument(IOperationContext context)
{
if (RenditionDocumentId == null)
{
return null;
}
return session.GetObject(session.CreateObjectId(RenditionDocumentId), context) as IDocument;
}
public ICmisObject GetTarget(IOperationContext context)
{
Lock();
try
{
IObjectId targetId = TargetId;
if (targetId == null)
{
return null;
}
return Session.GetObject(targetId, context);
}
finally
{
Unlock();
}
}
public ICmisObject GetSource(IOperationContext context)
{
Lock();
try
{
IObjectId sourceId = SourceId;
if (sourceId == null)
{
return null;
}
return Session.GetObject(sourceId, context);
}
finally
{
Unlock();
}
}
public Relationship(ISession session, IObjectType objectType, IObjectData objectData, IOperationContext context)
{
Initialize(session, objectType, objectData, context);
}
async Task<OperationResult> Process(TestStateful msg, IOperationContext arg2)
{
using (var trans = _stateManager.CreateTransaction())
{
_state = await _stateManager.GetOrAddAsync<IReliableDictionary<string, DateTime>>(ActorRef.Key.Id);
await _state.AddOrUpdateAsync(trans, ActorRef.Key.Id, (x) => DateTime.UtcNow, (x, _) => DateTime.UtcNow);
await trans.CommitAsync();
}
return OperationResult.Success;
}
