/
StorageActionsAccessor.cs
133 lines (116 loc) · 3.07 KB
/
StorageActionsAccessor.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
//-----------------------------------------------------------------------
// <copyright file="StorageActionsAccessor.cs" company="Hibernating Rhinos LTD">
// Copyright (c) Hibernating Rhinos LTD. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Raven.Abstractions;
using Raven.Abstractions.Exceptions;
using Raven.Abstractions.MEF;
using Raven.Database;
using Raven.Database.Impl;
using Raven.Database.Plugins;
using Raven.Database.Storage;
using Raven.Database.Tasks;
using Raven.Storage.Managed.Impl;
using System.Linq;
namespace Raven.Storage.Managed
{
public class StorageActionsAccessor : IStorageActionsAccessor
{
readonly DateTime createdAt = SystemTime.UtcNow;
public StorageActionsAccessor(TableStorage storage, IUuidGenerator generator, OrderedPartCollection<AbstractDocumentCodec> documentCodecs, IDocumentCacher documentCacher)
{
General = new GeneralStorageActions(storage);
Attachments = new AttachmentsStorageActions(storage, generator);
Transactions = new TransactionStorageActions(storage, generator, documentCodecs);
Documents = new DocumentsStorageActions(storage, Transactions, generator, documentCodecs, documentCacher);
Indexing = new IndexingStorageActions(storage);
MappedResults = new MappedResultsStorageAction(storage, generator);
Queue = new QueueStorageActions(storage, generator);
Tasks = new TasksStorageActions(storage, generator);
Staleness = new StalenessStorageActions(storage);
}
public ITransactionStorageActions Transactions
{
get;
private set;
}
public IDocumentStorageActions Documents
{
get;
private set;
}
public IQueueStorageActions Queue
{
get;
private set;
}
public ITasksStorageActions Tasks
{
get;
private set;
}
public IStalenessStorageActions Staleness
{
get;
private set;
}
public IAttachmentsStorageActions Attachments
{
get;
private set;
}
public IIndexingStorageActions Indexing
{
get;
private set;
}
public IGeneralStorageActions General
{
get;
private set;
}
public IMappedResultsStorageAction MappedResults
{
get;
private set;
}
public event Action OnCommit;
public bool IsWriteConflict(Exception exception)
{
return exception is ConcurrencyException;
}
private readonly List<Task> tasks = new List<Task>();
public T GetTask<T>(Func<T, bool> predicate, T newTask) where T : Task
{
T task = tasks.OfType<T>().FirstOrDefault(predicate);
if(task == null)
{
tasks.Add(newTask);
return newTask;
}
return task;
}
public void SaveAllTasks()
{
foreach (var task in tasks)
{
Tasks.AddTask(task, createdAt);
}
}
[DebuggerNonUserCode]
public void InvokeOnCommit()
{
var handler = OnCommit;
if (handler != null)
handler();
}
public void Dispose()
{
Indexing.Dispose();
}
}
}