virtual void SetUp() {
initialize_logger(LEVEL_WARN);
test_env.options.connect_timeout_s = 3;
test_env.options.request_timeout_s = 3;
test_env.options.retry_delay_s = 3;
test_env.options.enable_async_writes = true;
test_env.options.async_writes_max_request_size_kb = 128;
test_env.options.async_writes_max_requests = 8;
test_env.options.periodic_xcap_renewal_interval_s = 2;
ASSERT_TRUE(test_env.Start());
// Open a volume
volume = test_env.client->OpenVolume(
test_env.volume_name_,
NULL, // No SSL options.
test_env.options);
// Open a file.
file = volume->OpenFile(
test_env.user_credentials,
"/test_file",
static_cast<xtreemfs::pbrpc::SYSTEM_V_FCNTL>(
xtreemfs::pbrpc::SYSTEM_V_FCNTL_H_O_CREAT |
xtreemfs::pbrpc::SYSTEM_V_FCNTL_H_O_TRUNC |
xtreemfs::pbrpc::SYSTEM_V_FCNTL_H_O_RDWR));
}
// Main function fo whole program
int main(int argc, char **argv) {
signal(SIGINT, sigint_handler);
if (argc < 3) {
log_msg(LOG_ERROR, "[SERVER] Server need's two parameters\n");
log_msg(LOG_ERROR, "[SERVER] Usage: chess_server <listen_address> <port>\n");
return EXIT_FAILURE;
}
if (!atoi(argv[2])) {
log_msg(LOG_ERROR, "[SERVER] Invalid port %s to listen on\n", argv[2]);
log_msg(LOG_ERROR, "[SERVER] Usage: chess_server <listen_address> <port>\n");
return EXIT_FAILURE;
}
initialize_logger(), server_run(argv[1], atoi(argv[2]));
return EXIT_SUCCESS;
}
virtual void SetUp() {
initialize_logger(LEVEL_WARN);
kTestUUID_ = "uuid";
kTestPort_ = 12345;
user_credentials_.set_username("ClientImplementationTest");
user_credentials_.add_groups("ClientImplementationTest");
dir_.reset(new TestRPCServerDIRCustomMapping());
ASSERT_TRUE(dir_->Start());
client_.reset(Client::CreateClient(
dir_->GetAddress(),
user_credentials_,
NULL, // No SSL options.
options_));
// Start the client (a connection to the DIR service will be setup).
client_->Start();
}
// Run function of whole program
static void run(const char *config_filename) {
double max_z, min_z;
source_object *object;
double complex *optical_field;
// Initialize FFTW threads
fftw_init_threads();
// Load config to memory
load_config(config_filename);
// Initialize logger
initialize_logger(get_integer_value(CONF_LOGGER_DEBUG_MODE));
// Load source object
load_source_object(&object, get_string_value(CONF_OBJECT_POINTS_FILE));
// Initialize final optical field
initialize_optical_field(&optical_field);
// Extract z position extremes of source object
extract_object_proportions(object, &min_z, &max_z, OBJECT_DEPTH);
// Modified WRP method itself
perform_wrp_method(object, optical_field, min_z, max_z);
// Numerical reconstruction on hologram
perform_numerical_reconstruction(optical_field, min_z);
// Memory clear
log_info("Deleting all structures from memory\n");
free(optical_field);
delete_source_object(object);
delete_lookup_table();
delete_config();
}
explicit application_t(const std::string& name)
:_name(name),
logger(log4cxx::Logger::getLogger("application"))
{
initialize_logger();
}
/**
* Initializes the required resources.
*
* Should only be called once, right after starting.
*/
Code initialize(Window **window, Renderer **renderer) {
char log_buffer[MAXIMUM_STRING_SIZE];
Uint32 renderer_flags = 0;
initialize_logger();
initialize_profiler();
initialize_settings();
if (SDL_Init(SDL_INIT_FLAGS)) {
sprintf(log_buffer, "SDL initialization error: %s.", SDL_GetError());
log_message(log_buffer);
return CODE_ERROR;
}
SDL_ShowCursor(SDL_DISABLE);
initialize_joystick();
if (!TTF_WasInit()) {
if (TTF_Init()) {
sprintf(log_buffer, "TTF initialization error: %s.", SDL_GetError());
log_message(log_buffer);
return CODE_ERROR;
}
}
if ((IMG_Init(IMG_FLAGS) & IMG_FLAGS) != IMG_FLAGS) {
sprintf(log_buffer, "Failed to initialize required image support.");
log_message(log_buffer);
return CODE_ERROR;
}
/**
* The number of columns and the number of lines are fixed. However, the
* number of pixels we need for the screen is not. We find this number by
* experimenting before creating the window.
*/
/* Log the size of the window we are going to create. */
*window = create_window(&window_width, &window_height);
sprintf(log_buffer, "Created a %dx%d window.", window_width, window_height);
log_message(log_buffer);
if (*window == NULL) {
sprintf(log_buffer, "SDL initialization error: %s.", SDL_GetError());
log_message(log_buffer);
return CODE_ERROR;
}
if (initialize_fonts()) {
sprintf(log_buffer, "Failed to initialize fonts.");
log_message(log_buffer);
return CODE_ERROR;
}
if (initialize_font_metrics()) {
sprintf(log_buffer, "Failed to initialize font metrics.");
log_message(log_buffer);
return CODE_ERROR;
}
/* Must disable text input to prevent a name capture bug. */
SDL_StopTextInput();
set_window_title_and_icon(*window);
if (get_renderer_type() == RENDERER_HARDWARE) {
renderer_flags = SDL_RENDERER_ACCELERATED;
} else {
renderer_flags = SDL_RENDERER_SOFTWARE;
}
*renderer = SDL_CreateRenderer(*window, -1, renderer_flags);
set_color(*renderer, COLOR_DEFAULT_BACKGROUND);
clear(*renderer);
return CODE_OK;
}
int main(int argc, char *argv[]) {
int retval = 0;
wr_conf_t *conf=NULL;
char *WR_ROOT = argv[1];
//Initialize logger
if(initialize_logger(WR_LOG_FILE) == 0) {
LOG_DEBUG(DEBUG,"Logging started in %s file",WR_LOG_FILE);
} else {
printf("Logger initialization failed. Please make sure you have write permission on '/var/log/webroar' directory.");
}
//Allocate and initialize configuration structure
conf = wr_conf_read(WR_ROOT);
if(conf == NULL ) {
LOG_ERROR(FATAL,"Configuration reading failed.");
printf("Server not started.\nProblem with reading the configuration file. Kindly refer the log files for details.\n");
return -1;
}
#ifdef L_DEBUG
set_log_severity(DEBUG);
#else
set_log_severity(conf->server->log_level);
#endif
// Add Admin Panel
wr_conf_admin_panel_add(conf);
// Add staic file server
wr_conf_static_server_add(conf);
//TODO: Windows Portability?
signal(SIGINT, sigproc);
signal(SIGPIPE, SIG_IGN);
signal(SIGHUP, sigproc); /* catch hangup signal */
signal(SIGTERM, sigproc); /* catch terminate signal */
signal(SIGSEGV, crash_handler); /* set our handler for segfault */
// signal(SIGQUIT, crash_handler);
// signal(SIGILL, crash_handler);
// signal(SIGABRT, crash_handler);
// signal(SIGFPE, crash_handler);
// Initialize and start the Server to accept requests
retval = wr_svr_init(&server, conf);
if(retval<0) {
LOG_ERROR(FATAL,"Initialization of network server failed.");
printf("Server not started. Kindly refer the log files for details.\n");
return retval;
}
LOG_INFO("Network server successfully initialized on port %d",server->conf->server->port);
// Set keep alive flag
server->is_running = 1;
// Initialize contol port/sock path to recive control messages
retval = wr_ctl_init(server);
if(retval < 0) {
LOG_ERROR(FATAL,"Controller Initialization failed.");
printf("Server not started. Kindly refer the log files for details.\n");
wr_svr_free(server);
return retval;
}
LOG_INFO("Controller initialized");
// Fork processes and start 'webroar-workers's
wr_app_init(server);
//Daemonize the Server
daemonize();
LOG_DEBUG(4,"Done daemon");
redirect_standard_io();
// Start event loop
while(server->is_running) {
ev_loop(server->ebb_svr.loop,EVLOOP_ONESHOT);
}
// Cleanup
LOG_DEBUG(DEBUG,"Call cleanup");
cleanup(server);
return 0;
}
virtual void SetUp() {
initialize_logger(LEVEL_WARN);
}
void initialize_logger(std::string stringLevel,
std::string logfilePath,
LogLevel defaultLevel) {
initialize_logger(stringToLevel(stringLevel, defaultLevel), logfilePath);
}
/**
* Main function, starts NetworkManager backend.
*/
int main(int argc, char *argv[])
{
struct sigaction action;
int status = SS_RC_INITIALIZATION_FAILED;
/* logging for library during initialization, as we have no bus yet */
dbg = dbg_syslog;
/* initialize library */
if (!library_init(NULL))
{
library_deinit();
exit(SS_RC_LIBSTRONGSWAN_INTEGRITY);
}
if (lib->integrity &&
!lib->integrity->check_file(lib->integrity, "charon-nm", argv[0]))
{
dbg_syslog(DBG_DMN, 1, "integrity check of charon-nm failed");
library_deinit();
exit(SS_RC_DAEMON_INTEGRITY);
}
if (!libhydra_init("charon-nm"))
{
dbg_syslog(DBG_DMN, 1, "initialization failed - aborting charon-nm");
libhydra_deinit();
library_deinit();
exit(SS_RC_INITIALIZATION_FAILED);
}
if (!libcharon_init("charon-nm"))
{
dbg_syslog(DBG_DMN, 1, "initialization failed - aborting charon-nm");
goto deinit;
}
if (!lookup_uid_gid())
{
dbg_syslog(DBG_DMN, 1, "invalid uid/gid - aborting charon-nm");
goto deinit;
}
initialize_logger();
/* use random ports to avoid conflicts with regular charon */
lib->settings->set_int(lib->settings, "charon-nm.port", 0);
lib->settings->set_int(lib->settings, "charon-nm.port_natt_t", 0);
DBG1(DBG_DMN, "Starting charon NetworkManager backend (strongSwan "VERSION")");
if (lib->integrity)
{
DBG1(DBG_DMN, "integrity tests enabled:");
DBG1(DBG_DMN, "lib 'libstrongswan': passed file and segment integrity tests");
DBG1(DBG_DMN, "lib 'libhydra': passed file and segment integrity tests");
DBG1(DBG_DMN, "lib 'libcharon': passed file and segment integrity tests");
DBG1(DBG_DMN, "daemon 'charon-nm': passed file integrity test");
}
/* register NM backend to be loaded with plugins */
nm_backend_register();
/* initialize daemon */
if (!charon->initialize(charon,
lib->settings->get_str(lib->settings, "charon-nm.load", PLUGINS)))
{
DBG1(DBG_DMN, "initialization failed - aborting charon-nm");
goto deinit;
}
if (!charon->caps->drop(charon->caps))
{
DBG1(DBG_DMN, "capability dropping failed - aborting charon-nm");
goto deinit;
}
/* add handler for SEGV and ILL,
* INT and TERM are handled by sigwait() in run() */
action.sa_handler = segv_handler;
action.sa_flags = 0;
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGINT);
sigaddset(&action.sa_mask, SIGTERM);
sigaction(SIGSEGV, &action, NULL);
sigaction(SIGILL, &action, NULL);
sigaction(SIGBUS, &action, NULL);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
pthread_sigmask(SIG_SETMASK, &action.sa_mask, NULL);
/* start daemon (i.e. the threads in the thread-pool) */
charon->start(charon);
/* main thread goes to run loop */
run();
status = 0;
deinit:
libcharon_deinit();
libhydra_deinit();
library_deinit();
return status;
}
