//////////////////////////////////////////////////////////////////////////////// /// DISCLAIMER /// /// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany /// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany /// /// Licensed under the Apache License, Version 2.0 (the "License"); /// you may not use this file except in compliance with the License. /// You may obtain a copy of the License at /// /// http://www.apache.org/licenses/LICENSE-2.0 /// /// Unless required by applicable law or agreed to in writing, software /// distributed under the License is distributed on an "AS IS" BASIS, /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. /// See the License for the specific language governing permissions and /// limitations under the License. /// /// Copyright holder is ArangoDB GmbH, Cologne, Germany /// /// @author Jan Steemann //////////////////////////////////////////////////////////////////////////////// #ifndef ARANGOD_HTTP_SERVER_ASYNC_JOB_MANAGER_H #define ARANGOD_HTTP_SERVER_ASYNC_JOB_MANAGER_H 1 #include "Basics/Common.h" #include "Basics/ReadWriteLock.h" namespace triagens { namespace rest { class AsyncCallbackContext; class HttpServerJob; class HttpResponse; //////////////////////////////////////////////////////////////////////////////// /// @brief AsyncJobResult //////////////////////////////////////////////////////////////////////////////// struct AsyncJobResult { public: //////////////////////////////////////////////////////////////////////////////// /// @brief job states //////////////////////////////////////////////////////////////////////////////// typedef enum { JOB_UNDEFINED, JOB_PENDING, JOB_DONE } Status; //////////////////////////////////////////////////////////////////////////////// /// @brief id typedef //////////////////////////////////////////////////////////////////////////////// typedef uint64_t IdType; //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for an unspecified job result //////////////////////////////////////////////////////////////////////////////// AsyncJobResult(); //////////////////////////////////////////////////////////////////////////////// /// @brief constructor for a specific job result //////////////////////////////////////////////////////////////////////////////// AsyncJobResult(IdType jobId, HttpResponse* response, double stamp, Status status, AsyncCallbackContext* ctx); ~AsyncJobResult(); //////////////////////////////////////////////////////////////////////////////// /// @brief job id //////////////////////////////////////////////////////////////////////////////// IdType _jobId; //////////////////////////////////////////////////////////////////////////////// /// @brief the full HTTP response object of the job, can be 0 //////////////////////////////////////////////////////////////////////////////// HttpResponse* _response; //////////////////////////////////////////////////////////////////////////////// /// @brief job creation stamp //////////////////////////////////////////////////////////////////////////////// double _stamp; //////////////////////////////////////////////////////////////////////////////// /// @brief job status //////////////////////////////////////////////////////////////////////////////// Status _status; //////////////////////////////////////////////////////////////////////////////// /// @brief callback context object (normally 0, used in cluster operations) //////////////////////////////////////////////////////////////////////////////// AsyncCallbackContext* _ctx; }; //////////////////////////////////////////////////////////////////////////////// /// @brief AsyncJobManager //////////////////////////////////////////////////////////////////////////////// class AsyncJobManager { AsyncJobManager(AsyncJobManager const&) = delete; AsyncJobManager& operator=(AsyncJobManager const&) = delete; public: //////////////////////////////////////////////////////////////////////////////// /// @brief callback typedef //////////////////////////////////////////////////////////////////////////////// typedef void (*callback_fptr)(std::string&, HttpResponse*); //////////////////////////////////////////////////////////////////////////////// /// @brief joblist typedef //////////////////////////////////////////////////////////////////////////////// typedef std::unordered_map JobList; public: explicit AsyncJobManager(callback_fptr); ~AsyncJobManager(); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the result of an async job //////////////////////////////////////////////////////////////////////////////// HttpResponse* getJobResult(AsyncJobResult::IdType, AsyncJobResult::Status&, bool removeFromList); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes the result of an async job //////////////////////////////////////////////////////////////////////////////// bool deleteJobResult(AsyncJobResult::IdType); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes all results //////////////////////////////////////////////////////////////////////////////// void deleteJobResults(); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes expired results //////////////////////////////////////////////////////////////////////////////// void deleteExpiredJobResults(double stamp); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the list of pending jobs //////////////////////////////////////////////////////////////////////////////// const std::vector pending(size_t maxCount); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the list of done jobs //////////////////////////////////////////////////////////////////////////////// const std::vector done(size_t maxCount); //////////////////////////////////////////////////////////////////////////////// /// @brief returns the list of jobs by status //////////////////////////////////////////////////////////////////////////////// const std::vector byStatus(AsyncJobResult::Status, size_t maxCount); //////////////////////////////////////////////////////////////////////////////// /// @brief initializes an async job //////////////////////////////////////////////////////////////////////////////// void initAsyncJob(HttpServerJob*, char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief finishes the execution of an async job //////////////////////////////////////////////////////////////////////////////// void finishAsyncJob(AsyncJobResult::IdType jobId, HttpResponse*); private: //////////////////////////////////////////////////////////////////////////////// /// @brief lock to protect the _jobs map //////////////////////////////////////////////////////////////////////////////// basics::ReadWriteLock _lock; //////////////////////////////////////////////////////////////////////////////// /// @brief list of pending/done async jobs //////////////////////////////////////////////////////////////////////////////// JobList _jobs; //////////////////////////////////////////////////////////////////////////////// /// @brief function pointer for callback registered at initialization //////////////////////////////////////////////////////////////////////////////// callback_fptr callback; }; } } #endif