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
|
// file : mod/database-module.cxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#include <mod/database-module.hxx>
#include <odb/database.hxx>
#include <odb/exceptions.hxx>
#include <odb/transaction.hxx>
#include <libbrep/build-package.hxx>
#include <libbrep/build-package-odb.hxx>
#include <mod/database.hxx>
#include <mod/module-options.hxx>
namespace brep
{
using namespace odb::core;
// While currently the user-defined copy constructor is not required (we
// don't need to deep copy nullptr's), it is a good idea to keep the
// placeholder ready for less trivial cases.
//
database_module::
database_module (const database_module& r)
: handler (r),
retry_ (r.retry_),
package_db_ (r.initialized_ ? r.package_db_ : nullptr),
build_db_ (r.initialized_ ? r.build_db_ : nullptr)
{
}
void database_module::
init (const options::package_db& o, size_t retry)
{
package_db_ = shared_database (o.package_db_user (),
o.package_db_role (),
o.package_db_password (),
o.package_db_name (),
o.package_db_host (),
o.package_db_port (),
o.package_db_max_connections ());
retry_ = retry_ < retry ? retry : retry_;
}
void database_module::
init (const options::build_db& o, size_t retry)
{
build_db_ = shared_database (o.build_db_user (),
o.build_db_role (),
o.build_db_password (),
o.build_db_name (),
o.build_db_host (),
o.build_db_port (),
o.build_db_max_connections ());
retry_ = retry_ < retry ? retry : retry_;
}
bool database_module::
handle (request& rq, response& rs, log& l)
try
{
return handler::handle (rq, rs, l);
}
catch (const odb::recoverable& e)
{
if (retry_-- > 0)
{
HANDLER_DIAG;
l1 ([&]{trace << e << "; " << retry_ + 1 << " retries left";});
throw retry ();
}
throw;
}
void database_module::
update_tenant_service_state (
const connection_ptr& conn,
const string& tid,
const function<optional<string> (const tenant_service&)>& f)
{
assert (f != nullptr); // Shouldn't be called otherwise.
// Must be initialized via the init(options::build_db) function call.
//
assert (build_db_ != nullptr);
for (size_t retry (retry_);; )
{
try
{
transaction tr (conn->begin ());
shared_ptr<build_tenant> t (build_db_->find<build_tenant> (tid));
if (t != nullptr && t->service)
{
tenant_service& s (*t->service);
if (optional<string> data = f (s))
{
s.data = move (*data);
build_db_->update (t);
}
}
tr.commit ();
// Bail out if we have successfully updated the service state.
//
break;
}
catch (const odb::recoverable& e)
{
if (retry-- == 0)
throw;
HANDLER_DIAG;
l1 ([&]{trace << e << "; " << retry + 1 << " tenant service "
<< "state update retries left";});
}
}
}
}
|
