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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org) */
/* */
/* 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. */
/* -------------------------------------------------------------------------- */
#ifndef HOST_POOL_H_
#define HOST_POOL_H_
#include "PoolSQL.h"
#include "Host.h"
#include <time.h>
#include <sstream>
#include <iostream>
#include <vector>
using namespace std;
/**
* The Host Pool class.
*/
class HostPool : public PoolSQL
{
public:
HostPool(SqlDB * db,
vector<const Attribute *> hook_mads,
const string& hook_location,
const string& remotes_location);
~HostPool(){};
/**
* Function to allocate a new Host object
* @param oid the id assigned to the Host
* @return the oid assigned to the object or -1 in case of failure
*/
int allocate (
int * oid,
const string& hostname,
const string& im_mad_name,
const string& vmm_mad_name,
const string& vnm_mad_name,
int cluster_id,
const string& cluster_name,
string& error_str);
/**
* Function to get a Host from the pool, if the object is not in memory
* it is loaded from the DB
* @param oid Host unique id
* @param lock locks the Host mutex
* @return a pointer to the Host, 0 if the Host could not be loaded
*/
Host * get(
int oid,
bool lock)
{
return static_cast<Host *>(PoolSQL::get(oid,lock));
};
/**
* Function to get a Host from the pool, if the object is not in memory
* it is loaded from the DB
* @param hostname
* @param lock locks the Host mutex
* @return a pointer to the Host, 0 if the Host could not be loaded
*/
Host * get(string name, bool lock)
{
// The owner is set to -1, because it is not used in the key() method
return static_cast<Host *>(PoolSQL::get(name,-1,lock));
};
/**
* Generate an index key for the object
* @param name of the object
* @param uid owner of the object, only used if needed
*
* @return the key, a string
*/
string key(const string& name, int uid)
{
// Name is enough key because Hosts can't repeat names.
return name;
};
/**
* Bootstraps the database table(s) associated to the Host pool
* @return 0 on success
*/
static int bootstrap(SqlDB *_db)
{
return Host::bootstrap(_db);
};
/**
* Get the least monitored hosts
* @param discovered hosts, map to store the retrieved hosts hids and
* hostnames
* @param host_limit max. number of hosts to monitor at a time
* @return int 0 if success
*/
int discover(map<int, string> * discovered_hosts, int host_limit);
/**
* Allocates a given capacity to the host
* @param oid the id of the host to allocate the capacity
* @param cpu amount of CPU
* @param mem amount of main memory
* @param disk amount of disk
*/
void add_capacity(int oid,int cpu, int mem, int disk)
{
Host * host = get(oid, true);
if ( host != 0 )
{
host->add_capacity(cpu, mem, disk);
update(host);
host->unlock();
}
};
/**
* De-Allocates a given capacity to the host
* @param oid the id of the host to allocate the capacity
* @param cpu amount of CPU
* @param mem amount of main memory
* @param disk amount of disk
*/
void del_capacity(int oid,int cpu, int mem, int disk)
{
Host * host = get(oid, true);
if ( host != 0 )
{
host->del_capacity(cpu, mem, disk);
update(host);
host->unlock();
}
};
int drop(PoolObjectSQL * objsql, string& error_msg)
{
Host * host = static_cast<Host *>(objsql);
if ( host->get_share_running_vms() > 0 )
{
error_msg = "Can not remove a host with running VMs";
return -1;
}
return PoolSQL::drop(objsql, error_msg);
};
/**
* Dumps the HOST pool in XML format. A filter can be also added to the
* query
* @param oss the output stream to dump the pool contents
* @param where filter for the objects, defaults to all
*
* @return 0 on success
*/
int dump(ostringstream& oss, const string& where)
{
return PoolSQL::dump(oss, "HOST_POOL", Host::table, where);
};
/**
* Finds a set objects that satisfies a given condition
* @param oids a vector with the oids of the objects.
* @param the name of the DB table.
* @param where condition in SQL format.
*
* @return 0 on success
*/
int search(vector<int>& oids, const string& where)
{
return PoolSQL::search(oids, Host::table, where);
};
private:
/**
* Factory method to produce Host objects
* @return a pointer to the new Host
*/
PoolObjectSQL * create()
{
return new Host(-1,"","","","",-1,"");
};
/**
* Callback function to get the IDs of the hosts to be monitored
* (Host::discover)
* @param num the number of columns read from the DB
* @param names the column names
* @param vaues the column values
* @return 0 on success
*/
int discover_cb(void * _map, int num, char **values, char **names);
};
#endif /*HOST_POOL_H_*/
|
