1 #ifndef MISC_NETSTORAGE___NETSTORAGEIMPL__HPP
2 #define MISC_NETSTORAGE___NETSTORAGEIMPL__HPP
3 
4 /*  $Id: state.hpp 617407 2020-09-30 19:12:51Z sadyrovr $
5  * ===========================================================================
6  *
7  *                            PUBLIC DOMAIN NOTICE
8  *               National Center for Biotechnology Information
9  *
10  *  This software/database is a "United States Government Work" under the
11  *  terms of the United States Copyright Act.  It was written as part of
12  *  the author's official duties as a United States Government employee and
13  *  thus cannot be copyrighted.  This software/database is freely available
14  *  to the public for use. The National Library of Medicine and the U.S.
15  *  Government have not placed any restriction on its use or reproduction.
16  *
17  *  Although all reasonable efforts have been taken to ensure the accuracy
18  *  and reliability of the software and data, the NLM and the U.S.
19  *  Government do not and cannot warrant the performance or results that
20  *  may be obtained by using this software or data. The NLM and the U.S.
21  *  Government disclaim all warranties, express or implied, including
22  *  warranties of performance, merchantability or fitness for any particular
23  *  purpose.
24  *
25  *  Please cite the author in any work or product based on this material.
26  *
27  * ===========================================================================
28  *
29  * Author: Rafael Sadyrov
30  *
31  */
32 
33 #include <connect/services/compound_id.hpp>
34 #include <connect/services/neticache_client.hpp>
35 #include <connect/services/netstorage.hpp>
36 #include "filetrack.hpp"
37 
38 
39 BEGIN_NCBI_SCOPE
40 
41 
42 struct SCombinedNetStorageConfig : SNetStorage::SConfig
43 {
44     enum EMode {
45         eDefault,
46         eServerless,
47     };
48 
49     EMode mode;
50     SFileTrackConfig ft;
51 
SCombinedNetStorageConfigSCombinedNetStorageConfig52     SCombinedNetStorageConfig() : mode(eDefault) {}
53     void ParseArg(const string&, const string&);
54 
BuildSCombinedNetStorageConfig55     static SCombinedNetStorageConfig Build(const string& init_string)
56     {
57         return BuildImpl<SCombinedNetStorageConfig>(init_string);
58     }
59 
60 private:
61     static EMode GetMode(const string&);
62 };
63 
64 template <class TBase>
65 struct SNetStorageObjectDirectState : TBase
66 {
67     template <class... TArgs>
SNetStorageObjectDirectStateSNetStorageObjectDirectState68     SNetStorageObjectDirectState(CNetStorageObjectLoc& locator, TArgs&&... args) :
69         TBase(std::forward<TArgs>(args)...),
70         m_Locator(locator)
71     {
72     }
73 
GetLocSNetStorageObjectDirectState74     string GetLoc() const override           { return m_Locator.GetLocator(); }
LocatorSNetStorageObjectDirectState75     CNetStorageObjectLoc& Locator() override { return m_Locator; }
76 
77 private:
78     CNetStorageObjectLoc& m_Locator;
79 };
80 
81 
82 namespace NDirectNetStorageImpl
83 {
84 
85 class ILocation
86 {
87 public:
~ILocation()88     virtual ~ILocation() {}
89 
90     virtual INetStorageObjectState* StartRead(void*, size_t, size_t*, ERW_Result*) = 0;
91     virtual INetStorageObjectState* StartWrite(const void*, size_t, size_t*, ERW_Result*) = 0;
92     virtual Uint8 GetSize() = 0;
93     virtual CNetStorageObjectInfo GetInfo() = 0;
94     virtual bool Exists() = 0;
95     virtual ENetStorageRemoveResult Remove() = 0;
96     virtual void SetExpiration(const CTimeout&) = 0;
97     virtual string FileTrack_Path() = 0;
98     virtual pair<string, string> GetUserInfo() = 0;
99     virtual string GetLoc() const = 0;
100     virtual CNetStorageObjectLoc& Locator() = 0;
101     virtual void SetLocator() = 0;
102 };
103 
104 using CLocation = SNetStorageObjectDirectState<ILocation>;
105 
106 template <class TBase>
107 using TState = SNetStorageObjectState<SNetStorageObjectDirectState<TBase>>;
108 
109 struct SContext : CObject
110 {
111     CNetICacheClientExt icache_client;
112     SFileTrackAPI filetrack_api;
113     CCompoundIDPool compound_id_pool;
114     TNetStorageFlags default_flags = 0;
115     string app_domain;
116     size_t relocate_chunk;
117     CRandom random;
118 
119     SContext(const SCombinedNetStorageConfig&, TNetStorageFlags);
120     SContext(const string&, const string&,
121             CCompoundIDPool::TInstance, const IRegistry&);
122 
CreateNDirectNetStorageImpl::SContext123     CNetStorageObjectLoc Create(TNetStorageFlags flags)
124     {
125         return CNetStorageObjectLoc(compound_id_pool, flags, app_domain, random.GetRandUint8(), filetrack_api.config.site);
126     }
127 
CreateNDirectNetStorageImpl::SContext128     CNetStorageObjectLoc Create(const string& key, TNetStorageFlags flags)
129     {
130         return CNetStorageObjectLoc(compound_id_pool, flags, app_domain, key, filetrack_api.config.site);
131     }
132 
133 private:
134     void Init();
135 };
136 
137 class CROState : public SNetStorageObjectIState
138 {
139 public:
CROState(bool * cancel_relocate)140     CROState(bool* cancel_relocate) : m_CancelRelocate(cancel_relocate) {}
CancelRelocate()141     void CancelRelocate() override { _ASSERT(m_CancelRelocate); *m_CancelRelocate = true; }
142 
143 private:
144     bool* m_CancelRelocate;
145 };
146 
147 class CRWNotFound : public SNetStorageObjectIoState
148 {
149 public:
150     ERW_Result Read(void* buf, size_t count, size_t* read) override;
151     ERW_Result PendingCount(size_t* count) override;
152     bool Eof() override;
153     ERW_Result Write(const void* buf, size_t count, size_t* written) override;
Flush()154     ERW_Result Flush() override { return eRW_Success; }
155 
Close()156     void Close() override { ExitState(); }
Abort()157     void Abort() override { ExitState(); }
158 };
159 
160 class CRONetCache : public CROState
161 {
162 public:
163     typedef unique_ptr<IReader> TReaderPtr;
164 
CRONetCache(bool * cancel_relocate)165     CRONetCache(bool* cancel_relocate) : CROState(cancel_relocate) {}
166 
Set(TReaderPtr reader,size_t blob_size)167     void Set(TReaderPtr reader, size_t blob_size)
168     {
169         m_Reader = move(reader);
170         m_BlobSize = blob_size;
171         m_BytesRead = 0;
172     }
173 
174     ERW_Result Read(void* buf, size_t count, size_t* read) override;
175     ERW_Result PendingCount(size_t* count) override;
176     bool Eof() override;
177 
178     void Close() override;
179     void Abort() override;
180 
181 private:
182     TReaderPtr m_Reader;
183     size_t m_BlobSize;
184     size_t m_BytesRead;
185 };
186 
187 class CWONetCache : public SNetStorageObjectOState
188 {
189 public:
190     typedef unique_ptr<IEmbeddedStreamWriter> TWriterPtr;
191 
Set(TWriterPtr writer)192     void Set(TWriterPtr writer)
193     {
194         m_Writer = move(writer);
195     }
196 
197     ERW_Result Write(const void* buf, size_t count, size_t* written) override;
198     ERW_Result Flush() override;
199 
200     void Close() override;
201     void Abort() override;
202 
203 private:
204     TWriterPtr m_Writer;
205 };
206 
207 class CROFileTrack : public CROState
208 {
209 public:
210     typedef CRef<SFileTrackDownload> TRequest;
211 
CROFileTrack(bool * cancel_relocate)212     CROFileTrack(bool* cancel_relocate) : CROState(cancel_relocate) {}
213 
Set(TRequest request)214     void Set(TRequest request)
215     {
216         m_Request = request;
217     }
218 
219     ERW_Result Read(void* buf, size_t count, size_t* read) override;
220     ERW_Result PendingCount(size_t* count) override;
221     bool Eof() override;
222 
223     void Close() override;
224     void Abort() override;
225 
226 private:
227     TRequest m_Request;
228 };
229 
230 class CWOFileTrack : public SNetStorageObjectOState
231 {
232 public:
233     typedef CRef<SFileTrackUpload> TRequest;
234 
Set(TRequest request)235     void Set(TRequest request)
236     {
237         m_Request = request;
238     }
239 
240     ERW_Result Write(const void* buf, size_t count, size_t* written) override;
241     ERW_Result Flush() override;
242 
243     void Close() override;
244     void Abort() override;
245 
246 private:
247     TRequest m_Request;
248 };
249 
250 class CNotFound : public CLocation
251 {
252 public:
CNotFound(CNetStorageObjectLoc & object_loc,SNetStorageObjectImpl & fsm)253     CNotFound(CNetStorageObjectLoc& object_loc, SNetStorageObjectImpl& fsm)
254         : CLocation(object_loc),
255           m_RW(fsm, object_loc)
256     {}
257 
258     void SetLocator() override;
259 
260     INetStorageObjectState* StartRead(void*, size_t, size_t*, ERW_Result*) override;
261     INetStorageObjectState* StartWrite(const void*, size_t, size_t*, ERW_Result*) override;
262     Uint8 GetSize() override;
263     CNetStorageObjectInfo GetInfo() override;
264     bool Exists() override;
265     ENetStorageRemoveResult Remove() override;
266     void SetExpiration(const CTimeout&) override;
267     string FileTrack_Path() override;
268     pair<string, string> GetUserInfo() override;
269 
270 private:
271     TState<CRWNotFound> m_RW;
272 };
273 
274 class CNetCache : public CLocation
275 {
276 public:
CNetCache(CNetStorageObjectLoc & object_loc,SNetStorageObjectImpl & fsm,SContext * context,bool * cancel_relocate)277     CNetCache(CNetStorageObjectLoc& object_loc, SNetStorageObjectImpl& fsm, SContext* context, bool* cancel_relocate)
278         : CLocation(object_loc),
279           m_Context(context),
280           m_Read(fsm, object_loc, cancel_relocate),
281           m_Write(fsm, object_loc)
282     {}
283 
284     bool Init();
285     void SetLocator() override;
286 
287     INetStorageObjectState* StartRead(void*, size_t, size_t*, ERW_Result*) override;
288     INetStorageObjectState* StartWrite(const void*, size_t, size_t*, ERW_Result*) override;
289     Uint8 GetSize() override;
290     CNetStorageObjectInfo GetInfo() override;
291     bool Exists() override;
292     ENetStorageRemoveResult Remove() override;
293     void SetExpiration(const CTimeout&) override;
294     string FileTrack_Path() override;
295     pair<string, string> GetUserInfo() override;
296 
297 private:
298     CRef<SContext> m_Context;
299     CNetICacheClientExt m_Client;
300     TState<CRONetCache> m_Read;
301     TState<CWONetCache> m_Write;
302 };
303 
304 class CFileTrack : public CLocation
305 {
306 public:
CFileTrack(CNetStorageObjectLoc & object_loc,SNetStorageObjectImpl & fsm,SContext * context,bool * cancel_relocate)307     CFileTrack(CNetStorageObjectLoc& object_loc, SNetStorageObjectImpl& fsm, SContext* context, bool* cancel_relocate)
308         : CLocation(object_loc),
309           m_Context(context),
310           m_Read(fsm, object_loc, cancel_relocate),
311           m_Write(fsm, object_loc)
312     {}
313 
Init()314     bool Init() { return m_Context->filetrack_api; }
315     void SetLocator() override;
316 
317     INetStorageObjectState* StartRead(void*, size_t, size_t*, ERW_Result*) override;
318     INetStorageObjectState* StartWrite(const void*, size_t, size_t*, ERW_Result*) override;
319     Uint8 GetSize() override;
320     CNetStorageObjectInfo GetInfo() override;
321     bool Exists() override;
322     ENetStorageRemoveResult Remove() override;
323     void SetExpiration(const CTimeout&) override;
324     string FileTrack_Path() override;
325     pair<string, string> GetUserInfo() override;
326 
327 private:
328     CRef<SContext> m_Context;
329     TState<CROFileTrack> m_Read;
330     TState<CWOFileTrack> m_Write;
331 };
332 
333 }
334 
335 END_NCBI_SCOPE
336 
337 #endif
338