shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2025-03-21 14:50:08 +03:00
Code Releases Wiki Activity

Feature #457: Unit testing for Host Hooks

Browse Source
This commit is contained in:
Carlos Martín 2011-01-19 18:17:25 +01:00
parent d313af3abc
commit de97dfd903
5 changed files with 734 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/hm_mad/test/dummy Executable file
View File

@ -0,0 +1,41 @@
#!/bin/bash
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, 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. #
#--------------------------------------------------------------------------- #
#echo "MAD started" >> mad.log
while read COMMAND ARG1 ARG2 ARG3
do
# echo "$COMMAND $ARG1 $ARG2 $ARG3" >> mad.log
case $COMMAND in
"INIT")
echo "INIT SUCCESS"
;;
"FINALIZE")
echo "FINALIZE SUCCESS"
exit 0
;;
"EXECUTE")
`echo $ARG3 | cut -d ' ' -f 2-`
echo "EXECUTE SUCCESS"
;;
*)
echo "$COMMAND - FAILURE Unknown command"
;;
esac
done

168
src/host/test/HostHookTest.cc
View File

@ -14,107 +14,85 @@
/* limitations under the License. */
/* -------------------------------------------------------------------------- */
#include <string>
#include <iostream>
#include <stdlib.h>
#include <fstream>
#include "HostHookTest.h"
#include "HostPool.h"
#include "PoolTest.h"
string HostHookTest::db_name;
using namespace std;
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* ************************************************************************* */
/* ************************************************************************* */
class HostHookTest : public PoolTest
void show_options ()
{
CPPUNIT_TEST_SUITE (HostHookTest);
CPPUNIT_TEST (allocate_hook);
// CPPUNIT_TEST (error_hook);
// CPPUNIT_TEST (disable_hook);
CPPUNIT_TEST_SUITE_END ();
protected:
void bootstrap(SqlDB* db)
{
HostPool::bootstrap(db);
};
PoolSQL* create_pool(SqlDB* db)
{
map<string,string> hook_value;
VectorAttribute * hook;
vector<const Attribute *> host_hooks;
hook_value.insert(make_pair("NAME","create_test"));
hook_value.insert(make_pair("ON","ERROR"));
hook_value.insert(make_pair("COMMAND","/bin/touch"));
hook_value.insert(make_pair("ARGUMENTS","/tmp/host_$HID"));
hook_value.insert(make_pair("REMOTE","no"));
hook = new VectorAttribute("HOST_HOOK",hook_value);
host_hooks.push_back(hook);
return new HostPool(db,host_hooks,"./");
};
int allocate(int index){return 0;};
void check(int index, PoolObjectSQL* obj){};
public:
HostHookTest(){xmlInitParser();};
~HostHookTest(){xmlCleanupParser();};
/* ********************************************************************* */
/* ********************************************************************* */
void allocate_hook()
{
HostPool * hp = static_cast<HostPool *>(pool);
string err;
int oid;
fstream fd;
hp->allocate(&oid, "host_test", "im_mad", "vmm_mad", "tm_mad", err);
Host* host = hp->get(oid, true);
CPPUNIT_ASSERT( host != 0 );
host->unlock();
ostringstream oss;
oss << "/tmp/host_" << oid ;
fd.open(oss.str().c_str(), fstream::in | fstream::out );
CPPUNIT_ASSERT( fd.fail() == false );
fd.close();
};
/* ********************************************************************* */
cout << "Options:\n";
cout << " -h --help Show this help\n"
" -s --sqlite Run Sqlite tests (default)\n"
" -m --mysql Run MySQL tests\n"
" -l --log Keep the log file, test.log\n";
};
/* ************************************************************************* */
/* ************************************************************************* */
/* ************************************************************************* */
int main(int argc, char ** argv)
{
return PoolTest::main(argc, argv, HostHookTest::suite());
}
// Option flags
bool sqlite_flag = true;
bool log_flag = false;
// Long options
const struct option long_opt[] =
{
{ "sqlite", 0, NULL, 's'},
{ "mysql", 0, NULL, 'm'},
{ "log", 0, NULL, 'l'},
{ "help", 0, NULL, 'h'}
};
int c;
while ((c = getopt_long (argc, argv, "smlh", long_opt, NULL)) != -1)
switch (c)
{
case 'm':
sqlite_flag = false;
break;
case 'l':
log_flag = true;
break;
case 'h':
show_options();
return 0;
}
// We need to set the log file, otherwise it will end in a dead-lock
NebulaLog::init_log_system(NebulaLog::FILE, Log::DEBUG, "test.log");
NebulaLog::log("Test", Log::INFO, "Test started");
CppUnit::TextUi::TestRunner runner;
SETUP_XML_WRITER(runner, "output.xml")
runner.addTest( HostHookTest::suite() );
if (sqlite_flag)
{
NebulaTest::instance().setMysql(false);
NebulaLog::log("Test", Log::INFO, "Running Sqlite tests...");
cout << "\nRunning Sqlite tests...\n";
}
else
{
NebulaTest::instance().setMysql(true);
NebulaLog::log("Test", Log::INFO, "Running MySQL tests...");
cout << "\nRunning MySQL tests...\n";
}
runner.run();
END_XML_WRITER
if (!log_flag)
remove("test.log");
NebulaLog::finalize_log_system();
return 0;
}

209
src/host/test/HostHookTest.h Normal file
View File

@ -0,0 +1,209 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, 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. */
/* -------------------------------------------------------------------------- */
#include "Nebula.h"
#include "NebulaTest.h"
#include "SqliteDB.h"
#include "MySqlDB.h"
#include <string>
#include <iostream>
#include <stdlib.h>
#include <getopt.h>
#include <TestFixture.h>
#include <TestAssert.h>
#include <TestSuite.h>
#include <TestCaller.h>
#include <ui/text/TestRunner.h>
#include <cppunit/extensions/HelperMacros.h>
#include <unistd.h>
#include "test/one_test_common.h"
using namespace std;
class HostHookTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE (HostHookTest);
CPPUNIT_TEST (allocate_hook);
CPPUNIT_TEST (monitoring_error);
CPPUNIT_TEST (error_imd);
CPPUNIT_TEST (disable_hook);
CPPUNIT_TEST_SUITE_END ();
private:
Host * host;
HostPool * hpool;
HookManager * hm;
int oid;
int rc;
public:
static string db_name;
void setUp()
{
// Create var dir.
string command = "mkdir -p var";
std::system(command.c_str());
Nebula& neb = Nebula::instance();
neb.start();
hpool = neb.get_hpool();
hm = static_cast<HookManager*>(neb.get_hm());
}
void tearDown()
{
// -----------------------------------------------------------
// Stop the managers & free resources
// -----------------------------------------------------------
hm->finalize();
//sleep to wait drivers???
pthread_join(hm->get_thread_id(),0);
//XML Library
xmlCleanupParser();
if (NebulaTest::instance().isMysql())
{
SqlDB * db;
db = new MySqlDB("localhost",0,"oneadmin","oneadmin",db_name.c_str());
ostringstream oss;
oss << "DROP DATABASE IF EXISTS " << db_name;
db->exec(oss);
delete db;
}
// Clean var dir.
string command = "rm -r var";
std::system(command.c_str());
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
void allocate_hook()
{
string err;
hpool->allocate(&oid, "host_test", "im_mad", "vmm_mad", "tm_mad", err);
CPPUNIT_ASSERT( oid >= 0 );
sleep(1);
ostringstream oss;
oss << "ls ./var/hook_create_" << oid << " > /dev/null 2>&1";
rc = std::system(oss.str().c_str());
CPPUNIT_ASSERT( rc == 0 );
}
/* -------------------------------------------------------------------------- */
void monitoring_error()
{
string err;
hpool->allocate(&oid, "host_test", "im_mad", "vmm_mad", "tm_mad", err);
CPPUNIT_ASSERT( oid >= 0 );
host = hpool->get(oid, true);
CPPUNIT_ASSERT( host != 0 );
host->touch(false);
hpool->update(host);
host->unlock();
sleep(1);
ostringstream oss;
oss << "ls ./var/hook_error_" << oid << " > /dev/null 2>&1";
rc = std::system(oss.str().c_str());
CPPUNIT_ASSERT( rc == 0 );
}
/* -------------------------------------------------------------------------- */
void error_imd()
{
string err;
hpool->allocate(&oid, "host_test", "im_mad", "vmm_mad", "tm_mad", err);
CPPUNIT_ASSERT( oid >= 0 );
host = hpool->get(oid, true);
CPPUNIT_ASSERT( host != 0 );
host->set_state(Host::ERROR);
hpool->update(host);
host->unlock();
sleep(1);
ostringstream oss;
oss << "ls ./var/hook_error_" << oid << " > /dev/null 2>&1";
rc = std::system(oss.str().c_str());
CPPUNIT_ASSERT( rc == 0 );
}
/* -------------------------------------------------------------------------- */
void disable_hook()
{
string err;
hpool->allocate(&oid, "host_test", "im_mad", "vmm_mad", "tm_mad", err);
CPPUNIT_ASSERT( oid >= 0 );
host = hpool->get(oid, true);
CPPUNIT_ASSERT( host != 0 );
host->disable();
hpool->update(host);
host->unlock();
sleep(1);
ostringstream oss;
oss << "ls ./var/hook_disable_" << oid << " > /dev/null 2>&1";
rc = std::system(oss.str().c_str());
CPPUNIT_ASSERT( rc == 0 );
}
/* -------------------------------------------------------------------------- */
};

210
src/host/test/NebulaTest.h Normal file
View File

@ -0,0 +1,210 @@
/* -------------------------------------------------------------------------- */
/* Copyright 2002-2010, 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 NEBULA_TEST_H_
#define NEBULA_TEST_H_
#include "SqlDB.h"
#include "NebulaTemplate.h"
#include "VirtualMachinePool.h"
#include "VirtualNetworkPool.h"
#include "HostPool.h"
#include "UserPool.h"
#include "VirtualMachineManager.h"
#include "LifeCycleManager.h"
#include "InformationManager.h"
#include "TransferManager.h"
#include "DispatchManager.h"
#include "RequestManager.h"
#include "HookManager.h"
#include "AuthManager.h"
class NebulaTest
{
private:
bool mysql;
NebulaTest()
{
mysql = false;
};
public:
static NebulaTest& instance()
{
static NebulaTest instance;
return instance;
};
void setMysql(bool _mysql)
{
mysql = _mysql;
}
bool isMysql()
{
return mysql;
}
// -----------------------------------------------------------
// Pools
// -----------------------------------------------------------
static VirtualMachinePool* create_vmpool(SqlDB* db, string hook_location)
{
vector<const Attribute *> hooks;
return new VirtualMachinePool(db, hooks, hook_location);
}
static HostPool* create_hpool(SqlDB* db, string hook_location)
{
map<string,string> hook_value;
VectorAttribute * hook;
vector<const Attribute *> host_hooks;
hook_value.insert(make_pair("NAME","create_test"));
hook_value.insert(make_pair("ON","CREATE"));
hook_value.insert(make_pair("COMMAND","/bin/touch"));
hook_value.insert(make_pair("ARGUMENTS","./var/hook_create_$HID"));
hook_value.insert(make_pair("REMOTE","no"));
hook = new VectorAttribute("HOST_HOOK",hook_value);
host_hooks.push_back(hook);
map<string,string> hook_value2;
hook_value2.insert(make_pair("NAME","error_test"));
hook_value2.insert(make_pair("ON","ERROR"));
hook_value2.insert(make_pair("COMMAND","/bin/touch"));
hook_value2.insert(make_pair("ARGUMENTS","./var/hook_error_$HID"));
hook_value2.insert(make_pair("REMOTE","no"));
hook = new VectorAttribute("HOST_HOOK",hook_value2);
host_hooks.push_back(hook);
map<string,string> hook_value3;
hook_value3.insert(make_pair("NAME","create_test"));
hook_value3.insert(make_pair("ON","DISABLE"));
hook_value3.insert(make_pair("COMMAND","/bin/touch"));
hook_value3.insert(make_pair("ARGUMENTS","./var/hook_disable_$HID"));
hook_value3.insert(make_pair("REMOTE","no"));
hook = new VectorAttribute("HOST_HOOK",hook_value3);
host_hooks.push_back(hook);
return new HostPool(db, host_hooks, hook_location);
}
static VirtualNetworkPool* create_vnpool(SqlDB* db, string mac_prefix, int size)
{
return new VirtualNetworkPool(db,mac_prefix,size);
}
static UserPool* create_upool(SqlDB* db)
{
return new UserPool(db);
}
static ImagePool* create_ipool( SqlDB* db,
string repository_path,
string default_image_type,
string default_device_prefix)
{
return new ImagePool(db,repository_path,default_image_type,
default_device_prefix);
}
// -----------------------------------------------------------
// Managers
// -----------------------------------------------------------
static VirtualMachineManager* create_vmm(VirtualMachinePool* vmpool,
HostPool* hpool,
time_t timer_period,
time_t poll_period)
{
return NULL;
}
static LifeCycleManager* create_lcm(VirtualMachinePool* vmpool, HostPool* hpool)
{
return NULL;
}
static InformationManager* create_im( HostPool* hpool,
time_t timer_period,
string remotes_location)
{
return NULL;
}
static TransferManager* create_tm( VirtualMachinePool* vmpool,
HostPool* hpool)
{
return NULL;
}
static DispatchManager* create_dm( VirtualMachinePool* vmpool,
HostPool* hpool)
{
return NULL;
}
static RequestManager* create_rm(
VirtualMachinePool * vmpool,
HostPool * hpool,
VirtualNetworkPool * vnpool,
UserPool * upool,
ImagePool * ipool,
string log_file)
{
return NULL;
}
static HookManager* create_hm(VirtualMachinePool * vmpool)
{
map<string,string> mad_value;
VectorAttribute * mad;
vector<const Attribute *> hm_mads;
ostringstream oss;
// we need the full path (i.e, starting with '/')
// for the dummy executable
oss << getenv("PWD") << "/../../hm_mad/test/dummy";
mad_value.insert(make_pair("EXECUTABLE",oss.str()));
mad = new VectorAttribute("HM_MAD",mad_value);
hm_mads.push_back(mad);
return new HookManager(hm_mads,vmpool);
}
static AuthManager* create_authm(time_t timer_period)
{
return NULL;
}
};
#endif /*NEBULA_TEST_H_*/

262
src/host/test/SConstruct
View File

@ -1,18 +1,18 @@
# --------------------------------------------------------------------------
# Copyright 2002-2010, 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.
# --------------------------------------------------------------------------
# -------------------------------------------------------------------------- #
# Copyright 2002-2010, 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. #
#--------------------------------------------------------------------------- #
import os
import sys
@ -21,81 +21,221 @@ sys.path.append("../../../share/scons")
from lex_bison import *
# This is the absolute path where the project is located
cwd="../../../"
cwd="../../.."
# Environment that will be applied to each scons child
main_env=Environment()
main_env['ENV']['PATH']=os.environ['PATH']
# snippet borrowed from http://dev.gentoo.org/~vapier/scons-blows.txt
# makes scons aware of build related environment variables
if os.environ.has_key('CC'):
main_env['CC'] = os.environ['CC']
if os.environ.has_key('CFLAGS'):
main_env['CCFLAGS'] += SCons.Util.CLVar(os.environ['CFLAGS'])
if os.environ.has_key('CXX'):
main_env['CXX'] = os.environ['CXX']
if os.environ.has_key('CXXFLAGS'):
main_env['CXXFLAGS'] += SCons.Util.CLVar(os.environ['CXXFLAGS'])
if os.environ.has_key('LDFLAGS'):
main_env['LINKFLAGS'] += SCons.Util.CLVar(os.environ['LDFLAGS'])
# Add builders for flex and bison
add_lex(main_env)
add_bison(main_env)
# Include dirs
main_env.Append(CPPPATH=[
cwd + '/include',
cwd + '/include/test',
'/usr/include/cppunit/',
'.',
cwd+'/include',
cwd+'/include/test',
cwd+'/src/hm/test',
'/usr/include/cppunit/'
])
# Library dirs
main_env.Append(LIBPATH=[
cwd + '/src/common',
cwd + '/src/log',
cwd + '/src/nebula',
cwd + '/src/sql',
cwd + '/src/pool',
cwd + '/src/template',
cwd + '/src/host',
cwd + '/src/hm',
cwd + '/src/mad',
cwd+'/src/common',
cwd+'/src/log',
cwd+'/src/sql',
cwd+'/src/host',
cwd+'/src/mad',
cwd+'/src/nebula',
cwd+'/src/pool',
cwd+'/src/template',
cwd+'/src/vm',
cwd+'/src/vmm',
cwd+'/src/lcm',
cwd+'/src/tm',
cwd+'/src/dm',
cwd+'/src/im',
cwd+'/src/image',
cwd+'/src/rm',
cwd+'/src/vnm',
cwd+'/src/hm',
cwd+'/src/um',
cwd+'/src/authm',
'.',
])
main_env.Append(LIBS=[
'nebula_log',
'nebula_host',
'nebula_template',
'nebula_pool',
'nebula_mad',
'nebula_hm',
'nebula_common',
'nebula_core',
'nebula_sql',
'cppunit',
'dl',
'pthread',
# Compile flags
main_env.Append(CPPFLAGS=[
"-g",
"-Wall",
"-Werror",
])
# MYSQL
main_env.Append(LIBPATH=["/usr/lib/mysql"])
main_env.Append(CPPPATH=["/usr/include/mysql"])
# Linking flags
main_env.Append(LINKFLAGS=['-g', '-pthread'])
#######################
# EXTRA CONFIGURATION #
#######################
# SQLITE
sqlite_dir=ARGUMENTS.get('sqlite_dir', 'none')
if sqlite_dir!='none':
main_env.Append(LIBPATH=[sqlite_dir+"/lib"])
main_env.Append(CPPPATH=[sqlite_dir+"/include"])
sqlite=ARGUMENTS.get('sqlite', 'yes')
if sqlite=='yes':
main_env.Append(sqlite='yes')
main_env.Append(CPPFLAGS=["-DSQLITE_DB"])
else:
main_env.Append(sqlite='no')
# MySQL
mysql=ARGUMENTS.get('mysql', 'no')
if mysql=='yes':
main_env.Append(mysql='yes')
main_env.Append(CPPFLAGS=["-DMYSQL_DB"])
else:
main_env.Append(mysql='no')
# xmlrpc
xmlrpc_dir=ARGUMENTS.get('xmlrpc', 'none')
if xmlrpc_dir!='none':
main_env.Append(LIBPATH=[xmlrpc_dir+"/lib"])
main_env.Append(CPPPATH=[xmlrpc_dir+"/include"])
# build lex/bison
build_parsers=ARGUMENTS.get('parsers', 'no')
if build_parsers=='yes':
main_env.Append(parsers='yes')
else:
main_env.Append(parsers='no')
if not main_env.GetOption('clean'):
try:
main_env.ParseConfig('../../../share/scons/get_xmlrpc_config server')
main_env.ParseConfig('../../../share/scons/get_xmlrpc_config client')
if mysql=='yes':
main_env.ParseConfig('mysql_config --cflags --libs')
except Exception, e:
print ""
print "Error searching for xmlrpc-c libraries. Please check this"+\
" things:"
print ""
print " * You have installed development libraries for xmlrpc-c. One"+\
" way to check"
print " this is calling xmlrpc-c-config that is provided with the"+\
" development"
print " package."
print " * Check that the version of xmlrpc-c is at least 1.06. You"+\
" can do this also"
print " calling:"
print " $ xmlrpc-c-config --version"
print " * If all this requirements are already met please send log"+\
" files located in"
print " .xmlrpc_test to the mailing list."
print ""
exit(-1)
else:
main_env.Replace(mysql='yes')
shutil.rmtree('.xmlrpc_test', True)
shutil.rmtree('src/nebula/.xmlrpc_test', True)
shutil.rmtree('src/scheduler/.xmlrpc_test', True)
# libxml2
main_env.ParseConfig('xml2-config --libs --cflags')
sqlite=ARGUMENTS.get('sqlite', 'yes')
if sqlite=='yes':
main_env.Append(CPPFLAGS=["-DSQLITE_DB"])
main_env.Append(LIBS=[ 'sqlite3', ])
# Build LCM and DM toguether in a lib
# MySQL
mysql=ARGUMENTS.get('mysql', 'no')
if mysql=='yes':
main_env.Append(CPPFLAGS=["-DMYSQL_DB"])
main_env.Append(LIBS=[ 'mysqlclient', ])
lib_name='nebula_lcm_dm'
# Compile flags
main_env.Append(CPPFLAGS=[
"-g",
"-Wall",
"-Werror"
# Sources to generate the library
source_files=[
'../../lcm/LifeCycleManager.cc',
'../../lcm/LifeCycleActions.cc',
'../../lcm/LifeCycleStates.cc',
'../../dm/DispatchManager.cc',
'../../dm/DispatchManagerActions.cc',
'../../dm/DispatchManagerStates.cc',
]
# Build library
main_env.StaticLibrary(lib_name, source_files)
# Build a modified Nebula lib
lib_name='nebula_core_test'
# Sources to generate the library
source_files=[
'../../nebula/test/Nebula.cc',
'../../nebula/NebulaTemplate.cc',
]
# Build library
main_env.StaticLibrary(lib_name, source_files)
# Build daemon
main_env.Append(LIBS=[
'nebula_core_test',
'nebula_host',
'nebula_vmm',
'nebula_im',
'nebula_rm',
'nebula_tm',
'nebula_um',
'nebula_mad',
'nebula_template',
'nebula_vm',
'nebula_vnm',
'nebula_image',
'nebula_pool',
'nebula_hm',
'nebula_authm',
'nebula_common',
'nebula_sql',
'nebula_log',
'nebula_lcm_dm',
'crypto',
'cppunit',
])
# Linking flags
main_env.Append(LDFLAGS=["-g "])
# Sources to generate the library
if main_env['sqlite']=='yes':
main_env.Append(LIBS=['sqlite3'])
if main_env['mysql']=='yes':
main_env.Append(LIBS=['mysqlclient'])
if not main_env.GetOption('clean'):
main_env.ParseConfig('../../../share/scons/get_xmlrpc_config server')
main_env.Program('test','HostPoolTest.cc')
main_env.Program('test_hook','HostHookTest.cc')